spl/test.spl

[
"spl/stream.spl" import
"spl/http.spl" import
"spl/messaging.spl" import
"spl/server.spl" import
"spl/time.spl" import
"spl/httpserver/base.spl" import
"spl/linkedlist.spl" import


"SPL tester" =program-name

func main { int | with args ;

    def thing

    1 anew =thing

    "hi" 0 thing:unwrap:set;

    def thing2 thing:unwrap List:new:from =thing2

    "world" thing2:unwrap:push
    "hello" 0 thing2:unwrap:insert

    "printing first two words of 'hello hi world' (should be 'hello hi')" println
    " " print
    0 thing2:unwrap:get print " " print
    1 thing2:unwrap:get println
    "removing hello" println
    thing2:pop-front;
    "printing first two words again" println
    " " print
    0 thing2:unwrap:get print " " print
    1 thing2:unwrap:get println

    "" println
    "testing closures and func-ptrs" println

    def thingy 
    "heya1" =thingy
    "thingy println" dyn-read call

    "heya2" =thingy
    { | 
        thingy println 
    } call

    def ptr 
    &println =ptr
    "ptr works" ptr call
    &&println =ptr
    "ptr-ptr works" ptr call call
    thingy:&unwrap =ptr
    "unwrap-ptr works" ptr call println
    thingy:&&unwrap =ptr
    "unwrap-ptr-ptr works" ptr call call println


    "" println
    "testing if" println

    def a "test" =a
    def b "test" =b
    a b eq dup if {
        a " is equal to " b concat concat println
    } not if {
        a " is not equal to " b concat concat panic
    }

    a b assert-eq;

    "" println 
    "testing ranges & iterators: (0..30@5) + 1" println

    def range 5 (0 30 Range:new):set-step =range

    range:iter 
        { | 1 + } swap:map 
        { | _str println } swap:foreach

    "" println
    "testing Iter:sum of 5 10s" println

    0 5 Range:new:iter
        { | pop 10 } swap:map
        :sum 
        _str println

    "" println
    "testing MicroMap" println
    
    def map MicroMap:new =map
    "hey" "hello" map:set;
    "helloworld" "Hello, World" map:set;
    "{ " print
    { | with item ;
        "'" print
        0 item:get print
        "': '" print 
        1 item:get print
        "', " print
    } map:foreach
    "}" println

    "" println
    "Running with args: " print
    argv:iter
        { str | " " concat } swap:map
        &print swap:foreach

    "" println
    "testing stream" println

    def file "test.txt" 1 StreamTypes:file:create =file 
    "hi\n" :to-bytes file:write-exact; 
    file:close; null =file
    
    "" println
    "testing split" println
    { | println } (" " "hello how  are you" :split):foreach
    "" println

    use net:http:Request
    catch {
        "testing http" println;
        def req "data.tudbut.de" 80 "GET" "/spltest" Request:new =req
        req:send:body _str println;
    } { with e ;
        e:message println
        "it seems the internet is not available" println
    }
    "" println

    "testing cache" println
    2 cached-test _str println
    3 cached-test _str println
    2 cached-test _str println
    3 cached-test _str println
    "" println

    catch {
        "heya" throw
    } { with e ;
        e:message println
    }
    "" println

    "testing messages" println
    def bus messaging:Bus:new =bus
    bus:subscribe<"testmsg1" { | with message ; message:name print " called1 1" println }>
    bus:subscribe<"testmsg1" { | with message ; message:name print " called1 2" println }>
    bus:subscribe<"testmsg2" { | with message ; message:name print " called2 1" println }>
    bus:subscribe<"testmsg2" { | with message ; message:name print " called2 2" println }>
    "testmsg1" bus:publish
    "testmsg2" bus:publish
    "testmsg1" bus:publish
    "testmsg3" bus:publish

    "" println
    "testing threads" println

    def other-thread-done 0 =other-thread-done
    { |
        "i am in the other thread!!!" println
        1 =other-thread-done
    } fork
    while { other-thread-done not } { "waiting for the other thread..." println }

    "" println
    "testing tcp server" println

    " starting server thread" println
    { | 
        def server "0.0.0.0" 4075 net:server:Types:tcp:create =server
        while { 1 } {
            def stream server:accept =stream
            "Hello!" :to-bytes stream:write-exact;
            stream:close;
        }
    } fork;
    50 time:sleep;
    " starting client" println;
    def client "localhost" 4075 StreamTypes:tcp:create =client
    1024 client:read-to-end:to-str println;
    " ^ this should say 'Hello!'" println;
    
    "" println
    "testing string replace" println;

    "aba" "!!" "ababab" :replace println;
    " ^ should be !!bab." println;
    "aba" "!!" "aababab" :replace println;
    " ^ should be a!!bab." println;

    "" println;
    "testing string split" println;

    "ba" "abaabaabaa" :split:iter:join<", "> println;
    " ^ should be a, a, a, a" println;
    "ba" "abbaabbaababaa" :split:iter:join<", "> println;
    " ^ should be ab, ab, a, , a" println;

    "" println;
    "testing string find" println;

    "abba" "ababba" :find println;
    "^ should be 2" println;

    "" println;
    "testing readf" println;

    def array
    "Hello dear {}, {}?" "Hello dear friend, how are you?" (dup println;) :readf =array
    "Person was " 0 array:get concat println;
    "Question was " 1 array:get concat println;

    "" println;
    "testing http server" println;

    def server "0.0.0.0" 4076 net:http:Server:new =server
    { |
        while { 1 } {
            server
                :accept
                :read 
                :write-ok
                :write-str-body<"Hello! This was written to HTTP!">
                :finish
        }
    } fork
    def req "localhost" 4076 "GET" "/spltest" Request:new =req
    req:send:body _str println;

    "" println;
    "testing urlencoding";

    "hello! this is a test of URL encoding!" net:http:urlencode dup println;
    net:http:urldecode println;

    "" println;
    "testing linked lists" println;

    def list LinkedList:new =list
    "=> len of an empty list: " print;
    list:len println;

    "=> len of a list with one element: " print;
    list:push;<"Hello!">
    list:len println;

    "=> list should not have a next yet... " print;
    list:next null eq dup if { "ok" swap } not if { "BAD" } println 

    "=> element zero should be 'Hello!': " print list:get<0> println;
    
    "=> iter of list should start with that too: " print list:iter dup:next println;
    "=> then should be null: " print :next dup null eq if { pop "ok" } println;

    "=> list should contain 'Hello!': " print list:iter:join<", "> println;

    "=> with new element after that: " print 
    list:push;<"One!!">
    list:iter:join<", "> println;

    "=> pushing numbers 2..10: " print
    2 10 Range:new:iter:foreach;<{ | list:push; }>
    list:iter:join<", "> println;

    "=> popping 9: " print
    list:pop;
    list:iter:join<", "> println;
    "=> removing 5: " print
    list:remove;<5>
    list:iter:join<", "> println;
    "=> popping front: " print
    list:pop-front;
    list:iter:join<", "> println;

    "=> inserting 0 back: " print
    0 list:insert;<0>
    list:iter:join<", "> println;

    "=> inserting 5 back: " print
    5 list:insert;<5>
    list:iter:join<", "> println;
    

    ^ println
    "testing match" println

    "a -> b (0): " print "a" "b" match _str println
    "a -> a (1): " print "a" "a" match _str println
    "[a b] -> [a a] (0): " print [ "a" "b" ] [ "a" "a" ] match _str println
    "[a b] -> [a b] (1): " print [ "a" "b" ] [ "a" "b" ] match _str println

    def mtesta, mtestb

    "a => =mtesta (1): " print "a" &=mtesta match _str println
    "[a b] => [a =mtesta] (1): " print [ "a" "b" ] [ "a" &=mtesta ] match _str println
    "[b a] => [a =mtesta] (0): " print [ "b" "a" ] [ "a" &=mtesta ] match _str println
    "[a b] => [=mtesta a] (0): " print [ "b" "a" ] [ "a" &=mtesta ] match _str println
    "-> mtesta = (b) " mtesta _str concat println

    "^ok => ^ok (1): " print ^ok =>? ^ok _str println
    "^bad => ^ok (0): " print ^bad =>? ^ok _str println
    "[^bad a] => [^ok =mtestb] (0): " print [ ^bad "a" ] =>? [ ^ok &=mtestb ] _str println
    "[^ok b] => [^ok =mtestb] (1): " print [ ^ok "b" ] =>? [ ^ok &=mtestb ] _str println

    "-> mtestb = (b) " mtestb _str concat println

    def result, val

    [ ^ok "hello, world" ] =result

    result => [ ^ok &=val ]
    val println

    [ ^error "bad" ] =result

    catch Custom {
        result => [ ^ok &println ]
    } { with e ;
        e:message "match unsuccessful" eq if {
            "err value: " print
            result => [ ^error &println ]
        }
    }



    
    5 :foreach<{ | pop "" println }>
    
    
    ] dup :len 0 eq not if {
        "" println
        "!! something went wrong somewhere. the stack is not empty." println
        dyn-__dump
    }
    "you now have a chance to connect too: localhost :4075 :4076 - stopping in 5 seconds..." println;
    5000 time:sleep;
    100
}

func cached-test { mega | 1 "cached-test" cache<{ mega | with i ;
    i 2 *
    "calculated " i _str concat println
}>}