Test output for r7rs [ok]

Testing time: 1s

'/usr/home/chicken/salmonella/build/salmonella-run-publish/chicken/bin/csi' -script run.scm < /dev/null 2>&1

-- testing r7rs tests --------------------------------------------------------

    -- testing 2.1: Identifiers ----------------------------------------------
    #!(no-)fold-case ................................................. [ PASS]
    #!(no-)fold-case only affects subsequent reads from the same port  [ PASS]
    2 tests completed in 1/1000 seconds.
    2 out of 2 (100%) tests passed.
    -- done testing 2.1: Identifiers -----------------------------------------


    -- testing 4.1.7: Inclusion ----------------------------------------------

        -- testing include ---------------------------------------------------
        multiple filenames ........................................... [ PASS]
        case sensitivity ............................................. [ PASS]
        2 tests completed in 1/1000 seconds.
        2 out of 2 (100%) tests passed.
        -- done testing include ----------------------------------------------


        -- testing include-ci ------------------------------------------------
        multiple filenames ........................................... [ PASS]
        case sensitivity ............................................. [ PASS]
        2 tests completed in 0 seconds.
        2 out of 2 (100%) tests passed.
        -- done testing include-ci -------------------------------------------

    2 subgroups completed in 1/1000 seconds.
    2 out of 2 (100%) subgroups passed.
    -- done testing 4.1.7: Inclusion -----------------------------------------


    -- testing 6.2.6: numerical operations -----------------------------------

        -- testing floor/...truncate-remainder -------------------------------
        (receive (floor/ 5 2)) ....................................... [ PASS]
        (floor-quotient 5 2) ......................................... [ PASS]
        (floor-remainder 5 2) ........................................ [ PASS]
        (receive (floor/ -5 2)) ...................................... [ PASS]
        (floor-quotient -5 2) ........................................ [ PASS]
        (floor-remainder -5 2) ....................................... [ PASS]
        (receive (floor/ 5 -2)) ...................................... [ PASS]
        (floor-quotient 5 -2) ........................................ [ PASS]
        (floor-remainder 5 -2) ....................................... [ PASS]
        (receive (floor/ -5 -2)) ..................................... [ PASS]
        (floor-quotient -5 -2) ....................................... [ PASS]
        (floor-remainder -5 -2) ...................................... [ PASS]
        (receive (floor/ -5 -2.0)) ................................... [ PASS]
        (floor-quotient 123 10) ...................................... [ PASS]
        (floor-remainder 123 10) ..................................... [ PASS]
        (receive (floor/ 123 10)) .................................... [ PASS]
        (receive (floor/ 123 -10)) ................................... [ PASS]
        (receive (floor/ -123 10)) ................................... [ PASS]
        (receive (floor/ -123 -10)) .................................. [ PASS]
        (receive (truncate/ 5 2)) .................................... [ PASS]
        (truncate-quotient 5 2) ...................................... [ PASS]
        (truncate-remainder 5 2) ..................................... [ PASS]
        (receive (truncate/ -5 2)) ................................... [ PASS]
        (truncate-quotient -5 2) ..................................... [ PASS]
        (truncate-remainder -5 2) .................................... [ PASS]
        (receive (truncate/ 5 -2)) ................................... [ PASS]
        (truncate-quotient 5 -2) ..................................... [ PASS]
        (truncate-remainder 5 -2) .................................... [ PASS]
        (receive (truncate/ -5 -2)) .................................. [ PASS]
        (truncate-quotient -5 -2) .................................... [ PASS]
        (truncate-remainder -5 -2) ................................... [ PASS]
        (receive (truncate/ -5.0 -2)) ................................ [ PASS]
        (truncate-quotient -5.0 -2) .................................. [ PASS]
        (truncate-remainder -5.0 -2) ................................. [ PASS]
        (truncate-quotient 123 10) ................................... [ PASS]
        (truncate-remainder 123 10) .................................. [ PASS]
        (receive (truncate/ 123 10)) ................................. [ PASS]
        (receive (truncate/ 123 -10)) ................................ [ PASS]
        (receive (truncate/ -123 10)) ................................ [ PASS]
        (receive (truncate/ -123 -10)) ............................... [ PASS]
        40 tests completed in 1/500 seconds.
        40 out of 40 (100%) tests passed.
        -- done testing floor/...truncate-remainder --------------------------


        -- testing quotient, remainder and modulo ----------------------------
        (modulo 13 4) ................................................ [ PASS]
        (remainder 13 4) ............................................. [ PASS]
        (modulo -13 4) ............................................... [ PASS]
        (remainder -13 4) ............................................ [ PASS]
        (modulo 13 -4) ............................................... [ PASS]
        (remainder 13 -4) ............................................ [ PASS]
        (modulo -13 -4) .............................................. [ PASS]
        (remainder -13 -4) ........................................... [ PASS]
        (remainder -13 -4.0) ......................................... [ PASS]
        9 tests completed in 0 seconds.
        9 out of 9 (100%) tests passed.
        -- done testing quotient, remainder and modulo -----------------------


        -- testing square ----------------------------------------------------
        (square 1) ................................................... [ PASS]
        (square 4) ................................................... [ PASS]
        (square 4.0) ................................................. [ PASS]
        3 tests completed in 1/1000 seconds.
        3 out of 3 (100%) tests passed.
        -- done testing square -----------------------------------------------

    3 subgroups completed in 1/250 seconds.
    3 out of 3 (100%) subgroups passed.
    -- done testing 6.2.6: numerical operations ------------------------------


    -- testing 6.3: booleans -------------------------------------------------

        -- testing not -------------------------------------------------------
        (not #t) ..................................................... [ PASS]
        (not 3) ...................................................... [ PASS]
        (not (list 3)) ............................................... [ PASS]
        (not #f) ..................................................... [ PASS]
        (not '()) .................................................... [ PASS]
        (not (list)) ................................................. [ PASS]
        (not 'nil) ................................................... [ PASS]
        (not) ........................................................ [ PASS]
        (not 1 2) .................................................... [ PASS]
        9 tests completed in 0 seconds.
        9 out of 9 (100%) tests passed.
        -- done testing not --------------------------------------------------


        -- testing long boolean literals -------------------------------------
        (read-from-string "#t") ...................................... [ PASS]
        (read-from-string "#f") ...................................... [ PASS]
        (read-from-string "#true") ................................... [ PASS]
        (read-from-string "#false") .................................. [ PASS]
        (read-from-string "#faux") ................................... [ PASS]
        5 tests completed in 1/1000 seconds.
        5 out of 5 (100%) tests passed.
        -- done testing long boolean literals --------------------------------


        -- testing boolean=? -------------------------------------------------
        (boolean=? #t #t) ............................................ [ PASS]
        (boolean=? #t #t #t #t) ...................................... [ PASS]
        (boolean=? #f #f) ............................................ [ PASS]
        (boolean=? #f #f #f #f) ...................................... [ PASS]
        (boolean=? #f #t) ............................................ [ PASS]
        (boolean=? #f #t #t #t) ...................................... [ PASS]
        (boolean=? #f #f #t #t) ...................................... [ PASS]
        (boolean=? #f #f #f #t) ...................................... [ PASS]
        (boolean=? #t #f #f #f) ...................................... [ PASS]
        (boolean=? #t #f #f #t) ...................................... [ PASS]
        (boolean=? #t #t #f #t) ...................................... [ PASS]
        (boolean=? #f #f #f #t) ...................................... [ PASS]
        (boolean=? #f #t #f #f) ...................................... [ PASS]
        (boolean=? #f) ............................................... [ PASS]
        (boolean=? #f 1) ............................................. [ PASS]
        no shortcutting .............................................. [ PASS]
        16 tests completed in 1/1000 seconds.
        16 out of 16 (100%) tests passed.
        -- done testing boolean=? --------------------------------------------

    3 subgroups completed in 3/1000 seconds.
    3 out of 3 (100%) subgroups passed.
    -- done testing 6.3: booleans --------------------------------------------


    -- testing 6.4: pairs and lists ------------------------------------------

        -- testing pair? -----------------------------------------------------
        (pair? '(a . b)) ............................................. [ PASS]
        (pair? '(a b c)) ............................................. [ PASS]
        (pair? '()) .................................................. [ PASS]
        (pair? '#(a b)) .............................................. [ PASS]
        (pair? #f) ................................................... [ PASS]
        (pair? #t) ................................................... [ PASS]
        (pair? "some string") ........................................ [ PASS]
        (pair? 123) .................................................. [ PASS]
        8 tests completed in 1/1000 seconds.
        8 out of 8 (100%) tests passed.
        -- done testing pair? ------------------------------------------------


        -- testing cons ------------------------------------------------------
        (cons 'a '()) ................................................ [ PASS]
        (cons '(a) '(b c d)) ......................................... [ PASS]
        (cons "a" '(b c)) ............................................ [ PASS]
        (cons 'a 3) .................................................. [ PASS]
        (cons '(a b) 'c) ............................................. [ PASS]
        5 tests completed in 0 seconds.
        5 out of 5 (100%) tests passed.
        -- done testing cons -------------------------------------------------


        -- testing car -------------------------------------------------------
        (car '(a b c)) ............................................... [ PASS]
        (car '((a) b c d)) ........................................... [ PASS]
        (car '(1 . 2)) ............................................... [ PASS]
        (car '()) .................................................... [ PASS]
        (car '#(1 2 3)) .............................................. [ PASS]
        (car "not a pair") ........................................... [ PASS]
        6 tests completed in 1/1000 seconds.
        6 out of 6 (100%) tests passed.
        -- done testing car --------------------------------------------------


        -- testing cdr -------------------------------------------------------
        (cdr '((a) b c d)) ........................................... [ PASS]
        (cdr '(1 . 2)) ............................................... [ PASS]
        (cdr '()) .................................................... [ PASS]
        (cdr '#(1 2 3)) .............................................. [ PASS]
        (cdr "not a pair") ........................................... [ PASS]
        5 tests completed in 0 seconds.
        5 out of 5 (100%) tests passed.
        -- done testing cdr --------------------------------------------------


        -- testing set-car! --------------------------------------------------
        (car res) .................................................... [ PASS]
        (car (f)) .................................................... [ PASS]
        (set-car! 'x 'y) ............................................. [ PASS]
        3 tests completed in 1/1000 seconds.
        3 out of 3 (100%) tests passed.
        -- done testing set-car! ---------------------------------------------


        -- testing set-cdr! --------------------------------------------------
        (cdr res) .................................................... [ PASS]
        (cdr (f)) .................................................... [ PASS]
        (set-cdr! 'x 'y) ............................................. [ PASS]
        3 tests completed in 0 seconds.
        3 out of 3 (100%) tests passed.
        -- done testing set-cdr! ---------------------------------------------


        -- testing c..r (base) -----------------------------------------------
        (caar '((x) y)) .............................................. [ PASS]
        (caar '(x y)) ................................................ [ PASS]
        (cadr '((x) y)) .............................................. [ PASS]
        (cadr '(x)) .................................................. [ PASS]
        (cdar '((x) y)) .............................................. [ PASS]
        (cdar '(x)) .................................................. [ PASS]
        (cddr '((x) y)) .............................................. [ PASS]
        (cddr '(x)) .................................................. [ PASS]
        8 tests completed in 1/1000 seconds.
        8 out of 8 (100%) tests passed.
        -- done testing c..r (base) ------------------------------------------


        -- testing null? -----------------------------------------------------
        (null? '()) .................................................. [ PASS]
        (null? (list)) ............................................... [ PASS]
        (null? '(a)) ................................................. [ PASS]
        (null? 'a) ................................................... [ PASS]
        (null? '#()) ................................................. [ PASS]
        (null? "foo") ................................................ [ PASS]
        6 tests completed in 0 seconds.
        6 out of 6 (100%) tests passed.
        -- done testing null? ------------------------------------------------


        -- testing list? -----------------------------------------------------
        (list? '(a b c)) ............................................. [ PASS]
        (list? (list 'a 'b 'c)) ...................................... [ PASS]
        (list? '()) .................................................. [ PASS]
        (list? '(a . b)) ............................................. [ PASS]
        (list? x) .................................................... [ PASS]
        (list? 'a) ................................................... [ PASS]
        (list? '#()) ................................................. [ PASS]
        (list? "foo") ................................................ [ PASS]
        8 tests completed in 1/1000 seconds.
        8 out of 8 (100%) tests passed.
        -- done testing list? ------------------------------------------------


        -- testing make-list -------------------------------------------------
        (make-list) .................................................. [ PASS]
        (make-list 0) ................................................ [ PASS]
        (make-list 1) ................................................ [ PASS]
        (make-list 1 #f) ............................................. [ PASS]
        (make-list 1 2 3) ............................................ [ PASS]
        (make-list 2 3) .............................................. [ PASS]
        (make-list 0 3) .............................................. [ PASS]
        (make-list -1 3) ............................................. [ PASS]
        (make-list #f 3) ............................................. [ PASS]
        9 tests completed in 0 seconds.
        9 out of 9 (100%) tests passed.
        -- done testing make-list --------------------------------------------


        -- testing list ------------------------------------------------------
        (list 'a (+ 3 4) 'c) ......................................... [ PASS]
        (list) ....................................................... [ PASS]
        (list #f) .................................................... [ PASS]
        (list 'a 'b 'c) .............................................. [ PASS]
        4 tests completed in 1/1000 seconds.
        4 out of 4 (100%) tests passed.
        -- done testing list -------------------------------------------------


        -- testing length ----------------------------------------------------
        (length '(a b c)) ............................................ [ PASS]
        (length '(a (b) (c d e))) .................................... [ PASS]
        (length '()) ................................................. [ PASS]
        (length '(x . y)) ............................................ [ PASS]
        (length '#(x y)) ............................................. [ PASS]
        (length "foo") ............................................... [ PASS]
        6 tests completed in 0 seconds.
        6 out of 6 (100%) tests passed.
        -- done testing length -----------------------------------------------


        -- testing append ----------------------------------------------------
        (append '(x) '(y)) ........................................... [ PASS]
        (append '(a) '(b c d)) ....................................... [ PASS]
        (append '(a (b)) '((c))) ..................................... [ PASS]
        (append '(a b) '(c . d)) ..................................... [ PASS]
        (append '() 'a) .............................................. [ PASS]
        (append '(a b) 'c) ........................................... [ PASS]
        (append 'x '()) .............................................. [ PASS]
        (append '(x) 'y '()) ......................................... [ PASS]
        8 tests completed in 1/1000 seconds.
        8 out of 8 (100%) tests passed.
        -- done testing append -----------------------------------------------


        -- testing reverse ---------------------------------------------------
        (reverse '(a b c)) ........................................... [ PASS]
        (reverse '(a (b c) d (e (f)))) ............................... [ PASS]
        (reverse '()) ................................................ [ PASS]
        (reverse '(a . b)) ........................................... [ PASS]
        (reverse '(a b) '(c d)) ...................................... [ PASS]
        (reverse 'a) ................................................. [ PASS]
        (reverse '#(a b c)) .......................................... [ PASS]
        (reverse "foo") .............................................. [ PASS]
        8 tests completed in 0 seconds.
        8 out of 8 (100%) tests passed.
        -- done testing reverse ----------------------------------------------


        -- testing list-tail -------------------------------------------------
        (list-tail '(a b c d e f) 0) ................................. [ PASS]
        (list-tail '(a b c d e f) 3) ................................. [ PASS]
        (list-tail '(a b c d e f) 6) ................................. [ PASS]
        (list-tail '() 0) ............................................ [ PASS]
        (list-tail '(a b c d e f) -1) ................................ [ PASS]
        (list-tail '(a b c d e f) 7) ................................. [ PASS]
        (list-tail '(a b c d e . f) 6) ............................... [ PASS]
        7 tests completed in 1/1000 seconds.
        7 out of 7 (100%) tests passed.
        -- done testing list-tail --------------------------------------------


        -- testing list-ref --------------------------------------------------
        (list-ref '(a b c d) 0) ...................................... [ PASS]
        (list-ref '(a b c d) 1) ...................................... [ PASS]
        (list-ref '(a b c d) 2) ...................................... [ PASS]
        (list-ref '(a b c d) 3) ...................................... [ PASS]
        (list-ref '(a b c d) 4) ...................................... [ PASS]
        (list-ref '(a b c d) -1) ..................................... [ PASS]
        6 tests completed in 0 seconds.
        6 out of 6 (100%) tests passed.
        -- done testing list-ref ---------------------------------------------


        -- testing list-set! -------------------------------------------------
        (cdr ls) ..................................................... [ PASS]
        (list-set! (list 1 2 3) 3 'foo) .............................. [ PASS]
        2 tests completed in 1/1000 seconds.
        2 out of 2 (100%) tests passed.
        -- done testing list-set! --------------------------------------------


        -- testing mem* ------------------------------------------------------
        (memq 'a '(a b c)) ........................................... [ PASS]
        (memq 'b '(a b c)) ........................................... [ PASS]
        (memq 'a '(b c d)) ........................................... [ PASS]
        (memq (list 'a) '(b (a) c)) .................................. [ PASS]
        (member (list 'a) '(b (a) c)) ................................ [ PASS]
        (member "B" '("a" "b" "c") string-ci=?) ...................... [ PASS]
        (memq 101 '(100 101 102)) .................................... [ PASS]
        (memv 101 '(100 101 102)) .................................... [ PASS]
        8 tests completed in 0 seconds.
        8 out of 8 (100%) tests passed.
        -- done testing mem* -------------------------------------------------


        -- testing ass* ------------------------------------------------------
        (assq 'a e) .................................................. [ PASS]
        (assq 'b e) .................................................. [ PASS]
        (assq 'd e) .................................................. [ PASS]
        (assq (list 'a) '(((a)) ((b)) ((c)))) ........................ [ PASS]
        (assoc (list 'a) '(((a)) ((b)) ((c)))) ....................... [ PASS]
        (assoc 2.0 '((1 1) (2 4) (3 9)) =) ........................... [ PASS]
        (assq 5 '((2 3) (5 7) (11 13))) .............................. [ PASS]
        (assv 5 '((2 3) (5 7) (11 13))) .............................. [ PASS]
        (assq 5 '(5 6 7)) ............................................ [ PASS]
        (assv 5 '(5 6 7)) ............................................ [ PASS]
        (assoc 5 '(5 6 7)) ........................................... [ PASS]
        11 tests completed in 1/1000 seconds.
        11 out of 11 (100%) tests passed.
        -- done testing ass* -------------------------------------------------


        -- testing list-copy -------------------------------------------------
        (list b) ..................................................... [ PASS]
        (list a) ..................................................... [ PASS]
        2 tests completed in 0 seconds.
        2 out of 2 (100%) tests passed.
        -- done testing list-copy --------------------------------------------

    20 subgroups completed in 1/100 seconds.
    20 out of 20 (100%) subgroups passed.
    -- done testing 6.4: pairs and lists -------------------------------------


    -- testing 6.5: Symbols --------------------------------------------------

        -- testing symbol=? --------------------------------------------------
        (symbol=?) ................................................... [ PASS]
        (symbol=? 'a) ................................................ [ PASS]
        (symbol=? 'a 1) .............................................. [ PASS]
        (symbol=? 'a 'b 1) ........................................... [ PASS]
        (symbol=? '|| '||) ........................................... [ PASS]
        (symbol=? '|a b| '|a b|) ..................................... [ PASS]
        (symbol=? 'a 'a) ............................................. [ PASS]
        (symbol=? 'a 'b) ............................................. [ PASS]
        (symbol=? 'a 'a 'a) .......................................... [ PASS]
        (symbol=? 'a 'a 'b) .......................................... [ PASS]
        (symbol=? 'a 'b 'b) .......................................... [ PASS]
        (symbol=? 'a 'a 'a 'a) ....................................... [ PASS]
        (symbol=? 'a 'a 'a 'b) ....................................... [ PASS]
        (symbol=? 'a 'a 'b 'b) ....................................... [ PASS]
        (symbol=? 'a 'b 'b 'b) ....................................... [ PASS]
        15 tests completed in 1/1000 seconds.
        15 out of 15 (100%) tests passed.
        -- done testing symbol=? ---------------------------------------------

    1 subgroup completed in 1/500 seconds.
    1 out of 1 (100%) subgroup passed.
    -- done testing 6.5: Symbols ---------------------------------------------


    -- testing 6.6: characters -----------------------------------------------

        -- testing char*? ----------------------------------------------------
        arity ........................................................ [ PASS]
        type check ................................................... [ PASS]
        no shortcutting .............................................. [ PASS]
        (char? 1) .................................................... [ PASS]
        (char? #\a) .................................................. [ PASS]
        (char=? #\a #\a) ............................................. [ PASS]
        (char=? #\a #\b) ............................................. [ PASS]
        (char=? #\a #\a #\a) ......................................... [ PASS]
        (char=? #\a #\b #\a) ......................................... [ PASS]
        (char=? #\a #\a #\b) ......................................... [ PASS]
        (char=? #\a #\a #\a #\a) ..................................... [ PASS]
        (char=? #\a #\b #\a #\a) ..................................... [ PASS]
        (char=? #\a #\a #\a #\b) ..................................... [ PASS]
        (char<? #\a #\b #\c) ......................................... [ PASS]
        (char<? #\a #\b #\b) ......................................... [ PASS]
        (char<=? #\a #\b #\b) ........................................ [ PASS]
        (char<=? #\a #\b #\a) ........................................ [ PASS]
        (char>? #\c #\b #\a) ......................................... [ PASS]
        (char>? #\a #\a #\a) ......................................... [ PASS]
        (char>=? #\b #\b #\a) ........................................ [ PASS]
        (char>=? #\b #\a #\b) ........................................ [ PASS]
        21 tests completed in 1/1000 seconds.
        21 out of 21 (100%) tests passed.
        -- done testing char*? -----------------------------------------------

    1 subgroup completed in 1/1000 seconds.
    1 out of 1 (100%) subgroup passed.
    -- done testing 6.6: characters ------------------------------------------


    -- testing 6.7: strings --------------------------------------------------

        -- testing string*? --------------------------------------------------
        arity ........................................................ [ PASS]
        type check ................................................... [ PASS]
        no shortcutting .............................................. [ PASS]
        (string? 1) .................................................. [ PASS]
        (string? "a") ................................................ [ PASS]
        (string=? "a" "a") ........................................... [ PASS]
        (string=? "a" "b") ........................................... [ PASS]
        (string=? "a" "a" "a") ....................................... [ PASS]
        (string=? "a" "b" "a") ....................................... [ PASS]
        (string=? "a" "a" "b") ....................................... [ PASS]
        (string=? "a" "a" "a" "a") ................................... [ PASS]
        (string=? "a" "b" "a" "a") ................................... [ PASS]
        (string=? "a" "a" "a" "b") ................................... [ PASS]
        (string<? "a" "b" "c") ....................................... [ PASS]
        (string<? "a" "b" "b") ....................................... [ PASS]
        (string<=? "a" "b" "b") ...................................... [ PASS]
        (string<=? "a" "b" "a") ...................................... [ PASS]
        (string>? "c" "b" "a") ....................................... [ PASS]
        (string>? "c" "b" "b") ....................................... [ PASS]
        (string>=? "b" "b" "a") ...................................... [ PASS]
        (string>=? "b" "a" "b") ...................................... [ PASS]
        21 tests completed in 1/500 seconds.
        21 out of 21 (100%) tests passed.
        -- done testing string*? ---------------------------------------------


        -- testing string->list ----------------------------------------------
        (string->list "" 1) .......................................... [ PASS]
        (string->list "a" 1 2) ....................................... [ PASS]
        (string->list "a") ........................................... [ PASS]
        (string->list "a" 1) ......................................... [ PASS]
        (string->list "abc" 1 2) ..................................... [ PASS]
        (string->list "abc" 2 2) ..................................... [ PASS]
        6 tests completed in 0 seconds.
        6 out of 6 (100%) tests passed.
        -- done testing string->list -----------------------------------------


        -- testing string->vector --------------------------------------------
        (string->vector "" 1) ........................................ [ PASS]
        (string->vector "a" 0 2) ..................................... [ PASS]
        (string->vector "a") ......................................... [ PASS]
        (string->vector "a" 1 1) ..................................... [ PASS]
        (string->vector "abc" 1 2) ................................... [ PASS]
        (string->vector "abc" 2 2) ................................... [ PASS]
        6 tests completed in 1/1000 seconds.
        6 out of 6 (100%) tests passed.
        -- done testing string->vector ---------------------------------------


        -- testing vector->string --------------------------------------------
        (vector->string #() 1) ....................................... [ PASS]
        (vector->string #(1)) ........................................ [ PASS]
        (vector->string #(#\a) 0 2) .................................. [ PASS]
        (vector->string #(#\a)) ...................................... [ PASS]
        (vector->string #(#\a) 1 1) .................................. [ PASS]
        (vector->string #(#\a #\b #\c) 1 2) .......................... [ PASS]
        (vector->string #(#\a #\b #\c) 2 2) .......................... [ PASS]
        7 tests completed in 0 seconds.
        7 out of 7 (100%) tests passed.
        -- done testing vector->string ---------------------------------------

    4 subgroups completed in 3/1000 seconds.
    4 out of 4 (100%) subgroups passed.
    -- done testing 6.7: strings ---------------------------------------------


    -- testing 6.8: vectors --------------------------------------------------

        -- testing vector-copy -----------------------------------------------
        (vector-copy "") ............................................. [ PASS]
        (vector-copy #() #()) ........................................ [ PASS]
        (vector-copy #() 1) .......................................... [ PASS]
        (vector-copy #(0) -1) ........................................ [ PASS]
        (vector-copy #(0) 0 2) ....................................... [ PASS]
        (vector-copy #()) ............................................ [ PASS]
        (vector-copy #(0 1 2)) ....................................... [ PASS]
        (vector-copy #(0 1 2) 1) ..................................... [ PASS]
        (vector-copy #(0 1 2) 1 2) ................................... [ PASS]
        (vector-copy #(0 1 2) 1 1) ................................... [ PASS]
        10 tests completed in 0 seconds.
        10 out of 10 (100%) tests passed.
        -- done testing vector-copy ------------------------------------------


        -- testing vector-copy! ----------------------------------------------
        (vector-copy! "") ............................................ [ PASS]
        (vector-copy! #(0) 0 "") ..................................... [ PASS]
        (vector-copy! #() #() 0) ..................................... [ PASS]
        (vector-copy! #() 0 #(0)) .................................... [ PASS]
        (vector-copy! #(0) 1 #(0)) ................................... [ PASS]
        (vector-copy! #(0) 1 #(0) 0) ................................. [ PASS]
        (vector-copy! #(0) 0 #(0) 0 2) ............................... [ PASS]
        (vector-copy! #(0) 0 #(0 1) 1 0) ............................. [ PASS]
        (vector-copy! #() 0 #()) ..................................... [ PASS]
        (vector-copy! t 1 f 1 1) ..................................... [ PASS]
        (vector-copy! t 0 f 0 1) ..................................... [ PASS]
        (vector-copy! t 0 f 1 3) ..................................... [ PASS]
        (vector-copy! t 1 f 1) ....................................... [ PASS]
        (vector-copy! t 0 f) ......................................... [ PASS]
        14 tests completed in 1/1000 seconds.
        14 out of 14 (100%) tests passed.
        -- done testing vector-copy! -----------------------------------------


        -- testing vector-append ---------------------------------------------
        (vector-append "") ........................................... [ PASS]
        (vector-append #() 1) ........................................ [ PASS]
        (vector-append) .............................................. [ PASS]
        (vector-append #(0)) ......................................... [ PASS]
        (vector-append #() #()) ...................................... [ PASS]
        (vector-append #(0) #(1)) .................................... [ PASS]
        (vector-append #(0 1) #(2 3) #(4 5)) ......................... [ PASS]
        7 tests completed in 1/1000 seconds.
        7 out of 7 (100%) tests passed.
        -- done testing vector-append ----------------------------------------


        -- testing vector->list ----------------------------------------------
        (vector->list "") ............................................ [ PASS]
        (vector->list #() 1) ......................................... [ PASS]
        (vector->list #()) ........................................... [ PASS]
        (vector->list #(0 1 2)) ...................................... [ PASS]
        (vector->list #(0 1 2) 1) .................................... [ PASS]
        (vector->list #(0 1 2) 1 2) .................................. [ PASS]
        (vector->list #(0 1 2) 2 2) .................................. [ PASS]
        7 tests completed in 0 seconds.
        7 out of 7 (100%) tests passed.
        -- done testing vector->list -----------------------------------------

    4 subgroups completed in 1/500 seconds.
    4 out of 4 (100%) subgroups passed.
    -- done testing 6.8: vectors ---------------------------------------------


    -- testing 6.9: bytevectors ----------------------------------------------

        -- testing bytevector-copy -------------------------------------------
        (bytevector-copy "") ......................................... [ PASS]
        (bytevector-copy #u8() #u8()) ................................ [ PASS]
        (bytevector-copy #u8() 1) .................................... [ PASS]
        (bytevector-copy #u8(0) -1) .................................. [ PASS]
        (bytevector-copy #u8(0) 0 2) ................................. [ PASS]
        (bytevector-copy #u8()) ...................................... [ PASS]
        (bytevector-copy #u8(0 1 2)) ................................. [ PASS]
        (bytevector-copy #u8(0 1 2) 1) ............................... [ PASS]
        (bytevector-copy #u8(0 1 2) 1 2) ............................. [ PASS]
        (bytevector-copy #u8(0 1 2) 1 1) ............................. [ PASS]
        10 tests completed in 1/1000 seconds.
        10 out of 10 (100%) tests passed.
        -- done testing bytevector-copy --------------------------------------


        -- testing bytevector-copy! ------------------------------------------
        (bytevector-copy! "") ........................................ [ PASS]
        (bytevector-copy! #u8(0) 0 "") ............................... [ PASS]
        (bytevector-copy! #u8() #u8() 0) ............................. [ PASS]
        (bytevector-copy! #u8() 0 #u8(0)) ............................ [ PASS]
        (bytevector-copy! #u8(0) 1 #u8(0)) ........................... [ PASS]
        (bytevector-copy! #u8(0) 1 #u8(0) 0) ......................... [ PASS]
        (bytevector-copy! #u8(0) 0 #u8(0) 0 2) ....................... [ PASS]
        (bytevector-copy! #u8(0) 0 #u8(0 1) 1 0) ..................... [ PASS]
        (bytevector-copy! #u8() 0 #u8()) ............................. [ PASS]
        (bytevector-copy! t 1 f 1 1) ................................. [ PASS]
        (bytevector-copy! t 0 f 0 1) ................................. [ PASS]
        (bytevector-copy! t 0 f 1 3) ................................. [ PASS]
        (bytevector-copy! t 1 f 1) ................................... [ PASS]
        (bytevector-copy! t 0 f) ..................................... [ PASS]
        14 tests completed in 1/1000 seconds.
        14 out of 14 (100%) tests passed.
        -- done testing bytevector-copy! -------------------------------------


        -- testing bytevector-append -----------------------------------------
        (bytevector-append #u8() 1) .................................. [ PASS]
        (bytevector-append) .......................................... [ PASS]
        (bytevector-append #u8(0)) ................................... [ PASS]
        (bytevector-append #u8() #u8()) .............................. [ PASS]
        (bytevector-append #u8(0) #u8(1)) ............................ [ PASS]
        (bytevector-append #u8(0 1) #u8(2 3) #u8(4 5)) ............... [ PASS]
        6 tests completed in 0 seconds.
        6 out of 6 (100%) tests passed.
        -- done testing bytevector-append ------------------------------------

    3 subgroups completed in 1/500 seconds.
    3 out of 3 (100%) subgroups passed.
    -- done testing 6.9: bytevectors -----------------------------------------


    -- testing 6.10: Control features ----------------------------------------

        -- testing string-map ------------------------------------------------
        (string-map "abc") ........................................... [ PASS]
        (string-map values) .......................................... [ PASS]
        (string-map values '(1 2 3)) ................................. [ PASS]
        (string-map (constantly 1) "abc") ............................ [ PASS]
        (string-map values "") ....................................... [ PASS]
        (string-map values "abc") .................................... [ PASS]
        (string-map (constantly #\a) "abc") .......................... [ PASS]
        (string-map char-add1 "abc") ................................. [ PASS]
        (string-map 1st "abc" "123") ................................. [ PASS]
        (string-map 2nd "abc" "123") ................................. [ PASS]
        (string-map 1st "abc" "123456") .............................. [ PASS]
        (string-map 2nd "abc" "123456") .............................. [ PASS]
        12 tests completed in 1/1000 seconds.
        12 out of 12 (100%) tests passed.
        -- done testing string-map -------------------------------------------


        -- testing string-for-each -------------------------------------------
        (string-for-each "abc") ...................................... [ PASS]
        (string-for-each values) ..................................... [ PASS]
        (string-for-each values '(1 2 3)) ............................ [ PASS]
        (acc string-for-each values "") .............................. [ PASS]
        (acc string-for-each values "abc") ........................... [ PASS]
        (acc string-for-each char-add1 "abc") ........................ [ PASS]
        (acc string-for-each list "abc" "123") ....................... [ PASS]
        (acc string-for-each 2nd "abc" "123") ........................ [ PASS]
        (acc string-for-each 1st "abc" "123456") ..................... [ PASS]
        (acc string-for-each 2nd "abc" "123456") ..................... [ PASS]
        10 tests completed in 3/1000 seconds.
        10 out of 10 (100%) tests passed.
        -- done testing string-for-each --------------------------------------


        -- testing vector-map ------------------------------------------------
        (vector-map #(1 2 3)) ........................................ [ PASS]
        (vector-map values) .......................................... [ PASS]
        (vector-map values '(1 2 3)) ................................. [ PASS]
        (vector-map values #()) ...................................... [ PASS]
        (vector-map values #(1 2 3)) ................................. [ PASS]
        (vector-map (constantly 1) #(1 2 3)) ......................... [ PASS]
        (vector-map add1 #(1 2 3)) ................................... [ PASS]
        (vector-map 1st #(1 2 3) #(4 5 6)) ........................... [ PASS]
        (vector-map 2nd #(1 2 3) #(4 5 6)) ........................... [ PASS]
        (vector-map 1st #(1 2 3) #(4 5 6 7 8 9)) ..................... [ PASS]
        (vector-map 2nd #(1 2 3) #(4 5 6 7 8 9)) ..................... [ PASS]
        11 tests completed in 1/1000 seconds.
        11 out of 11 (100%) tests passed.
        -- done testing vector-map -------------------------------------------


        -- testing vector-for-each -------------------------------------------
        (vector-for-each #(1 2 3)) ................................... [ PASS]
        (vector-for-each values) ..................................... [ PASS]
        (vector-for-each values '(1 2 3)) ............................ [ PASS]
        (acc vector-for-each values #()) ............................. [ PASS]
        (acc vector-for-each values #(1 2 3)) ........................ [ PASS]
        (acc vector-for-each add1 #(1 2 3)) .......................... [ PASS]
        (acc vector-for-each list #(1 2 3) #(4 5 6)) ................. [ PASS]
        (acc vector-for-each 2nd #(1 2 3) #(4 5 6)) .................. [ PASS]
        (acc vector-for-each 1st #(1 2 3) #(4 5 6 7 8 9)) ............ [ PASS]
        (acc vector-for-each 2nd #(1 2 3) #(4 5 6 7 8 9)) ............ [ PASS]
        10 tests completed in 1/1000 seconds.
        10 out of 10 (100%) tests passed.
        -- done testing vector-for-each --------------------------------------

    4 subgroups completed in 3/500 seconds.
    4 out of 4 (100%) subgroups passed.
    -- done testing 6.10: Control features -----------------------------------


    -- testing 6.13: Input ---------------------------------------------------
    read-string returns eof-object for empty string .................. [ PASS]
    read-bytevector returns eof-object for empty string .............. [ PASS]
    2 tests completed in 0 seconds.
    2 out of 2 (100%) tests passed.
    -- done testing 6.13: Input ----------------------------------------------


    -- testing exceptions ----------------------------------------------------
    with-exception-handler (escape) .................................. [ PASS]
    with-exception-handler (return) .................................. [ PASS]
    with-exception-handler (raise) ................................... [ PASS]
    with-exception-handler (raise-continuable) ....................... [ PASS]
    error-object? (#f) ............................................... [ PASS]
    error-object? (#t) ............................................... [ PASS]
    error-object-message ............................................. [ PASS]
    error-object-irritants ........................................... [ PASS]
    read-error? (#f) ................................................. [ PASS]
    read-error? (#t) ................................................. [ PASS]
    file-error? (#f) ................................................. [ PASS]
    file-error? (#t) ................................................. [ PASS]
    guard (no match) ................................................. [ PASS]
    guard (match) .................................................... [ PASS]
    guard (=>) ....................................................... [ PASS]
    guard (multiple) ................................................. [ PASS]
    16 tests completed in 1/200 seconds.
    16 out of 16 (100%) tests passed.
    -- done testing exceptions -----------------------------------------------


    -- testing string ports --------------------------------------------------
    Port is still open after excursion ............................... [ PASS]
    call-with-port returns all values yielded by proc ................ [ PASS]
    call-with-port closes the port on normal return .................. [ PASS]
    It's ok to close output ports that are closed .................... [ PASS]
    input-port-open? fails on output ports ........................... [ PASS]
    call-with-port passes the port correctly and allows temporary escapes  [ PASS]
    output-port-open? fails on input ports ........................... [ PASS]
    Initially, string port is open ................................... [ PASS]
    Reading from string delivers the data ............................ [ PASS]
    After reading all, we get the eof-object ......................... [ PASS]
    Port is still open after all reads ............................... [ PASS]
    Port is no longer open after closing it .......................... [ PASS]
    It's ok to close input ports that are already closed ............. [ PASS]
    13 tests completed in 1/1000 seconds.
    13 out of 13 (100%) tests passed.
    -- done testing string ports ---------------------------------------------


    -- testing syntax-rules --------------------------------------------------
    let-syntax w/ basic syntax-rules ................................. [ PASS]
    Basic matching of vectors ........................................ [ PASS]
    Basic ellipsis match ............................................. [ PASS]
    Ellipsis match of length 1 does not match length 2 ............... [ PASS]
    Ellipsis match of lists with mismatched lengths (used to fail) ... [ PASS]
    letrec-syntax .................................................... [ PASS]
    Basic hygienic rename of syntactic keywords ...................... [ PASS]
    Basic hygienic rename of shadowed outer let ...................... [ PASS]
    Simple recursive letrec expansion ................................ [ PASS]
    Al* Petrofsky torture test ....................................... [ PASS]
    Quoted symbols inside vectors are stripped of syntactic info ..... [ PASS]
    syntax-rules keywords match ...................................... [ PASS]
    syntax-rules keywords no match ................................... [ PASS]
    keyword loses meaning if shadowed ................................ [ PASS]
    keyword also loses meaning for builtins (from R7RS section 4.3.2)  [ PASS]
    Nested identifier shadowing works correctly ...................... [ PASS]
    strip-syntax cuts across three levels of syntax .................. [ PASS]
    strip-syntax cuts across four levels of syntax ................... [ PASS]
    Alternative ellipsis (from SRFI-46) .............................. [ PASS]
    Ellipsis rules are reset in new macro expansion phase ............ [ PASS]

        -- testing rest patterns after ellipsis (SRFI-46 smoke test) ---------
        (foo (1 2)) .................................................. [ PASS]
        (foo (1 2) (3 4)) ............................................ [ PASS]
        (foo (1 2 3) (4 5) (6 7)) .................................... [ PASS]
        (foo #(1 2)) ................................................. [ PASS]
        (foo #(1) #(2 3)) ............................................ [ PASS]
        (foo #(1 2 3) #(4 5)) ........................................ [ PASS]
        (foo #(1 2 3) #(4 5) #(6 7)) ................................. [ PASS]
        (foo #(1 2) #(3 4)) .......................................... [ PASS]
        (foo #(1 2) #(3 4) #(5 6)) ................................... [ PASS]
        (foo #(1 2 3) #(4 5) #(6 7) #(8 9)) .......................... [ PASS]
        10 tests completed in 0 seconds.
        10 out of 10 (100%) tests passed.
        -- done testing rest patterns after ellipsis (SRFI-46 smoke test) ----

    Bug discovered during implementation of rest patterns ............ [ PASS]
    be-like-begin from R7RS 4.3.2 (nested ellipsis are not expanded) . [ PASS]
    underscores are ignored in patterns .............................. [ PASS]

        -- testing undefined behaviours: mixing keywords, ellipsis and underscores 

            -- testing underscore as keyword literal -------------------------
            Missing literal underscore keyword causes syntax-error ... [ PASS]
            Literal underscore matches ............................... [ PASS]
            Literal underscore matches even if it refers to toplevel binding  [ PASS]
            3 tests completed in 0 seconds.
            3 out of 3 (100%) tests passed.
            -- done testing underscore as keyword literal --------------------


            -- testing underscore as ellipsis --------------------------------
            No rule matching if prefix is omitted .................... [ PASS]
            Only prefix is supplied .................................. [ PASS]
            Ellipsis does its work if multiple arguments given ....... [ PASS]
            3 tests completed in 0 seconds.
            3 out of 3 (100%) tests passed.
            -- done testing underscore as ellipsis ---------------------------


            -- testing underscore as ellipsis mixed with underscore literal --
            No rule matching if prefix is omitted .................... [ PASS]
            (match-ellipsis-and-literals-underscores 1) .............. [ PASS]
            (match-ellipsis-and-literals-underscores 1 2 3) .......... [ PASS]
            (match-ellipsis-and-literals-underscores 1 2 3 4 5 6) .... [ PASS]
            4 tests completed in 0 seconds.
            4 out of 4 (100%) tests passed.
            -- done testing underscore as ellipsis mixed with underscore literal 


            -- testing "custom" ellipsis and literal of the same identifier --
            Ellipsis as literals ..................................... [ PASS]
            Ellipsis as literals multiple args ....................... [ PASS]
            Toplevel binding of the same name as ellipsis ............ [ PASS]
            3 tests completed in 1/1000 seconds.
            3 out of 3 (100%) tests passed.
            -- done testing "custom" ellipsis and literal of the same identifier 

        4 subgroups completed in 1/1000 seconds.
        4 out of 4 (100%) subgroups passed.
        -- done testing undefined behaviours: mixing keywords, ellipsis and underscores 

    Passing a macro as argument to macro ............................. [ PASS]
    DSSSL keyword arguments aren't renamed (not R7RS) ................ [ PASS]
    25 tests and 2 subgroups completed in 3/1000 seconds.
    25 out of 25 (100%) tests passed.
    2 out of 2 (100%) subgroups passed.
    -- done testing syntax-rules ---------------------------------------------


    -- testing define-record-type --------------------------------------------
    Record instances satisfy their predicates ........................ [ PASS]
    Record type definitions are generative ........................... [ PASS]
    2 tests completed in 0 seconds.
    2 out of 2 (100%) tests passed.
    -- done testing define-record-type ---------------------------------------


    -- testing open-input-bytevector -----------------------------------------
    ...(read-bytevector 12 (open-input-bytevector bv)) ............... [ PASS]
    1 test completed in 0 seconds.
    1 out of 1 (100%) test passed.
    -- done testing open-input-bytevector ------------------------------------


    -- testing open-output-bytevector ----------------------------------------
    ...(get-output-bytevector p) ..................................... [ PASS]
    1 test completed in 1/1000 seconds.
    1 out of 1 (100%) test passed.
    -- done testing open-output-bytevector -----------------------------------

18 subgroups completed in 697/500 seconds.
18 out of 18 (100%) subgroups passed.
-- done testing r7rs tests ---------------------------------------------------