test log

test.log

Testing VM stack sanity... ====================================================
simple expression ... ok
with-error-handler (1) ... ok
with-error-handler (2) ... ok
with-error-handler (3) ... ok
passed.
Testing integer arithmetic macros ... =========================================
<UADD>-------------------------------------------------------------------------
testing 4294967295+0 c=0 expects r=4294967295, c=0 =>ok
testing 4294967295+1 c=0 expects r=0, c=1 =>ok
testing 4294967295+2 c=0 expects r=1, c=1 =>ok
testing 4294967295+4294967295 c=0 expects r=4294967294, c=1 =>ok
testing 2147483647+2147483647 c=0 expects r=4294967294, c=0 =>ok
testing 2147483647+4294967295 c=0 expects r=2147483646, c=1 =>ok
testing 4294967294+0 c=1 expects r=4294967295, c=0 =>ok
testing 4294967295+0 c=1 expects r=0, c=1 =>ok
testing 4294967295+1 c=1 expects r=1, c=1 =>ok
testing 4294967295+4294967295 c=1 expects r=4294967295, c=1 =>ok
testing 2147483647+2147483647 c=1 expects r=4294967295, c=0 =>ok
testing 2147483647+4294967295 c=1 expects r=2147483647, c=1 =>ok
<UADDOV>-----------------------------------------------------------------------
testing 4294967295+0 expects 4294967295 =>ok
testing 4294967295+1 expects overflow =>ok
testing 4294967295+2 expects overflow =>ok
testing 4294967295+4294967295 expects overflow =>ok
testing 2147483647+2147483647 expects 4294967294 =>ok
testing 2147483647+4294967295 expects overflow =>ok
testing 4294967294+1 expects 4294967295 =>ok
testing 4294967294+2 expects overflow =>ok
<SADDOV>-----------------------------------------------------------------------
testing 1+1 expects 2 =>ok
testing -1+-1 expects -2 =>ok
testing 2147483647+0 expects 2147483647 =>ok
testing 2147483647+1 expects overflow =>ok
testing 2147483647+2 expects overflow =>ok
testing 2147483647+-1 expects 2147483646 =>ok
testing 2147483647+-2147483647 expects 0 =>ok
testing 2147483647+-2147483648 expects -1 =>ok
testing 1073741823+1073741823 expects 2147483646 =>ok
testing 1073741823+-1073741823 expects 0 =>ok
testing -1073741823+-1073741823 expects -2147483646 =>ok
testing 0+-2147483647 expects -2147483647 =>ok
testing -1+-2147483647 expects -2147483648 =>ok
testing -2+-2147483647 expects overflow =>ok
testing -2147483647+-2 expects overflow =>ok
testing -2147483647+-2147483647 expects overflow =>ok
testing -2147483647+-2147483648 expects overflow =>ok
<USUB>-------------------------------------------------------------------------
testing 4294967295-0 c=0 expects r=4294967295, c=0 =>ok
testing 4294967295-1 c=0 expects r=4294967294, c=0 =>ok
testing 0-4294967295 c=0 expects r=1, c=1 =>ok
testing 1-4294967295 c=0 expects r=2, c=1 =>ok
testing 4294967295-2147483647 c=0 expects r=2147483648, c=0 =>ok
testing 2147483647-4294967295 c=0 expects r=2147483648, c=1 =>ok
testing 4294967295-0 c=1 expects r=4294967294, c=0 =>ok
testing 4294967295-1 c=1 expects r=4294967293, c=0 =>ok
testing 0-4294967295 c=1 expects r=0, c=1 =>ok
testing 1-4294967295 c=1 expects r=1, c=1 =>ok
testing 4294967295-2147483647 c=1 expects r=2147483647, c=0 =>ok
testing 2147483647-4294967295 c=1 expects r=2147483647, c=1 =>ok
<USUBOV>-----------------------------------------------------------------------
testing 4294967295-0 expects 4294967295 =>ok
testing 4294967295-1 expects 4294967294 =>ok
testing 4294967295-4294967295 expects 0 =>ok
testing 4294967294-4294967295 expects overflow =>ok
testing 4294967295-4294967294 expects 1 =>ok
testing 0-1 expects overflow =>ok
testing 0-4294967295 expects overflow =>ok
<SSUBOV>-----------------------------------------------------------------------
testing 1-1 expects 0 =>ok
testing -1--1 expects 0 =>ok
testing 2147483647-0 expects 2147483647 =>ok
testing 2147483647-1 expects 2147483646 =>ok
testing 2147483647--1 expects overflow =>ok
testing 2147483647--2 expects overflow =>ok
testing 2147483647--2147483647 expects overflow =>ok
testing 2147483647-2147483647 expects 0 =>ok
testing 1073741823--1073741823 expects 2147483646 =>ok
testing 1073741823-1073741823 expects 0 =>ok
testing -1073741823-1073741823 expects -2147483646 =>ok
testing 0--2147483647 expects 2147483647 =>ok
testing 1--2147483647 expects overflow =>ok
testing 0--2147483647 expects 2147483647 =>ok
testing -2147483648-1 expects overflow =>ok
testing -2147483648--1 expects -2147483647 =>ok
testing -2147483647--2147483647 expects 0 =>ok
testing -2147483647--2147483648 expects 1 =>ok
<UMUL>-------------------------------------------------------------------------
testing 4294967295*4294967295 expects hi=4294967294, lo=1 =>ok
testing 4294967294*4294967294 expects hi=4294967292, lo=4 =>ok
testing 2147483647*2 expects hi=0, lo=4294967294 =>ok
testing 2147483648*2 expects hi=1, lo=0 =>ok
<UMULOV>-----------------------------------------------------------------------
testing 0*1 expects 0 =>ok
testing 1*0 expects 0 =>ok
testing 1*1 expects 1 =>ok
testing 1*4294967295 expects 4294967295 =>ok
testing 2*4294967295 expects overflow =>ok
testing 2147483647*2 expects 4294967294 =>ok
testing 2147483647*3 expects overflow =>ok
testing 268435455*268435455 expects overflow =>ok
testing 16777215*16777215 expects overflow =>ok
testing 4294967295*4294967295 expects overflow =>ok
testing 4294967294*4294967294 expects overflow =>ok
<SMULOV>-----------------------------------------------------------------------
testing 0*1 expects 0 =>ok
testing 1*0 expects 0 =>ok
testing 1*1 expects 1 =>ok
testing 1*-1 expects -1 =>ok
testing -1*1 expects -1 =>ok
testing -1*-1 expects 1 =>ok
testing 1*2147483647 expects 2147483647 =>ok
testing 1*-2147483647 expects -2147483647 =>ok
testing -1*2147483647 expects -2147483647 =>ok
testing -1*-2147483647 expects 2147483647 =>ok
testing 1*-2147483648 expects -2147483648 =>ok
testing -1*-2147483648 expects overflow =>ok
testing 2*2147483647 expects overflow =>ok
testing 2*-2147483647 expects overflow =>ok
testing -2*2147483647 expects overflow =>ok
testing -2*-2147483647 expects overflow =>ok
testing 1073741823*2 expects 2147483646 =>ok
testing 1073741823*-2 expects -2147483646 =>ok
testing -1073741823*2 expects -2147483646 =>ok
testing -1073741823*-2 expects 2147483646 =>ok
testing 1073741824*2 expects overflow =>ok
testing 1073741824*-2 expects -2147483648 =>ok
testing -1073741824*2 expects -2147483648 =>ok
testing -1073741824*-2 expects overflow =>ok
testing 134217727*134217727 expects overflow =>ok
testing 134217727*-134217727 expects overflow =>ok
testing -134217727*134217727 expects overflow =>ok
testing -134217727*-134217727 expects overflow =>ok
testing 8388607*8388607 expects overflow =>ok
testing 8388607*-8388607 expects overflow =>ok
testing -8388607*8388607 expects overflow =>ok
testing -8388607*-8388607 expects overflow =>ok
testing 2147483647*2147483647 expects overflow =>ok
testing 2147483647*-2147483647 expects overflow =>ok
testing -2147483647*2147483647 expects overflow =>ok
testing -2147483647*-2147483647 expects overflow =>ok
<integer conversions, non clamping>--------------------------------------------
<integer conversions, clamping>------------------------------------------------
<integer conversions, CLAMP_NONE>----------------------------------------------
<half floats>------------------------------------------------------------------
passed.
Testing primitive syntax ======================================================
<conditionals>-----------------------------------------------------------------
test if, expects 5 ==> ok
test if, expects 2 ==> ok
test and, expects #t ==> ok
test and, expects 5 ==> ok
test and, expects #f ==> ok
test and, expects #f ==> ok
test and, expects a ==> ok
test or, expects #f ==> ok
test or, expects 3 ==> ok
test or, expects 3 ==> ok
test when, expects 4 ==> ok
test when, expects #<undef> ==> ok
test unless, expects #<undef> ==> ok
test unless, expects 4 ==> ok
test cond, expects #<undef> ==> ok
test cond, expects 5 ==> ok
test cond, expects 2 ==> ok
test cond, expects 8 ==> ok
test cond, expects 3 ==> ok
test cond (srfi-61), expects 1 ==> ok
test cond (srfi-61), expects 8 ==> ok
test cond (srfi-61), expects (1 2) ==> ok
test case, expects #t ==> ok
test case, expects #t ==> ok
test case (srfi-87), expects 0 ==> ok
test case (srfi-87), expects 6 ==> ok
test case (srfi-87), expects 5 ==> ok
<binding>----------------------------------------------------------------------
test let, expects 35 ==> ok
test let*, expects 70 ==> ok
test let*, expects 2 ==> ok
test named let, expects -3 ==> ok
<closure and saved env>--------------------------------------------------------
test lambda, expects 5 ==> ok
test lambda, expects 12 ==> ok
test lambda, expects 5 ==> ok
test lambda, expects 9 ==> ok
test lambda, expects 1 ==> ok
test lambda, expects 2 ==> ok
<application>------------------------------------------------------------------
test apply, expects (1 2 3) ==> ok
test apply, expects (2 3 4) ==> ok
test apply, expects (3 4 5) ==> ok
test apply, expects (4 5 6) ==> ok
test apply^2, expects () ==> ok
test apply^2, expects () ==> ok
test apply^2, expects (1 . 2) ==> ok
test apply^2, expects (3 . 4) ==> ok
test apply^2, expects (5 . 6) ==> ok
test apply, expects (6 7 8) ==> ok
test apply, copying args, expects (1 2 3) ==> ok
test apply, copying args, expects (2 3) ==> ok
test apply local inliner optimizer, expects "1" ==> ok
test apply local inliner optimizer, expects "1" ==> ok
test map, expects () ==> ok
test map, expects (1 2 3) ==> ok
test map, expects (() () ()) ==> ok
test map, expects ((1 . 4) (2 . 5) (3 . 6)) ==> ok
<loop>-------------------------------------------------------------------------
test loop non-tail-rec, expects 120 ==> ok
test loop tail-rec, expects 120 ==> ok
test loop named-let, expects 120 ==> ok
test loop int-define, expects 120 ==> ok
test loop do, expects 120 ==> ok
test do, expects #f ==> ok
<quasiquote>-------------------------------------------------------------------
test qq, expects (1 2 3) ==> ok
test qq, expects () ==> ok
test qq, expects 99 ==> ok
test qq, expects 101 ==> ok
test qq,, expects ((1 . 2)) ==> ok
test qq,, expects ((1 . 2) 3) ==> ok
test qq,, expects (0 (1 . 2)) ==> ok
test qq,, expects (0 (1 . 2) 3) ==> ok
test qq,, expects (((1 . 2))) ==> ok
test qq,, expects (((1 . 2)) 3) ==> ok
test qq,, expects (99 3) ==> ok
test qq,, expects (3 99) ==> ok
test qq,, expects (3 99 3) ==> ok
test qq,, expects (100 3) ==> ok
test qq,, expects (3 100) ==> ok
test qq,, expects (101 3) ==> ok
test qq,, expects (3 101) ==> ok
test qq,, expects (102 3) ==> ok
test qq,, expects (3 102) ==> ok
test qq,(r6rs), expects (98 99 (a b) 100) ==> ok
test qq,(r6rs), expects (98 99 101 100) ==> ok
test qq,(r6rs), expects (98 99 (a b) 100) ==> ok
test qq,(r6rs), expects (98 99 (a b) (1 2) (3 4)) ==> ok
test qq@, expects (1 2 3 4) ==> ok
test qq@, expects (1 2 3 4) ==> ok
test qq@, expects (a b c d) ==> ok
test qq@(r6rs), expects (1 a b a b 2) ==> ok
test qq@(r6rs), expects (1 a b c d 2) ==> ok
test qq@(r6rs), expects (1 a b c d 2) ==> ok
test qq., expects (1 2 3 4) ==> ok
test qq., expects (a b c d) ==> ok
test qq#,, expects #((1 . 2) 3) ==> ok
test qq#,, expects #(99 3) ==> ok
test qq#,, expects #(100 3) ==> ok
test qq#,, expects #(3 101) ==> ok
test qq#,, expects #(3 102) ==> ok
test qq#@, expects #(1 2 3 4) ==> ok
test qq#@, expects #(1 2 3 4) ==> ok
test qq#@, expects #(a b c d) ==> ok
test qq#@, expects #(a b (c d)) ==> ok
test qq#@, expects #((a b) c d) ==> ok
test qq#, expects #() ==> ok
test qq#@, expects #() ==> ok
test qq@@, expects (1 2 1 2) ==> ok
test qq@@, expects (1 2 a 1 2) ==> ok
test qq@@, expects (a 1 2 1 2) ==> ok
test qq@@, expects (1 2 1 2 a) ==> ok
test qq@@, expects (1 2 1 2 a b) ==> ok
test qq@., expects (1 2 1 2 . a) ==> ok
test qq@., expects (1 2 1 2 1 . 2) ==> ok
test qq@., expects (1 2 1 2 a b) ==> ok
test qq@., expects (1 2 1 2 a 1 . 2) ==> ok
test qq@., expects (1 2 1 2 a c d) ==> ok
test qq#@@, expects #(1 2 1 2) ==> ok
test qq#@@, expects #(1 2 a 1 2) ==> ok
test qq#@@, expects #(a 1 2 1 2) ==> ok
test qq#@@, expects #(1 2 1 2 a) ==> ok
test qq#@@, expects #(1 2 1 2 a b) ==> ok
test qqq, expects (1 `(1 ,2 ,3) 1) ==> ok
test qqq, expects (1 `(1 ,99 ,101) 1) ==> ok
test qqq, expects (1 `(1 ,@2 ,@(1 2))) ==> ok
test qqq, expects (1 `(1 ,@2 (unquote 1 2))) ==> ok
test qqq, expects (1 `(1 ,@2 (unquote-splicing 1 2))) ==> ok
test qqq, expects (1 `(1 ,@(a b) ,@(c d))) ==> ok
test qqq, expects (1 `(1 ,(a b x) ,(y c d))) ==> ok
test qqq#, expects #(1 `(1 ,2 ,3) 1) ==> ok
test qqq#, expects #(1 `(1 ,99 ,101) 1) ==> ok
test qqq#, expects #(1 `(1 ,@2 ,@(1 2))) ==> ok
test qqq#, expects #(1 `(1 ,@(a b) ,@(c d))) ==> ok
test qqq#, expects #(1 `(1 ,(a b x) ,(y c d))) ==> ok
test qqq#, expects (1 `#(1 ,(a b x) ,(y c d))) ==> ok
test qq-hygiene 0, expects (2 1) ==> ok
test qq-hygiene 1, expects (,(+ 1 2)) ==> ok
test qq-hygiene 2, expects (,@(+ 1 2)) ==> ok
<multiple values>--------------------------------------------------------------
test receive, expects (1 2 3) ==> ok
test receive, expects (1 2 3) ==> ok
test receive, expects (1 2 3) ==> ok
test receive, expects 1 ==> ok
test call-with-values, expects (1 2 3) ==> ok
test call-with-values, expects () ==> ok
test receive, expects ((0 0)) ==> ok
<eval>-------------------------------------------------------------------------
test eval, expects (1 . 2) ==> ok
test eval, expects (foo foo 3) ==> ok
test eval, expects #t ==> ok
test eval (module), expects (a b (x y)) ==> ok
test eval (module), expects (x y) ==> ok
<local procedure optimization>-------------------------------------------------
test internal-define inilining, expects (1) ==> ok
test multiple inlining, expects 0 ==> ok
test pass3 inlining with pass3/$call optimization, expects #t ==> ok
test pass3/$call inlining problem, expects #t ==> ok
<optimized frames>-------------------------------------------------------------
test lambda (empty env), expects 1 ==> ok
test let (empty env), expects 1 ==> ok
test let (empty env), expects (1 . 1) ==> ok
test let (empty env), expects (3 . 1) ==> ok
test named let (empty env), expects 1 ==> ok
test do (empty env), expects 1 ==> ok
<hygienity>--------------------------------------------------------------------
test hygienity (named let), expects 4 ==> ok
test hygienity (internal defines), expects 4 ==> ok
test hygienity (do), expects 4 ==> ok
passed.
Testing error and exception handlers ==========================================
<with-error-handler>-----------------------------------------------------------
test basic, expects (1 . 2) ==> ok
test basic, expects (1 2 3) ==> ok
test with let, expects 1 ==> ok
test with let, expects 1 ==> ok
test cascade, expects 3 ==> ok
test over c stack, expects (1 . 2) ==> ok
test with dynamic wind, expects (a b c) ==> ok
test with dynamic wind, expects (a b e c d f) ==> ok
test repeat, expects 10 ==> ok
<cascading errors>-------------------------------------------------------------
test cascading error, expects (a b c e d) ==> ok
test cascading error 2, expects (a b c d e f g) ==> ok
test cascading error 3, expects (a b c d f g) ==> ok
test cascading error 4, expects (a b c d e f g h i j) ==> ok
test cascading error 5, expects (a b c d e f g) ==> ok
test cascading error 6, expects (a b c d e f g) ==> ok
<error in before/after thunk>--------------------------------------------------
test error in before thunk, expects (a c) ==> ok
test error in after thunk, expects (a b c d) ==> ok
test error in before thunk (nested), expects (a b c d) ==> ok
test error in after thunk (nested), expects (a b c d e f) ==> ok
test error in before thunk (cascaded), expects (a b c d e) ==> ok
test error in after thunk (cascaded), expects (a b c d e f g) ==> ok
<restart and error handler>----------------------------------------------------
test restart, expects (a b x b x) ==> ok
test restart & dynamic-wind, expects (a b c x e f z a b x e f z) ==> ok
<with-exception-handler>-------------------------------------------------------
test simple, expects (a b c) ==> ok
test w/dynamic-wind, expects (a b c d e f g) ==> ok
test manual restart (simple), expects (a b c) ==> ok
test manual restart (w/ dynamic-wind), expects (a b c e d) ==> ok
test noncontinuable error, expects (a b c g y) ==> ok
<nesting exception/error handlers>---------------------------------------------
test propagating continuable exception, expects (a b c) ==> ok
test propagating continuable exception, expects (a b c d e f g h) ==> ok
<interaction with empty environment frame>-------------------------------------
test empty do, expects ok ==> ok
test empty let, expects ok ==> ok
<error and errorf procedures>--------------------------------------------------
test error (<error>), expects "Message 1 \"2\" (:a . #\\4)" ==> ok
test errorf (<error>), expects "Message 1 and 2 or 3 and 4" ==> ok
test error (<system-error>), expects ("Wow: \"bang!\" 4" 111) ==> ok
test errorf (<system-error>), expects ("Wow: \"bang!\" 4" 111) ==> ok
test error (base case), expects #t ==> ok
test errorf (base case), expects #t ==> ok
test error (explicit message), expects "msg" ==> ok
test errorf (explicit message), expects "msg~s" ==> ok
<stack overflow inside handlers>-----------------------------------------------
test stack overflow in error handler, expects (4 . ok) ==> ok
test stack overflow in error handler (nested), expects (4 . ok) ==> ok
test stack overflow in error handler (cascading error), expects (4 . ok) ==> ok
passed.
Testing module ================================================================
test define-module, expects #t ==> ok
test with-module, expects 3 ==> ok
test with-module, expects 5 ==> ok
test with-module, expects (3 . 2) ==> ok
test with-module, expects 5 ==> ok
test with-module, expects 2 ==> ok
test with-module, expects 300 ==> ok
test with-module (error), expects #<error> ==> ok
test with-module in head position, expects (2 3) ==> ok
test with-module in head position, expects (3 5 6) ==> ok
test with-module in head position (shadowed), expects (1 2 3) ==> ok
test with-module in head position (shadowed), expects (1 2 3) ==> ok
test with-module in head position (in lambda body), expects 6 ==> ok
test define-in-module, expects 99 ==> ok
test define-in-module, expects #<error> ==> ok
test import/export, expects (56 72) ==> ok
test import (error), expects #<error> ==> ok
test import w/prefix, expects (56 72) ==> ok
test import w/prefix (error), expects #<error> ==> ok
test import w/prefix (insertion), expects 99 ==> ok
test import w/only, expects () ==> ok
test import w/only (error), expects #<error> ==> ok
test import w/only propagation, expects (0 10) ==> ok
test import w/only-prefix, expects () ==> ok
test import w/only-prefix (error), expects #<error> ==> ok
test import w/prefix-only, expects () ==> ok
test import w/prefix-only (error), expects #<error> ==> ok
test import w/prefix-only (nonexistent error), expects #<error> ==> ok
test import w/except, expects () ==> ok
test import w/except (error), expects #<error> ==> ok
test import w/except-prefix, expects () ==> ok
test import w/except-prefix (error), expects #<error> ==> ok
test import w/prefix-except, expects () ==> ok
test import w/prefix-except (error), expects #<error> ==> ok
test import w/prefix-except (nonexistent error), expects #<error> ==> ok
test import w/rename, expects (1 2) ==> ok
test import w/rename (make sure old binding is removed), expects #<error> ==> ok
test import w/rename (swap), expects (1 2) ==> ok
test import w/rename-prefix, expects (1 2) ==> ok
test import w/rename-prefix (hiding), expects #<error> ==> ok
test import w/rename-prefix (hiding), expects #<error> ==> ok
test import w/prefix-rename, expects (1 2) ==> ok
test import w/prefix-rename (hiding), expects #<error> ==> ok
test import w/prefix-rename (hiding), expects #<error> ==> ok
test import w/prefix-rename (hiding), expects #<error> ==> ok
test import w/prefix-rename (hiding), expects #<error> ==> ok
test import w/prefix-rename (hiding), expects #<error> ==> ok
test import w/prefix-rename-prefix-rename, expects (1 2) ==> ok
test select-module, expects (O O N O) ==> ok
test select-module, expects user ==> ok
test select-module (error), expects #<error> ==> ok
test module inheritance, expects alpha ==> ok
test module inheritance, expects ei ==> ok
test module inheritance, expects (gamma beta) ==> ok
test module inheritance, expects (alpha beta gamma dee) ==> ok
test moduel inheritance (error), expects #<error> ==> ok
test global-variable-ref, expects gamma ==> ok
test global-variable-ref, expects #<error> ==> ok
test global-variable-ref, expects huh? ==> ok
test global-variable-ref, expects huh? ==> ok
test make-module, expects #t ==> ok
test make-module (duplicate name), expects #<error> ==> ok
test make-module (duplicate name), expects #<error> ==> ok
test make-module (duplicate name), expects #f ==> ok
test anynomous module, expects #t ==> ok
test anonymous module, expects 13 ==> ok
test anonymous module, expects #<error> ==> ok
test mpl search (mplbug-user1,a), expects #t ==> ok
test mpl search (mplbug-user1,b), expects #t ==> ok
test mpl search (mplbug-user1,x), expects #t ==> ok
test mpl search (mplbug-user2,a), expects #t ==> ok
test mpl search (mplbug-user2,b), expects #t ==> ok
test mpl search (mplbug-user2,x), expects #t ==> ok
passed.
Testing macro =================================================================
<basic expansion>--------------------------------------------------------------
test simple, expects (a z) ==> ok
test simple, expects (b z) ==> ok
test simple, expects (c z) ==> ok
test simple, expects (d z) ==> ok
test simple, expects (e z) ==> ok
test simple, expects (f z #(1.0 2.0)) ==> ok
test simple, expects (f z (#\b #\a)) ==> ok
test simple, expects (f z #(2 1)) ==> ok
test repeat, expects ((a c e) (b d f)) ==> ok
test repeat, expects (a c e b d f) ==> ok
test repeat, expects (a c e b d f a c e) ==> ok
test repeat, expects ((a d g) (b c) (e f) (h i)) ==> ok
test repeat, expects (a d g (c 8 b) (f 8 e) (i 8 h)) ==> ok
test nest1, expects ((a z) (b c d z) (e f g h i z) (z) (j z)) ==> ok
test nest2, expects ((a c b d) () (e g i f h j)) ==> ok
test nest3, expects ((((b c d e) (g h i)) (() (l m n) (p)) () ((r))) ((a f) (j k o) () (q))) ==> ok
test mixlevel1, expects ((1 2) (1 3) (1 4) (1 5) (1 6)) ==> ok
test mixlevel2, expects (((1 2) (1 3) (1 4)) ((2 3) (2 4) (2 5) (2 6))) ==> ok
test mixlevel3, expects (((1 2 3) (1 2 4) (1 2 5) (1 2 6)) ((1 7 8) (1 7 9) (1 7 10))) ==> ok
test bad epplisis 1, expects #<error> ==> ok
test bad epplisis 2, expects #<error> ==> ok
test bad epplisis 3, expects #<error> ==> ok
test bad epplisis 4, expects #<error> ==> ok
test hygiene, expects 3 ==> ok
test vect1, expects (1 2 3 4 5) ==> ok
test vect1, expects #(1 2 3 4 5) ==> ok
test vect2, expects #(a c e b d f) ==> ok
test vect2, expects (a c e b d f) ==> ok
test vect2, expects (#(a c e) #(b d f)) ==> ok
test dot1, expects (1 2) ==> ok
test dot1, expects (1 (2)) ==> ok
test dot1, expects (1 ()) ==> ok
test dot1, expects (1 (2 3)) ==> ok
test dot1, expects #f ==> ok
test dot2, expects (2 . 1) ==> ok
test dot2, expects ((2) . 1) ==> ok
test dot2, expects (() . 1) ==> ok
test dot2, expects ((2 3) . 1) ==> ok
test dot2, expects #f ==> ok
test dot3, expects (1 2 . 3) ==> ok
test dot3, expects 3 ==> ok
test unwrap1, expects (a 3) ==> ok
test unwrap1, expects (a 4) ==> ok
test qq1, expects () ==> ok
test qq2, expects #() ==> ok
<recursive expansion>----------------------------------------------------------
test %cond, expects (begin a) ==> ok
test %cond, expects (begin a b c) ==> ok
test %cond, expects (let ((temp a)) (if temp (b temp))) ==> ok
test %cond, expects (let ((temp a)) (if temp (b temp) (%cond c))) ==> ok
test %cond, expects (let ((temp a)) (if temp (b temp) (%cond c d))) ==> ok
test %cond, expects (let ((temp a)) (if temp (b temp) (%cond c d e))) ==> ok
test %cond, expects a ==> ok
test %cond, expects (let ((temp a)) (if temp temp (%cond b))) ==> ok
test %cond, expects (let ((temp a)) (if temp temp (%cond b c))) ==> ok
test %cond, expects (if a (begin b)) ==> ok
test %cond, expects (if a (begin b c d)) ==> ok
test %cond, expects (if a (begin b c d) (%cond e f g)) ==> ok
test %cond, expects (if a (begin => b)) ==> ok
test %cond, expects (if else (begin z)) ==> ok
test %letrec, expects (let ((a :undefined) (c :undefined)) (let ((newtemp b) (newtemp d)) (set! a newtemp) (set! c newtemp) e f g)) ==> ok
test %letrec, expects (1 2 3) ==> ok
test %do, expects (letrec ((loop (lambda (x y) (if (>= x 10) (begin (if #f #f) y) (begin (loop (%do "step" x (+ x 1)) (%do "step" y (* y 2)))))))) (loop 0 1)) ==> ok
test %do, expects 1024 ==> ok
test %do, expects (letrec ((loop (lambda (y x) (if (>= x 10) (begin (if #f #f) y) (begin (set! y (* y 2)) (loop (%do "step" y) (%do "step" x (+ x 1)))))))) (loop 1 0)) ==> ok
test %do, expects 1024 ==> ok
<transformers other than syntax-rules>-----------------------------------------
test xif, expects ok ==> ok
test xfi, expects ok ==> ok
<local syntactic bindings>-----------------------------------------------------
test let-syntax, expects now ==> ok
test let-syntax, expects outer ==> ok
test let-syntax (multi), expects 81 ==> ok
test let-syntax (nest), expects 19 ==> ok
test let-syntax (nest), expects (-6 11) ==> ok
test letrec-syntax, expects 7 ==> ok
test letrec-syntax (nest), expects 2 ==> ok
test letrec-syntax (nest), expects (9 11) ==> ok
test letrec-syntax (recursive), expects #t ==> ok
test let-syntax (huima), expects (1 3 5 9) ==> ok
test let-syntax, rebinding syntax, expects ok ==> ok
test let-syntax, rebinding macro, expects ok ==> ok
<macro and internal define>----------------------------------------------------
test define foo (legacy), expects 3 ==> ok
test define foo (legacy), expects (3 5) ==> ok
test define foo (legacy), expects (3 10) ==> ok
test define foo (legacy), expects (4 5) ==> ok
test define foo (legacy), expects (4 5) ==> ok
test define foo (error), expects #<error> ==> ok
test define foo (error), expects #<error> ==> ok
test define foo (shadow), expects 10 ==> ok
test define foo, bar (legacy), expects ((0 1) 10) ==> ok
test define foo, bar (legacy), expects (-1 -2 20) ==> ok
test define foo, bar (legacy), expects (-1 -2 20) ==> ok
test define foo, bar (legacy), expects (3 4 20 -10) ==> ok
test define foo, bar (legacy), expects (3 4 20 -10) ==> ok
test define foo, bar (legacy), expects (3 4 20 -10) ==> ok
test define foo, bar (error), expects #<error> ==> ok
test define foo, bar (error), expects #<error> ==> ok
test define boo (r5rs), expects 3 ==> ok
test define boo (r5rs), expects (3 10) ==> ok
test define poo (r5rs), expects 6 ==> ok
test define poo (r5rs), expects 3 ==> ok
test define (legacy, mutually-recursive), expects (#t #f) ==> ok
test define (r5rs, mutually-recursive), expects (#t #f) ==> ok
<macro defining macros>--------------------------------------------------------
test define-syntax - define-syntax, expects (1 . 0) ==> ok
test define-syntax - let-syntax, expects (1 . 0) ==> ok
test let-syntax - let-syntax, expects (4 . 3) ==> ok
test lexical scope, expects 5 ==> ok
test lexical scope, expects 5 ==> ok
test passing by parameters, expects 5 ==> ok
test comparison of identifiers, expects (cdr b) ==> ok
test comparison of identifiers, expects (#<identifier user#cdr> #<identifier user#b>) ==> ok
<common-macros utilities>------------------------------------------------------
test push!, expects (1 2 3) ==> ok
test push!, expects (0 1 2 3) ==> ok
test push!, expects #((1 2) (3 . 0)) ==> ok
test pop!, expects ((2 3) . 1) ==> ok
test pop!, expects ((1 3) . 2) ==> ok
test pop!, expects (#((2)) . 1) ==> ok
test push!, pop!, expects ((2 3) (4 1)) ==> ok
test inc!, expects 3 ==> ok
test inc!, expects 4 ==> ok
test inc!, expects (4 . 1) ==> ok
test inc!, expects (1 . 1) ==> ok
test inc!, expects ((4 . 1) 1) ==> ok
test dec!, expects 1 ==> ok
test dec!, expects 0 ==> ok
test dec!, expects (2 . 1) ==> ok
test dec!, expects (5 . 1) ==> ok
test dec!, expects ((2 . 1) -1) ==> ok
test dotimes, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test dotimes, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test dotimes, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test while, expects 9 ==> ok
test while, expects 0 ==> ok
test while =>, expects 6 ==> ok
test while => guard, expects 45 ==> ok
test until, expects 10 ==> ok
test until => guard, expects 45 ==> ok
test values-ref, expects 3 ==> ok
test values-ref, expects 1 ==> ok
test values-ref, expects e ==> ok
test values-ref, expects (d b) ==> ok
test values-ref, expects (d a b) ==> ok
test values-ref, expects (e d c b a) ==> ok
test values->list, expects (3 1) ==> ok
test values->list, expects (1) ==> ok
test values->list, expects () ==> ok
test let1, expects (2 2 2) ==> ok
test let1, expects (2 4) ==> ok
test rlet1, expects 1 ==> ok
test if-let1, expects 4 ==> ok
test if-let1, expects bar ==> ok
test ecase, expects b ==> ok
test ecase, expects #<error> ==> ok
test ecase, expects d ==> ok
test $, expects (0 1) ==> ok
test $, expects (0 1 (2 3 (4 5 (6 7)))) ==> ok
test $ - $*, expects (0 1 (2 3 4 5 6 7)) ==> ok
test $ - $*, expects (0 1 2 3 (4 5 6 7)) ==> ok
test $ - $*, expects (0 1 2 3 4 5 (6 7)) ==> ok
test $ - partial, expects (0 1 (2 3 (4 5 a))) ==> ok
test $ - $* - partial, expects (0 1 2 3 4 5 a) ==> ok
test $ - $* - partial, expects (0 1 (2 3 (4 5 a b))) ==> ok
test $ - hygienty, expects (0 1 a #0=#<subr list> 2 3 b #0# 4 5) ==> ok
test cond-list, expects () ==> ok
test cond-list, expects (a) ==> ok
test cond-list, expects (a) ==> ok
test cond-list, expects (b) ==> ok
test cond-list, expects (a b d) ==> ok
test cond-list, expects ((b)) ==> ok
test cond-list, expects (a b c d x) ==> ok
<macroexpand>------------------------------------------------------------------
test macroexpand, expects (list 1 1 1 1) ==> ok
test macroexpand-1, expects (bar 1 1) ==> ok
<failure cases>----------------------------------------------------------------
test reject first-class syntax usage, expects #<error> ==> ok
test reject first-class macro usage, expects #<error> ==> ok
passed.
Testing numbers ===============================================================
<integer addition & reader>----------------------------------------------------
test around 2^28, expects (268435456 536870911 536870912 -268435456 -536870911 -536870912 -536870913) ==> ok
test around 2^31, expects (2147483648 4294967295 4294967296 -2147483648 -4294967295 -4294967296 -4294967297) ==> ok
test around 2^60, expects (1152921504606846976 2305843009213693951 2305843009213693952 -1152921504606846976 -2305843009213693951 -2305843009213693952 -2305843009213693953) ==> ok
test around 2^63, expects (9223372036854775808 18446744073709551615 18446744073709551616 -9223372036854775808 -18446744073709551615 -18446744073709551616 -18446744073709551617) ==> ok
test around 2^127, expects (170141183460469231731687303715884105728 340282366920938463463374607431768211455 340282366920938463463374607431768211456 -170141183460469231731687303715884105728 -340282366920938463463374607431768211455 -340282366920938463463374607431768211456 -340282366920938463463374607431768211457) ==> ok
test peculiarity around 2^32, expects 4772267290 ==> ok
test radix, expects (43605 342391 718048024785 123456789 123456789987654321 1193046 3735928559 3735928559) ==> ok
test exactness, expects #t ==> ok
test exactness, expects #t ==> ok
test exactness, expects #t ==> ok
test exactness, expects #t ==> ok
test inexactness, expects #f ==> ok
test inexactness, expects #f ==> ok
test inexactness, expects #f ==> ok
test exactness & radix, expects (#t 3735928559 #t 3735928559) ==> ok
test inexactness & radix, expects (#f 3.735928559e9 #f 3.735928559e9) ==> ok
test invalid exactness/radix spec, expects #f ==> ok
test base-2 reader, expects (#t #t) ==> ok
test base-3 reader, expects (#t #t) ==> ok
test base-4 reader, expects (#t #t) ==> ok
test base-5 reader, expects (#t #t) ==> ok
test base-6 reader, expects (#t #t) ==> ok
test base-7 reader, expects (#t #t) ==> ok
test base-8 reader, expects (#t #t) ==> ok
test base-9 reader, expects (#t #t) ==> ok
test base-10 reader, expects (#t #t) ==> ok
test base-11 reader, expects (#t #t) ==> ok
test base-12 reader, expects (#t #t) ==> ok
test base-13 reader, expects (#t #t) ==> ok
test base-14 reader, expects (#t #t) ==> ok
test base-15 reader, expects (#t #t) ==> ok
test base-16 reader, expects (#t #t) ==> ok
test base-17 reader, expects (#t #t) ==> ok
test base-18 reader, expects (#t #t) ==> ok
test base-19 reader, expects (#t #t) ==> ok
test base-20 reader, expects (#t #t) ==> ok
test base-21 reader, expects (#t #t) ==> ok
test base-22 reader, expects (#t #t) ==> ok
test base-23 reader, expects (#t #t) ==> ok
test base-24 reader, expects (#t #t) ==> ok
test base-25 reader, expects (#t #t) ==> ok
test base-26 reader, expects (#t #t) ==> ok
test base-27 reader, expects (#t #t) ==> ok
test base-28 reader, expects (#t #t) ==> ok
test base-29 reader, expects (#t #t) ==> ok
test base-30 reader, expects (#t #t) ==> ok
test base-31 reader, expects (#t #t) ==> ok
test base-32 reader, expects (#t #t) ==> ok
test base-33 reader, expects (#t #t) ==> ok
test base-34 reader, expects (#t #t) ==> ok
test base-35 reader, expects (#t #t) ==> ok
test base-36 reader, expects (#t #t) ==> ok
<rational reader>--------------------------------------------------------------
test rational reader, expects (1234 #t) ==> ok
test rational reader, expects (-1234 #t) ==> ok
test rational reader, expects (1234 #t) ==> ok
test rational reader, expects |1234/-1| ==> ok
test rational reader, expects (1234 #t) ==> ok
test rational reader, expects (1/2 #t) ==> ok
test rational reader, expects (-1/2 #t) ==> ok
test rational reader, expects (1/2 #t) ==> ok
test rational reader, expects (1/2 #t) ==> ok
test rational reader, expects (1 #t) ==> ok
test rational reader, expects (+inf.0 #f) ==> ok
test rational reader, expects (-inf.0 #f) ==> ok
test rational reader, expects #f ==> ok
test rational reader, expects #f ==> ok
test rational reader, expects #f ==> ok
test rational reader, expects #<error> ==> ok
test rational reader, expects #<error> ==> ok
test rational reader w/#e, expects (1234 #t) ==> ok
test rational reader w/#e, expects (-1234 #t) ==> ok
test rational reader w/#e, expects (32/7 #t) ==> ok
test rational reader w/#e, expects (-32/7 #t) ==> ok
test rational reader w/#i, expects (1234.0 #f) ==> ok
test rational reader w/#i, expects (-1234.0 #f) ==> ok
test rational reader w/#i, expects (-0.125 #f) ==> ok
test rational reader w/radix, expects (15 #t) ==> ok
test rational reader w/radix, expects (56 #t) ==> ok
test rational reader w/radix, expects (15.0 #f) ==> ok
test rational reader edge case, expects #t ==> ok
test rational reader edge case, expects #t ==> ok
test rational reader edge case, expects #t ==> ok
<flonum reader>----------------------------------------------------------------
test flonum reader, expects (3.14 #t) ==> ok
test flonum reader, expects (0.14 #t) ==> ok
test flonum reader, expects (0.14 #t) ==> ok
test flonum reader, expects (3.0 #t) ==> ok
test flonum reader, expects (-3.14 #t) ==> ok
test flonum reader, expects (-0.14 #t) ==> ok
test flonum reader, expects (-0.14 #t) ==> ok
test flonum reader, expects (-3.0 #t) ==> ok
test flonum reader, expects (3.14 #t) ==> ok
test flonum reader, expects (0.14 #t) ==> ok
test flonum reader, expects (0.14 #t) ==> ok
test flonum reader, expects (3.0 #t) ==> ok
test flonum reader, expects (0.0 #t) ==> ok
test flonum reader, expects (0.0 #t) ==> ok
test flonum reader, expects #f ==> ok
test flonum reader, expects #f ==> ok
test flonum reader, expects #f ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (-314.0 #t) ==> ok
test flonum reader (exp), expects (-314.0 #t) ==> ok
test flonum reader (exp), expects (-314.0 #t) ==> ok
test flonum reader (exp), expects (-314.0 #t) ==> ok
test flonum reader (exp), expects (-314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (exp), expects (314.0 #t) ==> ok
test flonum reader (minimum denormalized number 5.0e-324), expects #t ==> ok
test flonum reader (minimum denormalized number -5.0e-324), expects #t ==> ok
test flonum reader (minimum normalized number), expects #t ==> ok
test padding, expects (10.0 #t) ==> ok
test padding, expects (10.0 #t) ==> ok
test padding, expects (10.0 #t) ==> ok
test padding, expects (100.0 #t) ==> ok
test padding, expects (100.0 #t) ==> ok
test padding, expects (100.0 #t) ==> ok
test padding, expects (1.0 #t) ==> ok
test padding, expects |1#1| ==> ok
test padding, expects |1##1| ==> ok
test padding, expects |1#.1| ==> ok
test padding, expects |1.#1| ==> ok
test padding, expects |.#| ==> ok
test padding, expects (0.0 #t) ==> ok
test padding, expects (0.0 #t) ==> ok
test padding, expects (0.0 #t) ==> ok
test padding, expects (0.0 #t) ==> ok
test padding, expects |0#.0| ==> ok
test padding, expects (1000.0 #t) ==> ok
test padding, expects (1000.0 #t) ==> ok
test padding, expects (1000.0 #t) ==> ok
test padding, expects (0.0 #t) ==> ok
test padding, expects (0.0 #t) ==> ok
test padding, expects |.##e2| ==> ok
test padding (exactness), expects (100 #f) ==> ok
test padding (exactness), expects (120 #f) ==> ok
test padding (exactness), expects (120 #f) ==> ok
test padding (exactness), expects (100.0 #t) ==> ok
test padding (exactness), expects (120.0 #t) ==> ok
test padding (exactness), expects (120.0 #t) ==> ok
test exponent out-of-range 1, expects (+inf.0 #t) ==> ok
test exponent out-of-range 2, expects (+inf.0 #t) ==> ok
test exponent out-of-range 3, expects (+inf.0 #t) ==> ok
test exponent out-of-range 4, expects (-inf.0 #t) ==> ok
test exponent out-of-range 5, expects (-inf.0 #t) ==> ok
test exponent out-of-range 6, expects (-inf.0 #t) ==> ok
test exponent out-of-range 7, expects (0.0 #t) ==> ok
test exponent out-of-range 8, expects (0.0 #t) ==> ok
test exponent out-of-range 9, expects (0.0 #t) ==> ok
test no integral part, expects 0.5 ==> ok
test no integral part, expects -0.5 ==> ok
test no integral part, expects 0.5 ==> ok
<exact fractional number>------------------------------------------------------
test exact fractonal number, expects 12345 ==> ok
test exact fractonal number, expects 123450000000000 ==> ok
test exact fractonal number, expects 2469/20 ==> ok
test exact fractonal number, expects 2469/200000 ==> ok
test exact fractonal number, expects -12345 ==> ok
test exact fractonal number, expects -123450000000000 ==> ok
test exact fractonal number, expects -2469/20 ==> ok
test exact fractonal number, expects -2469/200000 ==> ok
test exact fractonal number, expects 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ==> ok
test exact fractonal number, expects -100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 ==> ok
test exact fractonal number, expects #<error> ==> ok
test exact fractonal number, expects #<error> ==> ok
<complex reader>---------------------------------------------------------------
test complex reader, expects (1.0 1.0) ==> ok
test complex reader, expects (1.0 1.0) ==> ok
test complex reader, expects (1.0 -1.0) ==> ok
test complex reader, expects (1.0 -1.0) ==> ok
test complex reader, expects (1.0 1.0) ==> ok
test complex reader, expects (1.0 1.0) ==> ok
test complex reader, expects (1.0e-5 1.0) ==> ok
test complex reader, expects (100000.0 1.0) ==> ok
test complex reader, expects (1.0 1.0e-5) ==> ok
test complex reader, expects (1.0 100000.0) ==> ok
test complex reader, expects (0.1 10000.0) ==> ok
test complex reader, expects (0.0 1.0) ==> ok
test complex reader, expects (0.0 -1.0) ==> ok
test complex reader, expects (0.0 1.0) ==> ok
test complex reader, expects (0.0 -1.0) ==> ok
test complex reader, expects (0.0 1.0) ==> ok
test complex reader, expects (0.0 -1.0) ==> ok
test complex reader, expects (0.0 1.0) ==> ok
test complex reader, expects (0.0 -1.0) ==> ok
test complex reader, expects 1.0 ==> ok
test complex reader, expects 1.0 ==> ok
test complex reader, expects 1.0 ==> ok
test complex reader, expects 1.0 ==> ok
test complex reader, expects 100.0 ==> ok
test complex reader, expects i ==> ok
test complex reader, expects #f ==> ok
test complex reader, expects #f ==> ok
test complex reader, expects #f ==> ok
test complex reader, expects |33i| ==> ok
test complex reader, expects i+1 ==> ok
test complex reader, expects |++i| ==> ok
test complex reader, expects |--i| ==> ok
test complex reader, expects (0.5 0.5) ==> ok
test complex reader, expects (0.0 0.5) ==> ok
test complex reader, expects (0.0 -0.5) ==> ok
test complex reader, expects 1/2 ==> ok
test complex reader, expects (0.5 -inf.0) ==> ok
test complex reader (polar), expects 0.5403023058681398+0.8414709848078965i ==> ok
test complex reader (polar), expects 0.5403023058681398-0.8414709848078965i ==> ok
test complex reader (polar), expects 0.5403023058681398+0.8414709848078965i ==> ok
test complex reader (polar), expects 6.929947476203118+0.9878400564190705i ==> ok
test complex reader (polar), expects -3.464973738101559-0.49392002820953523i ==> ok
test complex reader (polar), expects #f ==> ok
<integer writer syntax>--------------------------------------------------------
test around 2^28, expects ("268435456" "536870911" "536870912" "-268435456" "-536870911" "-536870912" "-536870913") ==> ok
test around 2^31, expects ("2147483648" "4294967295" "4294967296" "-2147483648" "-4294967295" "-4294967296" "-4294967297") ==> ok
test around 2^60, expects ("1152921504606846976" "2305843009213693951" "2305843009213693952" "-1152921504606846976" "-2305843009213693951" "-2305843009213693952" "-2305843009213693953") ==> ok
test around 2^63, expects ("9223372036854775808" "18446744073709551615" "18446744073709551616" "-9223372036854775808" "-18446744073709551615" "-18446744073709551616" "-18446744073709551617") ==> ok
test around 2^127, expects ("170141183460469231731687303715884105728" "340282366920938463463374607431768211455" "340282366920938463463374607431768211456" "-170141183460469231731687303715884105728" "-340282366920938463463374607431768211455" "-340282366920938463463374607431768211456" "-340282366920938463463374607431768211457") ==> ok
<expt>-------------------------------------------------------------------------
test exact expt, expects 1 ==> ok
test exact expt, expects 9765625 ==> ok
test exact expt, expects 1220703125 ==> ok
test exact expt, expects 94039548065783000637498922977779654225493244541767001720700136502273380756378173828125 ==> ok
test exact expt, expects 1/94039548065783000637498922977779654225493244541767001720700136502273380756378173828125 ==> ok
test exact expt, expects 1 ==> ok
test exact expt, expects 9765625 ==> ok
test exact expt, expects -1220703125 ==> ok
test exact expt, expects -94039548065783000637498922977779654225493244541767001720700136502273380756378173828125 ==> ok
test exact expt, expects -1/94039548065783000637498922977779654225493244541767001720700136502273380756378173828125 ==> ok
test exact expt, expects 1 ==> ok
test exact expt, expects 1 ==> ok
test exact expt, expects -1 ==> ok
test exact expt (ratinoal), expects 8589934592/5559060566555523 ==> ok
test exact expt (rational), expects -8589934592/5559060566555523 ==> ok
test exact expt (ratinoal), expects 5559060566555523/8589934592 ==> ok
test expt (coercion to inexact), expects 1.4142135623730951 ==> ok
<exact<->inexact>--------------------------------------------------------------
test exact->inexact 0.0, expects 0.0 ==> ok
test exact->inexact 0.0, expects 0.0 ==> ok
test inexact->exact 0, expects 0 ==> ok
test inexact->exact 0, expects 0 ==> ok
test exact->inexact 1.0, expects 1.0 ==> ok
test exact->inexact -1.0, expects -1.0 ==> ok
test inexact->exact 1, expects 1 ==> ok
test inexact->exact -1, expects -1 ==> ok
test exact->inexact 4.503599627370496e15, expects 4.503599627370496e15 ==> ok
test exact->inexact -4.503599627370496e15, expects -4.503599627370496e15 ==> ok
test inexact->exact 4503599627370496, expects 4503599627370496 ==> ok
test inexact->exact -4503599627370496, expects -4503599627370496 ==> ok
test exact->inexact 9.007199254740992e15, expects 9.007199254740992e15 ==> ok
test exact->inexact -9.007199254740992e15, expects -9.007199254740992e15 ==> ok
test inexact->exact 9007199254740992, expects 9007199254740992 ==> ok
test inexact->exact -9007199254740992, expects -9007199254740992 ==> ok
test exact->inexact 1.8014398509481984e16, expects 1.8014398509481984e16 ==> ok
test exact->inexact -1.8014398509481984e16, expects -1.8014398509481984e16 ==> ok
test inexact->exact 18014398509481984, expects 18014398509481984 ==> ok
test inexact->exact -18014398509481984, expects -18014398509481984 ==> ok
test exact->inexact 0.5, expects 0.5 ==> ok
test exact->inexact -0.5, expects -0.5 ==> ok
test inexact->exact 1/2, expects 1/2 ==> ok
test inexact->exact -1/2, expects -1/2 ==> ok
test exact->inexact 0.75, expects 0.75 ==> ok
test exact->inexact -0.75, expects -0.75 ==> ok
test inexact->exact 3/4, expects 3/4 ==> ok
test inexact->exact -3/4, expects -3/4 ==> ok
test exact->inexact 0.3333333333333333, expects 0.3333333333333333 ==> ok
test exact->inexact -0.3333333333333333, expects -0.3333333333333333 ==> ok
test inexact->exact 1/3, expects 1/3 ==> ok
test inexact->exact -1/3, expects -1/3 ==> ok
test inexact->exact->inexact roundtrip "1+d", expects 1.0000000000000002 ==> ERROR: GOT 1.0000000000000004
test inexact->exact->inexact roundtrip "1-d", expects 0.9999999999999999 ==> ERROR: GOT 0.9999999999999998
test exact->inexact, pattern a: round down (0), expects 9.007199254740992e15 ==> ok
test exact->inexact, pattern b: round up   (0), expects 9.007199254740994e15 ==> ok
test exact->inexact, pattern c: round up   (0), expects 9.007199254740996e15 ==> ok
test exact->inexact, pattern d: round down (0), expects 9.007199254740994e15 ==> ok
test exact->inexact, pattern e: round up   (0), expects 1.8014398509481984e16 ==> ok
test exact->inexact, pattern f: round up   (0), expects 1.3510798882111488e16 ==> ok
test exact->inexact, pattern g: round up   (0), expects 9.007207844675584e15 ==> ok
test exact->inexact, pattern a: round down (1), expects 1.8014398509481984e16 ==> ok
test exact->inexact, pattern b: round up   (1), expects 1.8014398509481988e16 ==> ok
test exact->inexact, pattern c: round up   (1), expects 1.801439850948199e16 ==> ok
test exact->inexact, pattern d: round down (1), expects 1.8014398509481988e16 ==> ok
test exact->inexact, pattern e: round up   (1), expects 3.602879701896397e16 ==> ok
test exact->inexact, pattern f: round up   (1), expects 2.7021597764222976e16 ==> ok
test exact->inexact, pattern g: round up   (1), expects 1.801441568935117e16 ==> ok
test exact->inexact, pattern a: round down (2), expects 3.602879701896397e16 ==> ok
test exact->inexact, pattern b: round up   (2), expects 3.6028797018963976e16 ==> ok
test exact->inexact, pattern c: round up   (2), expects 3.602879701896398e16 ==> ok
test exact->inexact, pattern d: round down (2), expects 3.6028797018963976e16 ==> ok
test exact->inexact, pattern e: round up   (2), expects 7.205759403792794e16 ==> ok
test exact->inexact, pattern f: round up   (2), expects 5.404319552844595e16 ==> ok
test exact->inexact, pattern g: round up   (2), expects 3.602883137870234e16 ==> ok
test exact->inexact, pattern a: round down (3), expects 7.205759403792794e16 ==> ok
test exact->inexact, pattern b: round up   (3), expects 7.205759403792795e16 ==> ok
test exact->inexact, pattern c: round up   (3), expects 7.205759403792797e16 ==> ok
test exact->inexact, pattern d: round down (3), expects 7.205759403792795e16 ==> ok
test exact->inexact, pattern e: round up   (3), expects 1.4411518807585587e17 ==> ok
test exact->inexact, pattern f: round up   (3), expects 1.080863910568919e17 ==> ok
test exact->inexact, pattern g: round up   (3), expects 7.205766275740467e16 ==> ok
test exact->inexact, pattern a: round down (4), expects 1.4411518807585587e17 ==> ok
test exact->inexact, pattern b: round up   (4), expects 1.441151880758559e17 ==> ok
test exact->inexact, pattern c: round up   (4), expects 1.4411518807585594e17 ==> ok
test exact->inexact, pattern d: round down (4), expects 1.441151880758559e17 ==> ok
test exact->inexact, pattern e: round up   (4), expects 2.8823037615171174e17 ==> ok
test exact->inexact, pattern f: round up   (4), expects 2.161727821137838e17 ==> ok
test exact->inexact, pattern g: round up   (4), expects 1.4411532551480934e17 ==> ok
test exact->inexact, pattern a: round down (5), expects 2.8823037615171174e17 ==> ok
test exact->inexact, pattern b: round up   (5), expects 2.882303761517118e17 ==> ok
test exact->inexact, pattern c: round up   (5), expects 2.882303761517119e17 ==> ok
test exact->inexact, pattern d: round down (5), expects 2.882303761517118e17 ==> ok
test exact->inexact, pattern e: round up   (5), expects 5.764607523034235e17 ==> ok
test exact->inexact, pattern f: round up   (5), expects 4.323455642275676e17 ==> ok
test exact->inexact, pattern g: round up   (5), expects 2.882306510296187e17 ==> ok
test exact->inexact, pattern a: round down (6), expects 5.764607523034235e17 ==> ok
test exact->inexact, pattern b: round up   (6), expects 5.764607523034236e17 ==> ok
test exact->inexact, pattern c: round up   (6), expects 5.764607523034237e17 ==> ok
test exact->inexact, pattern d: round down (6), expects 5.764607523034236e17 ==> ok
test exact->inexact, pattern e: round up   (6), expects 1.152921504606847e18 ==> ok
test exact->inexact, pattern f: round up   (6), expects 8.646911284551352e17 ==> ok
test exact->inexact, pattern g: round up   (6), expects 5.764613020592374e17 ==> ok
test exact->inexact, pattern a: round down (7), expects 1.152921504606847e18 ==> ok
test exact->inexact, pattern b: round up   (7), expects 1.1529215046068472e18 ==> ok
test exact->inexact, pattern c: round up   (7), expects 1.1529215046068475e18 ==> ok
test exact->inexact, pattern d: round down (7), expects 1.1529215046068472e18 ==> ok
test exact->inexact, pattern e: round up   (7), expects 2.305843009213694e18 ==> ok
test exact->inexact, pattern f: round up   (7), expects 1.7293822569102705e18 ==> ok
test exact->inexact, pattern g: round up   (7), expects 1.1529226041184748e18 ==> ok
test exact->inexact, pattern a: round down (8), expects 2.305843009213694e18 ==> ok
test exact->inexact, pattern b: round up   (8), expects 2.3058430092136945e18 ==> ok
test exact->inexact, pattern c: round up   (8), expects 2.305843009213695e18 ==> ok
test exact->inexact, pattern d: round down (8), expects 2.3058430092136945e18 ==> ok
test exact->inexact, pattern e: round up   (8), expects 4.611686018427388e18 ==> ok
test exact->inexact, pattern f: round up   (8), expects 3.458764513820541e18 ==> ok
test exact->inexact, pattern g: round up   (8), expects 2.3058452082369495e18 ==> ok
test exact->inexact, pattern a: round down (9), expects 4.611686018427388e18 ==> ok
test exact->inexact, pattern b: round up   (9), expects 4.611686018427389e18 ==> ok
test exact->inexact, pattern c: round up   (9), expects 4.61168601842739e18 ==> ok
test exact->inexact, pattern d: round down (9), expects 4.611686018427389e18 ==> ok
test exact->inexact, pattern e: round up   (9), expects 9.223372036854776e18 ==> ok
test exact->inexact, pattern f: round up   (9), expects 6.917529027641082e18 ==> ok
test exact->inexact, pattern g: round up   (9), expects 4.611690416473899e18 ==> ok
test exact->inexact, pattern a: round down (10), expects 9.223372036854776e18 ==> ok
test exact->inexact, pattern b: round up   (10), expects 9.223372036854778e18 ==> ok
test exact->inexact, pattern c: round up   (10), expects 9.22337203685478e18 ==> ok
test exact->inexact, pattern d: round down (10), expects 9.223372036854778e18 ==> ok
test exact->inexact, pattern e: round up   (10), expects 1.8446744073709552e19 ==> ok
test exact->inexact, pattern f: round up   (10), expects 1.3835058055282164e19 ==> ok
test exact->inexact, pattern g: round up   (10), expects 9.223380832947798e18 ==> ok
test exact->inexact, pattern a: round down (11), expects 1.8446744073709552e19 ==> ok
test exact->inexact, pattern b: round up   (11), expects 1.8446744073709556e19 ==> ok
test exact->inexact, pattern c: round up   (11), expects 1.844674407370956e19 ==> ok
test exact->inexact, pattern d: round down (11), expects 1.8446744073709556e19 ==> ok
test exact->inexact, pattern e: round up   (11), expects 3.6893488147419103e19 ==> ok
test exact->inexact, pattern f: round up   (11), expects 2.7670116110564327e19 ==> ok
test exact->inexact, pattern g: round up   (11), expects 1.8446761665895596e19 ==> ok
test exact->inexact, pattern a: round down (12), expects 3.6893488147419103e19 ==> ok
test exact->inexact, pattern b: round up   (12), expects 3.689348814741911e19 ==> ok
test exact->inexact, pattern c: round up   (12), expects 3.689348814741912e19 ==> ok
test exact->inexact, pattern d: round down (12), expects 3.689348814741911e19 ==> ok
test exact->inexact, pattern e: round up   (12), expects 7.378697629483821e19 ==> ok
test exact->inexact, pattern f: round up   (12), expects 5.5340232221128655e19 ==> ok
test exact->inexact, pattern g: round up   (12), expects 3.689352333179119e19 ==> ok
test exact->inexact, pattern a: round down (13), expects 7.378697629483821e19 ==> ok
test exact->inexact, pattern b: round up   (13), expects 7.378697629483822e19 ==> ok
test exact->inexact, pattern c: round up   (13), expects 7.378697629483824e19 ==> ok
test exact->inexact, pattern d: round down (13), expects 7.378697629483822e19 ==> ok
test exact->inexact, pattern e: round up   (13), expects 1.4757395258967641e20 ==> ok
test exact->inexact, pattern f: round up   (13), expects 1.1068046444225731e20 ==> ok
test exact->inexact, pattern g: round up   (13), expects 7.378704666358238e19 ==> ok
test exact->inexact, pattern a: round down (14), expects 1.4757395258967641e20 ==> ok
test exact->inexact, pattern b: round up   (14), expects 1.4757395258967645e20 ==> ok
test exact->inexact, pattern c: round up   (14), expects 1.4757395258967648e20 ==> ok
test exact->inexact, pattern d: round down (14), expects 1.4757395258967645e20 ==> ok
test exact->inexact, pattern e: round up   (14), expects 2.9514790517935283e20 ==> ok
test exact->inexact, pattern f: round up   (14), expects 2.2136092888451462e20 ==> ok
test exact->inexact, pattern g: round up   (14), expects 1.4757409332716477e20 ==> ok
test exact->inexact, pattern a: round down (15), expects 2.9514790517935283e20 ==> ok
test exact->inexact, pattern b: round up   (15), expects 2.951479051793529e20 ==> ok
test exact->inexact, pattern c: round up   (15), expects 2.9514790517935296e20 ==> ok
test exact->inexact, pattern d: round down (15), expects 2.951479051793529e20 ==> ok
test exact->inexact, pattern e: round up   (15), expects 5.902958103587057e20 ==> ok
test exact->inexact, pattern f: round up   (15), expects 4.4272185776902924e20 ==> ok
test exact->inexact, pattern g: round up   (15), expects 2.9514818665432954e20 ==> ok
test exact->inexact, pattern a: round down (16), expects 5.902958103587057e20 ==> ok
test exact->inexact, pattern b: round up   (16), expects 5.902958103587058e20 ==> ok
test exact->inexact, pattern c: round up   (16), expects 5.902958103587059e20 ==> ok
test exact->inexact, pattern d: round down (16), expects 5.902958103587058e20 ==> ok
test exact->inexact, pattern e: round up   (16), expects 1.1805916207174113e21 ==> ok
test exact->inexact, pattern f: round up   (16), expects 8.854437155380585e20 ==> ok
test exact->inexact, pattern g: round up   (16), expects 5.902963733086591e20 ==> ok
test exact->inexact, pattern a: round down (17), expects 1.1805916207174113e21 ==> ok
test exact->inexact, pattern b: round up   (17), expects 1.1805916207174116e21 ==> ok
test exact->inexact, pattern c: round up   (17), expects 1.1805916207174118e21 ==> ok
test exact->inexact, pattern d: round down (17), expects 1.1805916207174116e21 ==> ok
test exact->inexact, pattern e: round up   (17), expects 2.3611832414348226e21 ==> ok
test exact->inexact, pattern f: round up   (17), expects 1.770887431076117e21 ==> ok
test exact->inexact, pattern g: round up   (17), expects 1.1805927466173181e21 ==> ok
test exact->inexact, pattern a: round down (18), expects 2.3611832414348226e21 ==> ok
test exact->inexact, pattern b: round up   (18), expects 2.361183241434823e21 ==> ok
test exact->inexact, pattern c: round up   (18), expects 2.3611832414348237e21 ==> ok
test exact->inexact, pattern d: round down (18), expects 2.361183241434823e21 ==> ok
test exact->inexact, pattern e: round up   (18), expects 4.722366482869645e21 ==> ok
test exact->inexact, pattern f: round up   (18), expects 3.541774862152234e21 ==> ok
test exact->inexact, pattern g: round up   (18), expects 2.3611854932346363e21 ==> ok
test exact->inexact, pattern a: round down (19), expects 4.722366482869645e21 ==> ok
test exact->inexact, pattern b: round up   (19), expects 4.722366482869646e21 ==> ok
test exact->inexact, pattern c: round up   (19), expects 4.722366482869647e21 ==> ok
test exact->inexact, pattern d: round down (19), expects 4.722366482869646e21 ==> ok
test exact->inexact, pattern e: round up   (19), expects 9.44473296573929e21 ==> ok
test exact->inexact, pattern f: round up   (19), expects 7.083549724304468e21 ==> ok
test exact->inexact, pattern g: round up   (19), expects 4.722370986469273e21 ==> ok
test exact->inexact, pattern a: round down (20), expects 9.44473296573929e21 ==> ok
test exact->inexact, pattern b: round up   (20), expects 9.444732965739293e21 ==> ok
test exact->inexact, pattern c: round up   (20), expects 9.444732965739295e21 ==> ok
test exact->inexact, pattern d: round down (20), expects 9.444732965739293e21 ==> ok
test exact->inexact, pattern e: round up   (20), expects 1.888946593147858e22 ==> ok
test exact->inexact, pattern f: round up   (20), expects 1.4167099448608936e22 ==> ok
test exact->inexact, pattern g: round up   (20), expects 9.444741972938545e21 ==> ok
test exact->inexact, pattern a: round down (21), expects 1.888946593147858e22 ==> ok
test exact->inexact, pattern b: round up   (21), expects 1.8889465931478585e22 ==> ok
test exact->inexact, pattern c: round up   (21), expects 1.888946593147859e22 ==> ok
test exact->inexact, pattern d: round down (21), expects 1.8889465931478585e22 ==> ok
test exact->inexact, pattern e: round up   (21), expects 3.777893186295716e22 ==> ok
test exact->inexact, pattern f: round up   (21), expects 2.833419889721787e22 ==> ok
test exact->inexact, pattern g: round up   (21), expects 1.888948394587709e22 ==> ok
test exact->inexact, pattern a: round down (22), expects 3.777893186295716e22 ==> ok
test exact->inexact, pattern b: round up   (22), expects 3.777893186295717e22 ==> ok
test exact->inexact, pattern c: round up   (22), expects 3.777893186295718e22 ==> ok
test exact->inexact, pattern d: round down (22), expects 3.777893186295717e22 ==> ok
test exact->inexact, pattern e: round up   (22), expects 7.555786372591432e22 ==> ok
test exact->inexact, pattern f: round up   (22), expects 5.666839779443574e22 ==> ok
test exact->inexact, pattern g: round up   (22), expects 3.777896789175418e22 ==> ok
test exact->inexact, pattern a: round down (23), expects 7.555786372591432e22 ==> ok
test exact->inexact, pattern b: round up   (23), expects 7.555786372591434e22 ==> ok
test exact->inexact, pattern c: round up   (23), expects 7.555786372591436e22 ==> ok
test exact->inexact, pattern d: round down (23), expects 7.555786372591434e22 ==> ok
test exact->inexact, pattern e: round up   (23), expects 1.5111572745182865e23 ==> ok
test exact->inexact, pattern f: round up   (23), expects 1.1333679558887149e23 ==> ok
test exact->inexact, pattern g: round up   (23), expects 7.555793578350836e22 ==> ok
test exact->inexact, pattern a: round down (24), expects 1.5111572745182865e23 ==> ok
test exact->inexact, pattern b: round up   (24), expects 1.5111572745182868e23 ==> ok
test exact->inexact, pattern c: round up   (24), expects 1.511157274518287e23 ==> ok
test exact->inexact, pattern d: round down (24), expects 1.5111572745182868e23 ==> ok
test exact->inexact, pattern e: round up   (24), expects 3.022314549036573e23 ==> ok
test exact->inexact, pattern f: round up   (24), expects 2.2667359117774297e23 ==> ok
test exact->inexact, pattern g: round up   (24), expects 1.5111587156701672e23 ==> ok
test exact->inexact, pattern a: round down (25), expects 3.022314549036573e23 ==> ok
test exact->inexact, pattern b: round up   (25), expects 3.0223145490365736e23 ==> ok
test exact->inexact, pattern c: round up   (25), expects 3.022314549036574e23 ==> ok
test exact->inexact, pattern d: round down (25), expects 3.0223145490365736e23 ==> ok
test exact->inexact, pattern e: round up   (25), expects 6.044629098073146e23 ==> ok
test exact->inexact, pattern f: round up   (25), expects 4.5334718235548594e23 ==> ok
test exact->inexact, pattern g: round up   (25), expects 3.0223174313403345e23 ==> ok
test exact->inexact, pattern a: round down (26), expects 6.044629098073146e23 ==> ok
test exact->inexact, pattern b: round up   (26), expects 6.044629098073147e23 ==> ok
test exact->inexact, pattern c: round up   (26), expects 6.044629098073149e23 ==> ok
test exact->inexact, pattern d: round down (26), expects 6.044629098073147e23 ==> ok
test exact->inexact, pattern e: round up   (26), expects 1.2089258196146292e24 ==> ok
test exact->inexact, pattern f: round up   (26), expects 9.066943647109719e23 ==> ok
test exact->inexact, pattern g: round up   (26), expects 6.044634862680669e23 ==> ok
test exact->inexact, pattern a: round down (27), expects 1.2089258196146292e24 ==> ok
test exact->inexact, pattern b: round up   (27), expects 1.2089258196146294e24 ==> ok
test exact->inexact, pattern c: round up   (27), expects 1.2089258196146297e24 ==> ok
test exact->inexact, pattern d: round down (27), expects 1.2089258196146294e24 ==> ok
test exact->inexact, pattern e: round up   (27), expects 2.4178516392292583e24 ==> ok
test exact->inexact, pattern f: round up   (27), expects 1.8133887294219438e24 ==> ok
test exact->inexact, pattern g: round up   (27), expects 1.2089269725361338e24 ==> ok
test exact->inexact, pattern a: round down (28), expects 2.4178516392292583e24 ==> ok
test exact->inexact, pattern b: round up   (28), expects 2.417851639229259e24 ==> ok
test exact->inexact, pattern c: round up   (28), expects 2.4178516392292594e24 ==> ok
test exact->inexact, pattern d: round down (28), expects 2.417851639229259e24 ==> ok
test exact->inexact, pattern e: round up   (28), expects 4.835703278458517e24 ==> ok
test exact->inexact, pattern f: round up   (28), expects 3.6267774588438875e24 ==> ok
test exact->inexact, pattern g: round up   (28), expects 2.4178539450722676e24 ==> ok
test exact->inexact, pattern a: round down (29), expects 4.835703278458517e24 ==> ok
test exact->inexact, pattern b: round up   (29), expects 4.835703278458518e24 ==> ok
test exact->inexact, pattern c: round up   (29), expects 4.835703278458519e24 ==> ok
test exact->inexact, pattern d: round down (29), expects 4.835703278458518e24 ==> ok
test exact->inexact, pattern e: round up   (29), expects 9.671406556917033e24 ==> ok
test exact->inexact, pattern f: round up   (29), expects 7.253554917687775e24 ==> ok
test exact->inexact, pattern g: round up   (29), expects 4.835707890144535e24 ==> ok
test exact->inexact, pattern a: round down (30), expects 9.671406556917033e24 ==> ok
test exact->inexact, pattern b: round up   (30), expects 9.671406556917036e24 ==> ok
test exact->inexact, pattern c: round up   (30), expects 9.671406556917038e24 ==> ok
test exact->inexact, pattern d: round down (30), expects 9.671406556917036e24 ==> ok
test exact->inexact, pattern e: round up   (30), expects 1.9342813113834067e25 ==> ok
test exact->inexact, pattern f: round up   (30), expects 1.450710983537555e25 ==> ok
test exact->inexact, pattern g: round up   (30), expects 9.67141578028907e24 ==> ok
test exact->inexact, pattern a: round down (31), expects 1.9342813113834067e25 ==> ok
test exact->inexact, pattern b: round up   (31), expects 1.934281311383407e25 ==> ok
test exact->inexact, pattern c: round up   (31), expects 1.9342813113834075e25 ==> ok
test exact->inexact, pattern d: round down (31), expects 1.934281311383407e25 ==> ok
test exact->inexact, pattern e: round up   (31), expects 3.8685626227668134e25 ==> ok
test exact->inexact, pattern f: round up   (31), expects 2.90142196707511e25 ==> ok
test exact->inexact, pattern g: round up   (31), expects 1.934283156057814e25 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 1, expects 3.205068552596811e-18 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 2, expects -2.848949824530498e-18 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 3, expects 1.0e-308 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 4, expects 0.0 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 5, expects 1.0e308 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 6, expects +inf.0 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 7, expects -inf.0 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 8, expects -inf.0 ==> ok
test expt (ratnum with large denom and numer) with inexact conversion 9, expects +inf.0 ==> ok
test rationalize (edge cases), expects (#t #t #t +inf.0 -inf.0 0.0) ==> ok
test rationalize (integers), expects (1 2 0 -1 -2 0) ==> ok
test rationalize (exactness), expects (#t #f #f #f) ==> ok
<predicates>-------------------------------------------------------------------
test integer?, expects #t ==> ok
test integer?, expects #t ==> ok
test integer?, expects #f ==> ok
test integer?, expects #f ==> ok
test integer?, expects #f ==> ok
test integer?, expects #t ==> ok
test integer?, expects #f ==> ok
test integer?, expects #f ==> ok
test integer?, expects #f ==> ok
test integer?, expects #f ==> ok
test rational?, expects #t ==> ok
test rational?, expects #t ==> ok
test rational?, expects #t ==> ok
test rational?, expects #t ==> ok
test rational?, expects #t ==> ok
test rational?, expects #f ==> ok
test rational?, expects #t ==> ok
test rational?, expects #f ==> ok
test rational?, expects #f ==> ok
test rational?, expects #f ==> ok
test rational?, expects #f ==> ok
test real?, expects #t ==> ok
test real?, expects #t ==> ok
test real?, expects #t ==> ok
test real?, expects #t ==> ok
test real?, expects #f ==> ok
test real?, expects #f ==> ok
test real?, expects #f ==> ok
test real?, expects #t ==> ok
test real?, expects #t ==> ok
test real?, expects #t ==> ok
test complex?, expects #t ==> ok
test complex?, expects #t ==> ok
test complex?, expects #t ==> ok
test complex?, expects #t ==> ok
test complex?, expects #t ==> ok
test complex?, expects #t ==> ok
test complex?, expects #f ==> ok
test number?, expects #t ==> ok
test number?, expects #t ==> ok
test number?, expects #t ==> ok
test number?, expects #t ==> ok
test number?, expects #t ==> ok
test number?, expects #t ==> ok
test number?, expects #f ==> ok
test exact?, expects #t ==> ok
test exact?, expects #t ==> ok
test exact?, expects #t ==> ok
test exact?, expects #f ==> ok
test exact?, expects #f ==> ok
test exact?, expects #f ==> ok
test exact?, expects #f ==> ok
test inexact?, expects #f ==> ok
test inexact?, expects #f ==> ok
test inexact?, expects #f ==> ok
test inexact?, expects #t ==> ok
test inexact?, expects #t ==> ok
test inexact?, expects #t ==> ok
test inexact?, expects #t ==> ok
test odd?, expects #t ==> ok
test odd?, expects #f ==> ok
test even?, expects #f ==> ok
test even?, expects #t ==> ok
test odd?, expects #t ==> ok
test odd?, expects #f ==> ok
test even?, expects #f ==> ok
test even?, expects #t ==> ok
test odd?, expects #t ==> ok
test odd?, expects #f ==> ok
test even?, expects #f ==> ok
test even?, expects #t ==> ok
test zero?, expects #t ==> ok
test zero?, expects #t ==> ok
test zero?, expects #t ==> ok
test zero?, expects #t ==> ok
test zero?, expects #f ==> ok
test zero?, expects #f ==> ok
test positive?, expects #t ==> ok
test positive?, expects #f ==> ok
test positive?, expects #t ==> ok
test positive?, expects #f ==> ok
test positive?, expects #t ==> ok
test positive?, expects #f ==> ok
test positive?, expects #t ==> ok
test positive?, expects #f ==> ok
test negative?, expects #f ==> ok
test negative?, expects #t ==> ok
test negative?, expects #f ==> ok
test negative?, expects #t ==> ok
test negative?, expects #f ==> ok
test negative?, expects #t ==> ok
test negative?, expects #f ==> ok
test negative?, expects #t ==> ok
test finite?, expects #<error> ==> ok
test finite?, expects (#t #f #f #f) ==> ok
test infinite?, expects #<error> ==> ok
test infinite?, expects (#f #t #t #f) ==> ok
test nan?, expects #<error> ==> ok
test nan?, expects (#f #f #f #t) ==> ok
test eqv?, expects #t ==> ok
test eqv?, expects #t ==> ok
test eqv?, expects #f ==> ok
test eqv?, expects #t ==> ok
test eqv?, expects #t ==> ok
test eqv?, expects #f ==> ok
test NaN = (inlined), expects (#f #f #f) ==> ok
test NaN = (applied), expects (#f #f #f) ==> ok
test NaN < (inlined), expects (#f #f #f) ==> ok
test NaN < (applied), expects (#f #f #f) ==> ok
test NaN <= (inlined), expects (#f #f #f) ==> ok
test NaN <= (applied), expects (#f #f #f) ==> ok
test NaN > (inlined), expects (#f #f #f) ==> ok
test NaN > (applied), expects (#f #f #f) ==> ok
test NaN >= (inlined), expects (#f #f #f) ==> ok
test NaN >= (applied), expects (#f #f #f) ==> ok
test NUMEQF, expects (#t #t #f #f) ==> ok
test NLTF, expects (#f #f #f #t #t #f) ==> ok
test NLEF, expects (#t #t #f #t #t #f) ==> ok
test NGTF, expects (#f #f #t #f #f #t) ==> ok
test NGEF, expects (#t #t #t #f #f #t) ==> ok
test fixnum vs fixnum eq  =(++), expects #t ==> ok
test fixnum vs fixnum eq  =(+-), expects #f ==> ok
test fixnum vs fixnum eq  =(-+), expects #f ==> ok
test fixnum vs fixnum eq  =(--), expects #t ==> ok
test fixnum vs fixnum eq rev =(++), expects #t ==> ok
test fixnum vs fixnum eq rev =(+-), expects #f ==> ok
test fixnum vs fixnum eq rev =(-+), expects #f ==> ok
test fixnum vs fixnum eq rev =(--), expects #t ==> ok
test fixnum vs fixnum eq  >=(++), expects #t ==> ok
test fixnum vs fixnum eq  >=(+-), expects #t ==> ok
test fixnum vs fixnum eq  >=(-+), expects #f ==> ok
test fixnum vs fixnum eq  >=(--), expects #t ==> ok
test fixnum vs fixnum eq rev >=(++), expects #t ==> ok
test fixnum vs fixnum eq rev >=(+-), expects #f ==> ok
test fixnum vs fixnum eq rev >=(-+), expects #t ==> ok
test fixnum vs fixnum eq rev >=(--), expects #t ==> ok
test fixnum vs fixnum eq  >(++), expects #f ==> ok
test fixnum vs fixnum eq  >(+-), expects #t ==> ok
test fixnum vs fixnum eq  >(-+), expects #f ==> ok
test fixnum vs fixnum eq  >(--), expects #f ==> ok
test fixnum vs fixnum eq rev >(++), expects #f ==> ok
test fixnum vs fixnum eq rev >(+-), expects #f ==> ok
test fixnum vs fixnum eq rev >(-+), expects #t ==> ok
test fixnum vs fixnum eq rev >(--), expects #f ==> ok
test fixnum vs fixnum eq  <=(++), expects #t ==> ok
test fixnum vs fixnum eq  <=(+-), expects #f ==> ok
test fixnum vs fixnum eq  <=(-+), expects #t ==> ok
test fixnum vs fixnum eq  <=(--), expects #t ==> ok
test fixnum vs fixnum eq rev <=(++), expects #t ==> ok
test fixnum vs fixnum eq rev <=(+-), expects #t ==> ok
test fixnum vs fixnum eq rev <=(-+), expects #f ==> ok
test fixnum vs fixnum eq rev <=(--), expects #t ==> ok
test fixnum vs fixnum eq  <(++), expects #f ==> ok
test fixnum vs fixnum eq  <(+-), expects #f ==> ok
test fixnum vs fixnum eq  <(-+), expects #t ==> ok
test fixnum vs fixnum eq  <(--), expects #f ==> ok
test fixnum vs fixnum eq rev <(++), expects #f ==> ok
test fixnum vs fixnum eq rev <(+-), expects #t ==> ok
test fixnum vs fixnum eq rev <(-+), expects #f ==> ok
test fixnum vs fixnum eq rev <(--), expects #f ==> ok
test fixnum vs fixnum ne  =(++), expects #f ==> ok
test fixnum vs fixnum ne  =(+-), expects #f ==> ok
test fixnum vs fixnum ne  =(-+), expects #f ==> ok
test fixnum vs fixnum ne  =(--), expects #f ==> ok
test fixnum vs fixnum ne rev =(++), expects #f ==> ok
test fixnum vs fixnum ne rev =(+-), expects #f ==> ok
test fixnum vs fixnum ne rev =(-+), expects #f ==> ok
test fixnum vs fixnum ne rev =(--), expects #f ==> ok
test fixnum vs fixnum ne  >=(++), expects #t ==> ok
test fixnum vs fixnum ne  >=(+-), expects #t ==> ok
test fixnum vs fixnum ne  >=(-+), expects #f ==> ok
test fixnum vs fixnum ne  >=(--), expects #f ==> ok
test fixnum vs fixnum ne rev >=(++), expects #f ==> ok
test fixnum vs fixnum ne rev >=(+-), expects #f ==> ok
test fixnum vs fixnum ne rev >=(-+), expects #t ==> ok
test fixnum vs fixnum ne rev >=(--), expects #t ==> ok
test fixnum vs fixnum ne  >(++), expects #t ==> ok
test fixnum vs fixnum ne  >(+-), expects #t ==> ok
test fixnum vs fixnum ne  >(-+), expects #f ==> ok
test fixnum vs fixnum ne  >(--), expects #f ==> ok
test fixnum vs fixnum ne rev >(++), expects #f ==> ok
test fixnum vs fixnum ne rev >(+-), expects #f ==> ok
test fixnum vs fixnum ne rev >(-+), expects #t ==> ok
test fixnum vs fixnum ne rev >(--), expects #t ==> ok
test fixnum vs fixnum ne  <=(++), expects #f ==> ok
test fixnum vs fixnum ne  <=(+-), expects #f ==> ok
test fixnum vs fixnum ne  <=(-+), expects #t ==> ok
test fixnum vs fixnum ne  <=(--), expects #t ==> ok
test fixnum vs fixnum ne rev <=(++), expects #t ==> ok
test fixnum vs fixnum ne rev <=(+-), expects #t ==> ok
test fixnum vs fixnum ne rev <=(-+), expects #f ==> ok
test fixnum vs fixnum ne rev <=(--), expects #f ==> ok
test fixnum vs fixnum ne  <(++), expects #f ==> ok
test fixnum vs fixnum ne  <(+-), expects #f ==> ok
test fixnum vs fixnum ne  <(-+), expects #t ==> ok
test fixnum vs fixnum ne  <(--), expects #t ==> ok
test fixnum vs fixnum ne rev <(++), expects #t ==> ok
test fixnum vs fixnum ne rev <(+-), expects #t ==> ok
test fixnum vs fixnum ne rev <(-+), expects #f ==> ok
test fixnum vs fixnum ne rev <(--), expects #f ==> ok
test bignum vs fixnum ne  =(++), expects #f ==> ok
test bignum vs fixnum ne  =(+-), expects #f ==> ok
test bignum vs fixnum ne  =(-+), expects #f ==> ok
test bignum vs fixnum ne  =(--), expects #f ==> ok
test bignum vs fixnum ne rev =(++), expects #f ==> ok
test bignum vs fixnum ne rev =(+-), expects #f ==> ok
test bignum vs fixnum ne rev =(-+), expects #f ==> ok
test bignum vs fixnum ne rev =(--), expects #f ==> ok
test bignum vs fixnum ne  >=(++), expects #t ==> ok
test bignum vs fixnum ne  >=(+-), expects #t ==> ok
test bignum vs fixnum ne  >=(-+), expects #f ==> ok
test bignum vs fixnum ne  >=(--), expects #f ==> ok
test bignum vs fixnum ne rev >=(++), expects #f ==> ok
test bignum vs fixnum ne rev >=(+-), expects #f ==> ok
test bignum vs fixnum ne rev >=(-+), expects #t ==> ok
test bignum vs fixnum ne rev >=(--), expects #t ==> ok
test bignum vs fixnum ne  >(++), expects #t ==> ok
test bignum vs fixnum ne  >(+-), expects #t ==> ok
test bignum vs fixnum ne  >(-+), expects #f ==> ok
test bignum vs fixnum ne  >(--), expects #f ==> ok
test bignum vs fixnum ne rev >(++), expects #f ==> ok
test bignum vs fixnum ne rev >(+-), expects #f ==> ok
test bignum vs fixnum ne rev >(-+), expects #t ==> ok
test bignum vs fixnum ne rev >(--), expects #t ==> ok
test bignum vs fixnum ne  <=(++), expects #f ==> ok
test bignum vs fixnum ne  <=(+-), expects #f ==> ok
test bignum vs fixnum ne  <=(-+), expects #t ==> ok
test bignum vs fixnum ne  <=(--), expects #t ==> ok
test bignum vs fixnum ne rev <=(++), expects #t ==> ok
test bignum vs fixnum ne rev <=(+-), expects #t ==> ok
test bignum vs fixnum ne rev <=(-+), expects #f ==> ok
test bignum vs fixnum ne rev <=(--), expects #f ==> ok
test bignum vs fixnum ne  <(++), expects #f ==> ok
test bignum vs fixnum ne  <(+-), expects #f ==> ok
test bignum vs fixnum ne  <(-+), expects #t ==> ok
test bignum vs fixnum ne  <(--), expects #t ==> ok
test bignum vs fixnum ne rev <(++), expects #t ==> ok
test bignum vs fixnum ne rev <(+-), expects #t ==> ok
test bignum vs fixnum ne rev <(-+), expects #f ==> ok
test bignum vs fixnum ne rev <(--), expects #f ==> ok
test bignum vs bignum eq  =(++), expects #t ==> ok
test bignum vs bignum eq  =(+-), expects #f ==> ok
test bignum vs bignum eq  =(-+), expects #f ==> ok
test bignum vs bignum eq  =(--), expects #t ==> ok
test bignum vs bignum eq rev =(++), expects #t ==> ok
test bignum vs bignum eq rev =(+-), expects #f ==> ok
test bignum vs bignum eq rev =(-+), expects #f ==> ok
test bignum vs bignum eq rev =(--), expects #t ==> ok
test bignum vs bignum eq  >=(++), expects #t ==> ok
test bignum vs bignum eq  >=(+-), expects #t ==> ok
test bignum vs bignum eq  >=(-+), expects #f ==> ok
test bignum vs bignum eq  >=(--), expects #t ==> ok
test bignum vs bignum eq rev >=(++), expects #t ==> ok
test bignum vs bignum eq rev >=(+-), expects #f ==> ok
test bignum vs bignum eq rev >=(-+), expects #t ==> ok
test bignum vs bignum eq rev >=(--), expects #t ==> ok
test bignum vs bignum eq  >(++), expects #f ==> ok
test bignum vs bignum eq  >(+-), expects #t ==> ok
test bignum vs bignum eq  >(-+), expects #f ==> ok
test bignum vs bignum eq  >(--), expects #f ==> ok
test bignum vs bignum eq rev >(++), expects #f ==> ok
test bignum vs bignum eq rev >(+-), expects #f ==> ok
test bignum vs bignum eq rev >(-+), expects #t ==> ok
test bignum vs bignum eq rev >(--), expects #f ==> ok
test bignum vs bignum eq  <=(++), expects #t ==> ok
test bignum vs bignum eq  <=(+-), expects #f ==> ok
test bignum vs bignum eq  <=(-+), expects #t ==> ok
test bignum vs bignum eq  <=(--), expects #t ==> ok
test bignum vs bignum eq rev <=(++), expects #t ==> ok
test bignum vs bignum eq rev <=(+-), expects #t ==> ok
test bignum vs bignum eq rev <=(-+), expects #f ==> ok
test bignum vs bignum eq rev <=(--), expects #t ==> ok
test bignum vs bignum eq  <(++), expects #f ==> ok
test bignum vs bignum eq  <(+-), expects #f ==> ok
test bignum vs bignum eq  <(-+), expects #t ==> ok
test bignum vs bignum eq  <(--), expects #f ==> ok
test bignum vs bignum eq rev <(++), expects #f ==> ok
test bignum vs bignum eq rev <(+-), expects #t ==> ok
test bignum vs bignum eq rev <(-+), expects #f ==> ok
test bignum vs bignum eq rev <(--), expects #f ==> ok
test bignum vs bignum ne  =(++), expects #f ==> ok
test bignum vs bignum ne  =(+-), expects #f ==> ok
test bignum vs bignum ne  =(-+), expects #f ==> ok
test bignum vs bignum ne  =(--), expects #f ==> ok
test bignum vs bignum ne rev =(++), expects #f ==> ok
test bignum vs bignum ne rev =(+-), expects #f ==> ok
test bignum vs bignum ne rev =(-+), expects #f ==> ok
test bignum vs bignum ne rev =(--), expects #f ==> ok
test bignum vs bignum ne  >=(++), expects #t ==> ok
test bignum vs bignum ne  >=(+-), expects #t ==> ok
test bignum vs bignum ne  >=(-+), expects #f ==> ok
test bignum vs bignum ne  >=(--), expects #f ==> ok
test bignum vs bignum ne rev >=(++), expects #f ==> ok
test bignum vs bignum ne rev >=(+-), expects #f ==> ok
test bignum vs bignum ne rev >=(-+), expects #t ==> ok
test bignum vs bignum ne rev >=(--), expects #t ==> ok
test bignum vs bignum ne  >(++), expects #t ==> ok
test bignum vs bignum ne  >(+-), expects #t ==> ok
test bignum vs bignum ne  >(-+), expects #f ==> ok
test bignum vs bignum ne  >(--), expects #f ==> ok
test bignum vs bignum ne rev >(++), expects #f ==> ok
test bignum vs bignum ne rev >(+-), expects #f ==> ok
test bignum vs bignum ne rev >(-+), expects #t ==> ok
test bignum vs bignum ne rev >(--), expects #t ==> ok
test bignum vs bignum ne  <=(++), expects #f ==> ok
test bignum vs bignum ne  <=(+-), expects #f ==> ok
test bignum vs bignum ne  <=(-+), expects #t ==> ok
test bignum vs bignum ne  <=(--), expects #t ==> ok
test bignum vs bignum ne rev <=(++), expects #t ==> ok
test bignum vs bignum ne rev <=(+-), expects #t ==> ok
test bignum vs bignum ne rev <=(-+), expects #f ==> ok
test bignum vs bignum ne rev <=(--), expects #f ==> ok
test bignum vs bignum ne  <(++), expects #f ==> ok
test bignum vs bignum ne  <(+-), expects #f ==> ok
test bignum vs bignum ne  <(-+), expects #t ==> ok
test bignum vs bignum ne  <(--), expects #t ==> ok
test bignum vs bignum ne rev <(++), expects #t ==> ok
test bignum vs bignum ne rev <(+-), expects #t ==> ok
test bignum vs bignum ne rev <(-+), expects #f ==> ok
test bignum vs bignum ne rev <(--), expects #f ==> ok
test flonum vs fixnum eq  =(++), expects #t ==> ok
test flonum vs fixnum eq  =(+-), expects #f ==> ok
test flonum vs fixnum eq  =(-+), expects #f ==> ok
test flonum vs fixnum eq  =(--), expects #t ==> ok
test flonum vs fixnum eq rev =(++), expects #t ==> ok
test flonum vs fixnum eq rev =(+-), expects #f ==> ok
test flonum vs fixnum eq rev =(-+), expects #f ==> ok
test flonum vs fixnum eq rev =(--), expects #t ==> ok
test flonum vs fixnum eq  >=(++), expects #t ==> ok
test flonum vs fixnum eq  >=(+-), expects #t ==> ok
test flonum vs fixnum eq  >=(-+), expects #f ==> ok
test flonum vs fixnum eq  >=(--), expects #t ==> ok
test flonum vs fixnum eq rev >=(++), expects #t ==> ok
test flonum vs fixnum eq rev >=(+-), expects #f ==> ok
test flonum vs fixnum eq rev >=(-+), expects #t ==> ok
test flonum vs fixnum eq rev >=(--), expects #t ==> ok
test flonum vs fixnum eq  >(++), expects #f ==> ok
test flonum vs fixnum eq  >(+-), expects #t ==> ok
test flonum vs fixnum eq  >(-+), expects #f ==> ok
test flonum vs fixnum eq  >(--), expects #f ==> ok
test flonum vs fixnum eq rev >(++), expects #f ==> ok
test flonum vs fixnum eq rev >(+-), expects #f ==> ok
test flonum vs fixnum eq rev >(-+), expects #t ==> ok
test flonum vs fixnum eq rev >(--), expects #f ==> ok
test flonum vs fixnum eq  <=(++), expects #t ==> ok
test flonum vs fixnum eq  <=(+-), expects #f ==> ok
test flonum vs fixnum eq  <=(-+), expects #t ==> ok
test flonum vs fixnum eq  <=(--), expects #t ==> ok
test flonum vs fixnum eq rev <=(++), expects #t ==> ok
test flonum vs fixnum eq rev <=(+-), expects #t ==> ok
test flonum vs fixnum eq rev <=(-+), expects #f ==> ok
test flonum vs fixnum eq rev <=(--), expects #t ==> ok
test flonum vs fixnum eq  <(++), expects #f ==> ok
test flonum vs fixnum eq  <(+-), expects #f ==> ok
test flonum vs fixnum eq  <(-+), expects #t ==> ok
test flonum vs fixnum eq  <(--), expects #f ==> ok
test flonum vs fixnum eq rev <(++), expects #f ==> ok
test flonum vs fixnum eq rev <(+-), expects #t ==> ok
test flonum vs fixnum eq rev <(-+), expects #f ==> ok
test flonum vs fixnum eq rev <(--), expects #f ==> ok
test flonum vs fixnum ne  =(++), expects #f ==> ok
test flonum vs fixnum ne  =(+-), expects #f ==> ok
test flonum vs fixnum ne  =(-+), expects #f ==> ok
test flonum vs fixnum ne  =(--), expects #f ==> ok
test flonum vs fixnum ne rev =(++), expects #f ==> ok
test flonum vs fixnum ne rev =(+-), expects #f ==> ok
test flonum vs fixnum ne rev =(-+), expects #f ==> ok
test flonum vs fixnum ne rev =(--), expects #f ==> ok
test flonum vs fixnum ne  >=(++), expects #t ==> ok
test flonum vs fixnum ne  >=(+-), expects #t ==> ok
test flonum vs fixnum ne  >=(-+), expects #f ==> ok
test flonum vs fixnum ne  >=(--), expects #f ==> ok
test flonum vs fixnum ne rev >=(++), expects #f ==> ok
test flonum vs fixnum ne rev >=(+-), expects #f ==> ok
test flonum vs fixnum ne rev >=(-+), expects #t ==> ok
test flonum vs fixnum ne rev >=(--), expects #t ==> ok
test flonum vs fixnum ne  >(++), expects #t ==> ok
test flonum vs fixnum ne  >(+-), expects #t ==> ok
test flonum vs fixnum ne  >(-+), expects #f ==> ok
test flonum vs fixnum ne  >(--), expects #f ==> ok
test flonum vs fixnum ne rev >(++), expects #f ==> ok
test flonum vs fixnum ne rev >(+-), expects #f ==> ok
test flonum vs fixnum ne rev >(-+), expects #t ==> ok
test flonum vs fixnum ne rev >(--), expects #t ==> ok
test flonum vs fixnum ne  <=(++), expects #f ==> ok
test flonum vs fixnum ne  <=(+-), expects #f ==> ok
test flonum vs fixnum ne  <=(-+), expects #t ==> ok
test flonum vs fixnum ne  <=(--), expects #t ==> ok
test flonum vs fixnum ne rev <=(++), expects #t ==> ok
test flonum vs fixnum ne rev <=(+-), expects #t ==> ok
test flonum vs fixnum ne rev <=(-+), expects #f ==> ok
test flonum vs fixnum ne rev <=(--), expects #f ==> ok
test flonum vs fixnum ne  <(++), expects #f ==> ok
test flonum vs fixnum ne  <(+-), expects #f ==> ok
test flonum vs fixnum ne  <(-+), expects #t ==> ok
test flonum vs fixnum ne  <(--), expects #t ==> ok
test flonum vs fixnum ne rev <(++), expects #t ==> ok
test flonum vs fixnum ne rev <(+-), expects #t ==> ok
test flonum vs fixnum ne rev <(-+), expects #f ==> ok
test flonum vs fixnum ne rev <(--), expects #f ==> ok
test flonum vs bignum eq  =(++), expects #t ==> ok
test flonum vs bignum eq  =(+-), expects #f ==> ok
test flonum vs bignum eq  =(-+), expects #f ==> ok
test flonum vs bignum eq  =(--), expects #t ==> ok
test flonum vs bignum eq rev =(++), expects #t ==> ok
test flonum vs bignum eq rev =(+-), expects #f ==> ok
test flonum vs bignum eq rev =(-+), expects #f ==> ok
test flonum vs bignum eq rev =(--), expects #t ==> ok
test flonum vs bignum eq  >=(++), expects #t ==> ok
test flonum vs bignum eq  >=(+-), expects #t ==> ok
test flonum vs bignum eq  >=(-+), expects #f ==> ok
test flonum vs bignum eq  >=(--), expects #t ==> ok
test flonum vs bignum eq rev >=(++), expects #t ==> ok
test flonum vs bignum eq rev >=(+-), expects #f ==> ok
test flonum vs bignum eq rev >=(-+), expects #t ==> ok
test flonum vs bignum eq rev >=(--), expects #t ==> ok
test flonum vs bignum eq  >(++), expects #f ==> ok
test flonum vs bignum eq  >(+-), expects #t ==> ok
test flonum vs bignum eq  >(-+), expects #f ==> ok
test flonum vs bignum eq  >(--), expects #f ==> ok
test flonum vs bignum eq rev >(++), expects #f ==> ok
test flonum vs bignum eq rev >(+-), expects #f ==> ok
test flonum vs bignum eq rev >(-+), expects #t ==> ok
test flonum vs bignum eq rev >(--), expects #f ==> ok
test flonum vs bignum eq  <=(++), expects #t ==> ok
test flonum vs bignum eq  <=(+-), expects #f ==> ok
test flonum vs bignum eq  <=(-+), expects #t ==> ok
test flonum vs bignum eq  <=(--), expects #t ==> ok
test flonum vs bignum eq rev <=(++), expects #t ==> ok
test flonum vs bignum eq rev <=(+-), expects #t ==> ok
test flonum vs bignum eq rev <=(-+), expects #f ==> ok
test flonum vs bignum eq rev <=(--), expects #t ==> ok
test flonum vs bignum eq  <(++), expects #f ==> ok
test flonum vs bignum eq  <(+-), expects #f ==> ok
test flonum vs bignum eq  <(-+), expects #t ==> ok
test flonum vs bignum eq  <(--), expects #f ==> ok
test flonum vs bignum eq rev <(++), expects #f ==> ok
test flonum vs bignum eq rev <(+-), expects #t ==> ok
test flonum vs bignum eq rev <(-+), expects #f ==> ok
test flonum vs bignum eq rev <(--), expects #f ==> ok
test flonum vs bignum ne  =(++), expects #f ==> ok
test flonum vs bignum ne  =(+-), expects #f ==> ok
test flonum vs bignum ne  =(-+), expects #f ==> ok
test flonum vs bignum ne  =(--), expects #f ==> ok
test flonum vs bignum ne rev =(++), expects #f ==> ok
test flonum vs bignum ne rev =(+-), expects #f ==> ok
test flonum vs bignum ne rev =(-+), expects #f ==> ok
test flonum vs bignum ne rev =(--), expects #f ==> ok
test flonum vs bignum ne  >=(++), expects #t ==> ok
test flonum vs bignum ne  >=(+-), expects #t ==> ok
test flonum vs bignum ne  >=(-+), expects #f ==> ok
test flonum vs bignum ne  >=(--), expects #f ==> ok
test flonum vs bignum ne rev >=(++), expects #f ==> ok
test flonum vs bignum ne rev >=(+-), expects #f ==> ok
test flonum vs bignum ne rev >=(-+), expects #t ==> ok
test flonum vs bignum ne rev >=(--), expects #t ==> ok
test flonum vs bignum ne  >(++), expects #t ==> ok
test flonum vs bignum ne  >(+-), expects #t ==> ok
test flonum vs bignum ne  >(-+), expects #f ==> ok
test flonum vs bignum ne  >(--), expects #f ==> ok
test flonum vs bignum ne rev >(++), expects #f ==> ok
test flonum vs bignum ne rev >(+-), expects #f ==> ok
test flonum vs bignum ne rev >(-+), expects #t ==> ok
test flonum vs bignum ne rev >(--), expects #t ==> ok
test flonum vs bignum ne  <=(++), expects #f ==> ok
test flonum vs bignum ne  <=(+-), expects #f ==> ok
test flonum vs bignum ne  <=(-+), expects #t ==> ok
test flonum vs bignum ne  <=(--), expects #t ==> ok
test flonum vs bignum ne rev <=(++), expects #t ==> ok
test flonum vs bignum ne rev <=(+-), expects #t ==> ok
test flonum vs bignum ne rev <=(-+), expects #f ==> ok
test flonum vs bignum ne rev <=(--), expects #f ==> ok
test flonum vs bignum ne  <(++), expects #f ==> ok
test flonum vs bignum ne  <(+-), expects #f ==> ok
test flonum vs bignum ne  <(-+), expects #t ==> ok
test flonum vs bignum ne  <(--), expects #t ==> ok
test flonum vs bignum ne rev <(++), expects #t ==> ok
test flonum vs bignum ne rev <(+-), expects #t ==> ok
test flonum vs bignum ne rev <(-+), expects #f ==> ok
test flonum vs bignum ne rev <(--), expects #f ==> ok
test ratnum vs fixnum ne  =(++), expects #f ==> ok
test ratnum vs fixnum ne  =(+-), expects #f ==> ok
test ratnum vs fixnum ne  =(-+), expects #f ==> ok
test ratnum vs fixnum ne  =(--), expects #f ==> ok
test ratnum vs fixnum ne rev =(++), expects #f ==> ok
test ratnum vs fixnum ne rev =(+-), expects #f ==> ok
test ratnum vs fixnum ne rev =(-+), expects #f ==> ok
test ratnum vs fixnum ne rev =(--), expects #f ==> ok
test ratnum vs fixnum ne  >=(++), expects #t ==> ok
test ratnum vs fixnum ne  >=(+-), expects #t ==> ok
test ratnum vs fixnum ne  >=(-+), expects #f ==> ok
test ratnum vs fixnum ne  >=(--), expects #f ==> ok
test ratnum vs fixnum ne rev >=(++), expects #f ==> ok
test ratnum vs fixnum ne rev >=(+-), expects #f ==> ok
test ratnum vs fixnum ne rev >=(-+), expects #t ==> ok
test ratnum vs fixnum ne rev >=(--), expects #t ==> ok
test ratnum vs fixnum ne  >(++), expects #t ==> ok
test ratnum vs fixnum ne  >(+-), expects #t ==> ok
test ratnum vs fixnum ne  >(-+), expects #f ==> ok
test ratnum vs fixnum ne  >(--), expects #f ==> ok
test ratnum vs fixnum ne rev >(++), expects #f ==> ok
test ratnum vs fixnum ne rev >(+-), expects #f ==> ok
test ratnum vs fixnum ne rev >(-+), expects #t ==> ok
test ratnum vs fixnum ne rev >(--), expects #t ==> ok
test ratnum vs fixnum ne  <=(++), expects #f ==> ok
test ratnum vs fixnum ne  <=(+-), expects #f ==> ok
test ratnum vs fixnum ne  <=(-+), expects #t ==> ok
test ratnum vs fixnum ne  <=(--), expects #t ==> ok
test ratnum vs fixnum ne rev <=(++), expects #t ==> ok
test ratnum vs fixnum ne rev <=(+-), expects #t ==> ok
test ratnum vs fixnum ne rev <=(-+), expects #f ==> ok
test ratnum vs fixnum ne rev <=(--), expects #f ==> ok
test ratnum vs fixnum ne  <(++), expects #f ==> ok
test ratnum vs fixnum ne  <(+-), expects #f ==> ok
test ratnum vs fixnum ne  <(-+), expects #t ==> ok
test ratnum vs fixnum ne  <(--), expects #t ==> ok
test ratnum vs fixnum ne rev <(++), expects #t ==> ok
test ratnum vs fixnum ne rev <(+-), expects #t ==> ok
test ratnum vs fixnum ne rev <(-+), expects #f ==> ok
test ratnum vs fixnum ne rev <(--), expects #f ==> ok
test ratnum vs ratnum eq  =(++), expects #t ==> ok
test ratnum vs ratnum eq  =(+-), expects #f ==> ok
test ratnum vs ratnum eq  =(-+), expects #f ==> ok
test ratnum vs ratnum eq  =(--), expects #t ==> ok
test ratnum vs ratnum eq rev =(++), expects #t ==> ok
test ratnum vs ratnum eq rev =(+-), expects #f ==> ok
test ratnum vs ratnum eq rev =(-+), expects #f ==> ok
test ratnum vs ratnum eq rev =(--), expects #t ==> ok
test ratnum vs ratnum eq  >=(++), expects #t ==> ok
test ratnum vs ratnum eq  >=(+-), expects #t ==> ok
test ratnum vs ratnum eq  >=(-+), expects #f ==> ok
test ratnum vs ratnum eq  >=(--), expects #t ==> ok
test ratnum vs ratnum eq rev >=(++), expects #t ==> ok
test ratnum vs ratnum eq rev >=(+-), expects #f ==> ok
test ratnum vs ratnum eq rev >=(-+), expects #t ==> ok
test ratnum vs ratnum eq rev >=(--), expects #t ==> ok
test ratnum vs ratnum eq  >(++), expects #f ==> ok
test ratnum vs ratnum eq  >(+-), expects #t ==> ok
test ratnum vs ratnum eq  >(-+), expects #f ==> ok
test ratnum vs ratnum eq  >(--), expects #f ==> ok
test ratnum vs ratnum eq rev >(++), expects #f ==> ok
test ratnum vs ratnum eq rev >(+-), expects #f ==> ok
test ratnum vs ratnum eq rev >(-+), expects #t ==> ok
test ratnum vs ratnum eq rev >(--), expects #f ==> ok
test ratnum vs ratnum eq  <=(++), expects #t ==> ok
test ratnum vs ratnum eq  <=(+-), expects #f ==> ok
test ratnum vs ratnum eq  <=(-+), expects #t ==> ok
test ratnum vs ratnum eq  <=(--), expects #t ==> ok
test ratnum vs ratnum eq rev <=(++), expects #t ==> ok
test ratnum vs ratnum eq rev <=(+-), expects #t ==> ok
test ratnum vs ratnum eq rev <=(-+), expects #f ==> ok
test ratnum vs ratnum eq rev <=(--), expects #t ==> ok
test ratnum vs ratnum eq  <(++), expects #f ==> ok
test ratnum vs ratnum eq  <(+-), expects #f ==> ok
test ratnum vs ratnum eq  <(-+), expects #t ==> ok
test ratnum vs ratnum eq  <(--), expects #f ==> ok
test ratnum vs ratnum eq rev <(++), expects #f ==> ok
test ratnum vs ratnum eq rev <(+-), expects #t ==> ok
test ratnum vs ratnum eq rev <(-+), expects #f ==> ok
test ratnum vs ratnum eq rev <(--), expects #f ==> ok
test ratnum vs ratnum 1 ne  =(++), expects #f ==> ok
test ratnum vs ratnum 1 ne  =(+-), expects #f ==> ok
test ratnum vs ratnum 1 ne  =(-+), expects #f ==> ok
test ratnum vs ratnum 1 ne  =(--), expects #f ==> ok
test ratnum vs ratnum 1 ne rev =(++), expects #f ==> ok
test ratnum vs ratnum 1 ne rev =(+-), expects #f ==> ok
test ratnum vs ratnum 1 ne rev =(-+), expects #f ==> ok
test ratnum vs ratnum 1 ne rev =(--), expects #f ==> ok
test ratnum vs ratnum 1 ne  >=(++), expects #t ==> ok
test ratnum vs ratnum 1 ne  >=(+-), expects #t ==> ok
test ratnum vs ratnum 1 ne  >=(-+), expects #f ==> ok
test ratnum vs ratnum 1 ne  >=(--), expects #f ==> ok
test ratnum vs ratnum 1 ne rev >=(++), expects #f ==> ok
test ratnum vs ratnum 1 ne rev >=(+-), expects #f ==> ok
test ratnum vs ratnum 1 ne rev >=(-+), expects #t ==> ok
test ratnum vs ratnum 1 ne rev >=(--), expects #t ==> ok
test ratnum vs ratnum 1 ne  >(++), expects #t ==> ok
test ratnum vs ratnum 1 ne  >(+-), expects #t ==> ok
test ratnum vs ratnum 1 ne  >(-+), expects #f ==> ok
test ratnum vs ratnum 1 ne  >(--), expects #f ==> ok
test ratnum vs ratnum 1 ne rev >(++), expects #f ==> ok
test ratnum vs ratnum 1 ne rev >(+-), expects #f ==> ok
test ratnum vs ratnum 1 ne rev >(-+), expects #t ==> ok
test ratnum vs ratnum 1 ne rev >(--), expects #t ==> ok
test ratnum vs ratnum 1 ne  <=(++), expects #f ==> ok
test ratnum vs ratnum 1 ne  <=(+-), expects #f ==> ok
test ratnum vs ratnum 1 ne  <=(-+), expects #t ==> ok
test ratnum vs ratnum 1 ne  <=(--), expects #t ==> ok
test ratnum vs ratnum 1 ne rev <=(++), expects #t ==> ok
test ratnum vs ratnum 1 ne rev <=(+-), expects #t ==> ok
test ratnum vs ratnum 1 ne rev <=(-+), expects #f ==> ok
test ratnum vs ratnum 1 ne rev <=(--), expects #f ==> ok
test ratnum vs ratnum 1 ne  <(++), expects #f ==> ok
test ratnum vs ratnum 1 ne  <(+-), expects #f ==> ok
test ratnum vs ratnum 1 ne  <(-+), expects #t ==> ok
test ratnum vs ratnum 1 ne  <(--), expects #t ==> ok
test ratnum vs ratnum 1 ne rev <(++), expects #t ==> ok
test ratnum vs ratnum 1 ne rev <(+-), expects #t ==> ok
test ratnum vs ratnum 1 ne rev <(-+), expects #f ==> ok
test ratnum vs ratnum 1 ne rev <(--), expects #f ==> ok
test ratnum vs ratnum 2 ne  =(++), expects #f ==> ok
test ratnum vs ratnum 2 ne  =(+-), expects #f ==> ok
test ratnum vs ratnum 2 ne  =(-+), expects #f ==> ok
test ratnum vs ratnum 2 ne  =(--), expects #f ==> ok
test ratnum vs ratnum 2 ne rev =(++), expects #f ==> ok
test ratnum vs ratnum 2 ne rev =(+-), expects #f ==> ok
test ratnum vs ratnum 2 ne rev =(-+), expects #f ==> ok
test ratnum vs ratnum 2 ne rev =(--), expects #f ==> ok
test ratnum vs ratnum 2 ne  >=(++), expects #t ==> ok
test ratnum vs ratnum 2 ne  >=(+-), expects #t ==> ok
test ratnum vs ratnum 2 ne  >=(-+), expects #f ==> ok
test ratnum vs ratnum 2 ne  >=(--), expects #f ==> ok
test ratnum vs ratnum 2 ne rev >=(++), expects #f ==> ok
test ratnum vs ratnum 2 ne rev >=(+-), expects #f ==> ok
test ratnum vs ratnum 2 ne rev >=(-+), expects #t ==> ok
test ratnum vs ratnum 2 ne rev >=(--), expects #t ==> ok
test ratnum vs ratnum 2 ne  >(++), expects #t ==> ok
test ratnum vs ratnum 2 ne  >(+-), expects #t ==> ok
test ratnum vs ratnum 2 ne  >(-+), expects #f ==> ok
test ratnum vs ratnum 2 ne  >(--), expects #f ==> ok
test ratnum vs ratnum 2 ne rev >(++), expects #f ==> ok
test ratnum vs ratnum 2 ne rev >(+-), expects #f ==> ok
test ratnum vs ratnum 2 ne rev >(-+), expects #t ==> ok
test ratnum vs ratnum 2 ne rev >(--), expects #t ==> ok
test ratnum vs ratnum 2 ne  <=(++), expects #f ==> ok
test ratnum vs ratnum 2 ne  <=(+-), expects #f ==> ok
test ratnum vs ratnum 2 ne  <=(-+), expects #t ==> ok
test ratnum vs ratnum 2 ne  <=(--), expects #t ==> ok
test ratnum vs ratnum 2 ne rev <=(++), expects #t ==> ok
test ratnum vs ratnum 2 ne rev <=(+-), expects #t ==> ok
test ratnum vs ratnum 2 ne rev <=(-+), expects #f ==> ok
test ratnum vs ratnum 2 ne rev <=(--), expects #f ==> ok
test ratnum vs ratnum 2 ne  <(++), expects #f ==> ok
test ratnum vs ratnum 2 ne  <(+-), expects #f ==> ok
test ratnum vs ratnum 2 ne  <(-+), expects #t ==> ok
test ratnum vs ratnum 2 ne  <(--), expects #t ==> ok
test ratnum vs ratnum 2 ne rev <(++), expects #t ==> ok
test ratnum vs ratnum 2 ne rev <(+-), expects #t ==> ok
test ratnum vs ratnum 2 ne rev <(-+), expects #f ==> ok
test ratnum vs ratnum 2 ne rev <(--), expects #f ==> ok
test ratnum vs ratnum 3 ne  =(++), expects #f ==> ok
test ratnum vs ratnum 3 ne  =(+-), expects #f ==> ok
test ratnum vs ratnum 3 ne  =(-+), expects #f ==> ok
test ratnum vs ratnum 3 ne  =(--), expects #f ==> ok
test ratnum vs ratnum 3 ne rev =(++), expects #f ==> ok
test ratnum vs ratnum 3 ne rev =(+-), expects #f ==> ok
test ratnum vs ratnum 3 ne rev =(-+), expects #f ==> ok
test ratnum vs ratnum 3 ne rev =(--), expects #f ==> ok
test ratnum vs ratnum 3 ne  >=(++), expects #t ==> ok
test ratnum vs ratnum 3 ne  >=(+-), expects #t ==> ok
test ratnum vs ratnum 3 ne  >=(-+), expects #f ==> ok
test ratnum vs ratnum 3 ne  >=(--), expects #f ==> ok
test ratnum vs ratnum 3 ne rev >=(++), expects #f ==> ok
test ratnum vs ratnum 3 ne rev >=(+-), expects #f ==> ok
test ratnum vs ratnum 3 ne rev >=(-+), expects #t ==> ok
test ratnum vs ratnum 3 ne rev >=(--), expects #t ==> ok
test ratnum vs ratnum 3 ne  >(++), expects #t ==> ok
test ratnum vs ratnum 3 ne  >(+-), expects #t ==> ok
test ratnum vs ratnum 3 ne  >(-+), expects #f ==> ok
test ratnum vs ratnum 3 ne  >(--), expects #f ==> ok
test ratnum vs ratnum 3 ne rev >(++), expects #f ==> ok
test ratnum vs ratnum 3 ne rev >(+-), expects #f ==> ok
test ratnum vs ratnum 3 ne rev >(-+), expects #t ==> ok
test ratnum vs ratnum 3 ne rev >(--), expects #t ==> ok
test ratnum vs ratnum 3 ne  <=(++), expects #f ==> ok
test ratnum vs ratnum 3 ne  <=(+-), expects #f ==> ok
test ratnum vs ratnum 3 ne  <=(-+), expects #t ==> ok
test ratnum vs ratnum 3 ne  <=(--), expects #t ==> ok
test ratnum vs ratnum 3 ne rev <=(++), expects #t ==> ok
test ratnum vs ratnum 3 ne rev <=(+-), expects #t ==> ok
test ratnum vs ratnum 3 ne rev <=(-+), expects #f ==> ok
test ratnum vs ratnum 3 ne rev <=(--), expects #f ==> ok
test ratnum vs ratnum 3 ne  <(++), expects #f ==> ok
test ratnum vs ratnum 3 ne  <(+-), expects #f ==> ok
test ratnum vs ratnum 3 ne  <(-+), expects #t ==> ok
test ratnum vs ratnum 3 ne  <(--), expects #t ==> ok
test ratnum vs ratnum 3 ne rev <(++), expects #t ==> ok
test ratnum vs ratnum 3 ne rev <(+-), expects #t ==> ok
test ratnum vs ratnum 3 ne rev <(-+), expects #f ==> ok
test ratnum vs ratnum 3 ne rev <(--), expects #f ==> ok
test ratnum vs ratnum 4 ne  =(++), expects #f ==> ok
test ratnum vs ratnum 4 ne  =(+-), expects #f ==> ok
test ratnum vs ratnum 4 ne  =(-+), expects #f ==> ok
test ratnum vs ratnum 4 ne  =(--), expects #f ==> ok
test ratnum vs ratnum 4 ne rev =(++), expects #f ==> ok
test ratnum vs ratnum 4 ne rev =(+-), expects #f ==> ok
test ratnum vs ratnum 4 ne rev =(-+), expects #f ==> ok
test ratnum vs ratnum 4 ne rev =(--), expects #f ==> ok
test ratnum vs ratnum 4 ne  >=(++), expects #t ==> ok
test ratnum vs ratnum 4 ne  >=(+-), expects #t ==> ok
test ratnum vs ratnum 4 ne  >=(-+), expects #f ==> ok
test ratnum vs ratnum 4 ne  >=(--), expects #f ==> ok
test ratnum vs ratnum 4 ne rev >=(++), expects #f ==> ok
test ratnum vs ratnum 4 ne rev >=(+-), expects #f ==> ok
test ratnum vs ratnum 4 ne rev >=(-+), expects #t ==> ok
test ratnum vs ratnum 4 ne rev >=(--), expects #t ==> ok
test ratnum vs ratnum 4 ne  >(++), expects #t ==> ok
test ratnum vs ratnum 4 ne  >(+-), expects #t ==> ok
test ratnum vs ratnum 4 ne  >(-+), expects #f ==> ok
test ratnum vs ratnum 4 ne  >(--), expects #f ==> ok
test ratnum vs ratnum 4 ne rev >(++), expects #f ==> ok
test ratnum vs ratnum 4 ne rev >(+-), expects #f ==> ok
test ratnum vs ratnum 4 ne rev >(-+), expects #t ==> ok
test ratnum vs ratnum 4 ne rev >(--), expects #t ==> ok
test ratnum vs ratnum 4 ne  <=(++), expects #f ==> ok
test ratnum vs ratnum 4 ne  <=(+-), expects #f ==> ok
test ratnum vs ratnum 4 ne  <=(-+), expects #t ==> ok
test ratnum vs ratnum 4 ne  <=(--), expects #t ==> ok
test ratnum vs ratnum 4 ne rev <=(++), expects #t ==> ok
test ratnum vs ratnum 4 ne rev <=(+-), expects #t ==> ok
test ratnum vs ratnum 4 ne rev <=(-+), expects #f ==> ok
test ratnum vs ratnum 4 ne rev <=(--), expects #f ==> ok
test ratnum vs ratnum 4 ne  <(++), expects #f ==> ok
test ratnum vs ratnum 4 ne  <(+-), expects #f ==> ok
test ratnum vs ratnum 4 ne  <(-+), expects #t ==> ok
test ratnum vs ratnum 4 ne  <(--), expects #t ==> ok
test ratnum vs ratnum 4 ne rev <(++), expects #t ==> ok
test ratnum vs ratnum 4 ne rev <(+-), expects #t ==> ok
test ratnum vs ratnum 4 ne rev <(-+), expects #f ==> ok
test ratnum vs ratnum 4 ne rev <(--), expects #f ==> ok
test ratnum vs flonum eq  =(++), expects #t ==> ok
test ratnum vs flonum eq  =(+-), expects #f ==> ok
test ratnum vs flonum eq  =(-+), expects #f ==> ok
test ratnum vs flonum eq  =(--), expects #t ==> ok
test ratnum vs flonum eq rev =(++), expects #t ==> ok
test ratnum vs flonum eq rev =(+-), expects #f ==> ok
test ratnum vs flonum eq rev =(-+), expects #f ==> ok
test ratnum vs flonum eq rev =(--), expects #t ==> ok
test ratnum vs flonum eq  >=(++), expects #t ==> ok
test ratnum vs flonum eq  >=(+-), expects #t ==> ok
test ratnum vs flonum eq  >=(-+), expects #f ==> ok
test ratnum vs flonum eq  >=(--), expects #t ==> ok
test ratnum vs flonum eq rev >=(++), expects #t ==> ok
test ratnum vs flonum eq rev >=(+-), expects #f ==> ok
test ratnum vs flonum eq rev >=(-+), expects #t ==> ok
test ratnum vs flonum eq rev >=(--), expects #t ==> ok
test ratnum vs flonum eq  >(++), expects #f ==> ok
test ratnum vs flonum eq  >(+-), expects #t ==> ok
test ratnum vs flonum eq  >(-+), expects #f ==> ok
test ratnum vs flonum eq  >(--), expects #f ==> ok
test ratnum vs flonum eq rev >(++), expects #f ==> ok
test ratnum vs flonum eq rev >(+-), expects #f ==> ok
test ratnum vs flonum eq rev >(-+), expects #t ==> ok
test ratnum vs flonum eq rev >(--), expects #f ==> ok
test ratnum vs flonum eq  <=(++), expects #t ==> ok
test ratnum vs flonum eq  <=(+-), expects #f ==> ok
test ratnum vs flonum eq  <=(-+), expects #t ==> ok
test ratnum vs flonum eq  <=(--), expects #t ==> ok
test ratnum vs flonum eq rev <=(++), expects #t ==> ok
test ratnum vs flonum eq rev <=(+-), expects #t ==> ok
test ratnum vs flonum eq rev <=(-+), expects #f ==> ok
test ratnum vs flonum eq rev <=(--), expects #t ==> ok
test ratnum vs flonum eq  <(++), expects #f ==> ok
test ratnum vs flonum eq  <(+-), expects #f ==> ok
test ratnum vs flonum eq  <(-+), expects #t ==> ok
test ratnum vs flonum eq  <(--), expects #f ==> ok
test ratnum vs flonum eq rev <(++), expects #f ==> ok
test ratnum vs flonum eq rev <(+-), expects #t ==> ok
test ratnum vs flonum eq rev <(-+), expects #f ==> ok
test ratnum vs flonum eq rev <(--), expects #f ==> ok
test ratnum vs flonum ne  =(++), expects #f ==> ok
test ratnum vs flonum ne  =(+-), expects #f ==> ok
test ratnum vs flonum ne  =(-+), expects #f ==> ok
test ratnum vs flonum ne  =(--), expects #f ==> ok
test ratnum vs flonum ne rev =(++), expects #f ==> ok
test ratnum vs flonum ne rev =(+-), expects #f ==> ok
test ratnum vs flonum ne rev =(-+), expects #f ==> ok
test ratnum vs flonum ne rev =(--), expects #f ==> ok
test ratnum vs flonum ne  >=(++), expects #t ==> ok
test ratnum vs flonum ne  >=(+-), expects #t ==> ok
test ratnum vs flonum ne  >=(-+), expects #f ==> ok
test ratnum vs flonum ne  >=(--), expects #f ==> ok
test ratnum vs flonum ne rev >=(++), expects #f ==> ok
test ratnum vs flonum ne rev >=(+-), expects #f ==> ok
test ratnum vs flonum ne rev >=(-+), expects #t ==> ok
test ratnum vs flonum ne rev >=(--), expects #t ==> ok
test ratnum vs flonum ne  >(++), expects #t ==> ok
test ratnum vs flonum ne  >(+-), expects #t ==> ok
test ratnum vs flonum ne  >(-+), expects #f ==> ok
test ratnum vs flonum ne  >(--), expects #f ==> ok
test ratnum vs flonum ne rev >(++), expects #f ==> ok
test ratnum vs flonum ne rev >(+-), expects #f ==> ok
test ratnum vs flonum ne rev >(-+), expects #t ==> ok
test ratnum vs flonum ne rev >(--), expects #t ==> ok
test ratnum vs flonum ne  <=(++), expects #f ==> ok
test ratnum vs flonum ne  <=(+-), expects #f ==> ok
test ratnum vs flonum ne  <=(-+), expects #t ==> ok
test ratnum vs flonum ne  <=(--), expects #t ==> ok
test ratnum vs flonum ne rev <=(++), expects #t ==> ok
test ratnum vs flonum ne rev <=(+-), expects #t ==> ok
test ratnum vs flonum ne rev <=(-+), expects #f ==> ok
test ratnum vs flonum ne rev <=(--), expects #f ==> ok
test ratnum vs flonum ne  <(++), expects #f ==> ok
test ratnum vs flonum ne  <(+-), expects #f ==> ok
test ratnum vs flonum ne  <(-+), expects #t ==> ok
test ratnum vs flonum ne  <(--), expects #t ==> ok
test ratnum vs flonum ne rev <(++), expects #t ==> ok
test ratnum vs flonum ne rev <(+-), expects #t ==> ok
test ratnum vs flonum ne rev <(-+), expects #f ==> ok
test ratnum vs flonum ne rev <(--), expects #f ==> ok
test ratnum vs bignum ne  =(++), expects #f ==> ok
test ratnum vs bignum ne  =(+-), expects #f ==> ok
test ratnum vs bignum ne  =(-+), expects #f ==> ok
test ratnum vs bignum ne  =(--), expects #f ==> ok
test ratnum vs bignum ne rev =(++), expects #f ==> ok
test ratnum vs bignum ne rev =(+-), expects #f ==> ok
test ratnum vs bignum ne rev =(-+), expects #f ==> ok
test ratnum vs bignum ne rev =(--), expects #f ==> ok
test ratnum vs bignum ne  >=(++), expects #t ==> ok
test ratnum vs bignum ne  >=(+-), expects #t ==> ok
test ratnum vs bignum ne  >=(-+), expects #f ==> ok
test ratnum vs bignum ne  >=(--), expects #f ==> ok
test ratnum vs bignum ne rev >=(++), expects #f ==> ok
test ratnum vs bignum ne rev >=(+-), expects #f ==> ok
test ratnum vs bignum ne rev >=(-+), expects #t ==> ok
test ratnum vs bignum ne rev >=(--), expects #t ==> ok
test ratnum vs bignum ne  >(++), expects #t ==> ok
test ratnum vs bignum ne  >(+-), expects #t ==> ok
test ratnum vs bignum ne  >(-+), expects #f ==> ok
test ratnum vs bignum ne  >(--), expects #f ==> ok
test ratnum vs bignum ne rev >(++), expects #f ==> ok
test ratnum vs bignum ne rev >(+-), expects #f ==> ok
test ratnum vs bignum ne rev >(-+), expects #t ==> ok
test ratnum vs bignum ne rev >(--), expects #t ==> ok
test ratnum vs bignum ne  <=(++), expects #f ==> ok
test ratnum vs bignum ne  <=(+-), expects #f ==> ok
test ratnum vs bignum ne  <=(-+), expects #t ==> ok
test ratnum vs bignum ne  <=(--), expects #t ==> ok
test ratnum vs bignum ne rev <=(++), expects #t ==> ok
test ratnum vs bignum ne rev <=(+-), expects #t ==> ok
test ratnum vs bignum ne rev <=(-+), expects #f ==> ok
test ratnum vs bignum ne rev <=(--), expects #f ==> ok
test ratnum vs bignum ne  <(++), expects #f ==> ok
test ratnum vs bignum ne  <(+-), expects #f ==> ok
test ratnum vs bignum ne  <(-+), expects #t ==> ok
test ratnum vs bignum ne  <(--), expects #t ==> ok
test ratnum vs bignum ne rev <(++), expects #t ==> ok
test ratnum vs bignum ne rev <(+-), expects #t ==> ok
test ratnum vs bignum ne rev <(-+), expects #f ==> ok
test ratnum vs bignum ne rev <(--), expects #f ==> ok
test =(1 2 3 4), expects #f ==> ok
test <(1 2 3 4), expects #t ==> ok
test <=(1 2 3 4), expects #t ==> ok
test >(1 2 3 4), expects #f ==> ok
test >=(1 2 3 4), expects #f ==> ok
test =(1 2 3 3), expects #f ==> ok
test <(1 2 3 3), expects #f ==> ok
test <=(1 2 3 3), expects #t ==> ok
test >(1 2 3 3), expects #f ==> ok
test >=(1 2 3 3), expects #f ==> ok
test =(1 2 3 2), expects #f ==> ok
test <(1 2 3 2), expects #f ==> ok
test <=(1 2 3 2), expects #f ==> ok
test >(1 2 3 2), expects #f ==> ok
test >=(1 2 3 2), expects #f ==> ok
test =(1 2 3 4 5), expects #f ==> ok
test <(1 2 3 4 5), expects #t ==> ok
test <=(1 2 3 4 5), expects #t ==> ok
test >(1 2 3 4 5), expects #f ==> ok
test >=(1 2 3 4 5), expects #f ==> ok
test =(1 2 3 4 4), expects #f ==> ok
test <(1 2 3 4 4), expects #f ==> ok
test <=(1 2 3 4 4), expects #t ==> ok
test >(1 2 3 4 4), expects #f ==> ok
test >=(1 2 3 4 4), expects #f ==> ok
test =(1 2 3 4 3), expects #f ==> ok
test <(1 2 3 4 3), expects #f ==> ok
test <=(1 2 3 4 3), expects #f ==> ok
test >(1 2 3 4 3), expects #f ==> ok
test >=(1 2 3 4 3), expects #f ==> ok
test =(1 2 3 4 5 6), expects #f ==> ok
test <(1 2 3 4 5 6), expects #t ==> ok
test <=(1 2 3 4 5 6), expects #t ==> ok
test >(1 2 3 4 5 6), expects #f ==> ok
test >=(1 2 3 4 5 6), expects #f ==> ok
test =(1 2 3 4 5 5), expects #f ==> ok
test <(1 2 3 4 5 5), expects #f ==> ok
test <=(1 2 3 4 5 5), expects #t ==> ok
test >(1 2 3 4 5 5), expects #f ==> ok
test >=(1 2 3 4 5 5), expects #f ==> ok
test =(1 2 3 4 5 4), expects #f ==> ok
test <(1 2 3 4 5 4), expects #f ==> ok
test <=(1 2 3 4 5 4), expects #f ==> ok
test >(1 2 3 4 5 4), expects #f ==> ok
test >=(1 2 3 4 5 4), expects #f ==> ok
test =(4 3 2 1), expects #f ==> ok
test <(4 3 2 1), expects #f ==> ok
test <=(4 3 2 1), expects #f ==> ok
test >(4 3 2 1), expects #t ==> ok
test >=(4 3 2 1), expects #t ==> ok
test =(4 3 2 2), expects #f ==> ok
test <(4 3 2 2), expects #f ==> ok
test <=(4 3 2 2), expects #f ==> ok
test >(4 3 2 2), expects #f ==> ok
test >=(4 3 2 2), expects #t ==> ok
test =(4 3 2 3), expects #f ==> ok
test <(4 3 2 3), expects #f ==> ok
test <=(4 3 2 3), expects #f ==> ok
test >(4 3 2 3), expects #f ==> ok
test >=(4 3 2 3), expects #f ==> ok
test =(5 4 3 2 1), expects #f ==> ok
test <(5 4 3 2 1), expects #f ==> ok
test <=(5 4 3 2 1), expects #f ==> ok
test >(5 4 3 2 1), expects #t ==> ok
test >=(5 4 3 2 1), expects #t ==> ok
test =(5 4 3 2 2), expects #f ==> ok
test <(5 4 3 2 2), expects #f ==> ok
test <=(5 4 3 2 2), expects #f ==> ok
test >(5 4 3 2 2), expects #f ==> ok
test >=(5 4 3 2 2), expects #t ==> ok
test =(5 4 3 2 3), expects #f ==> ok
test <(5 4 3 2 3), expects #f ==> ok
test <=(5 4 3 2 3), expects #f ==> ok
test >(5 4 3 2 3), expects #f ==> ok
test >=(5 4 3 2 3), expects #f ==> ok
test =(6 5 4 3 2 1), expects #f ==> ok
test <(6 5 4 3 2 1), expects #f ==> ok
test <=(6 5 4 3 2 1), expects #f ==> ok
test >(6 5 4 3 2 1), expects #t ==> ok
test >=(6 5 4 3 2 1), expects #t ==> ok
test =(6 5 4 3 2 2), expects #f ==> ok
test <(6 5 4 3 2 2), expects #f ==> ok
test <=(6 5 4 3 2 2), expects #f ==> ok
test >(6 5 4 3 2 2), expects #f ==> ok
test >=(6 5 4 3 2 2), expects #t ==> ok
test =(6 5 4 3 2 3), expects #f ==> ok
test <(6 5 4 3 2 3), expects #f ==> ok
test <=(6 5 4 3 2 3), expects #f ==> ok
test >(6 5 4 3 2 3), expects #f ==> ok
test >=(6 5 4 3 2 3), expects #f ==> ok
test =(1 1 1 1 1), expects #t ==> ok
test <(1 1 1 1 1), expects #f ==> ok
test <=(1 1 1 1 1), expects #t ==> ok
test >(1 1 1 1 1), expects #f ==> ok
test >=(1 1 1 1 1), expects #t ==> ok
test =(1 1 1 1 2), expects #f ==> ok
test <(1 1 1 1 2), expects #f ==> ok
test <=(1 1 1 1 2), expects #t ==> ok
test >(1 1 1 1 2), expects #f ==> ok
test >=(1 1 1 1 2), expects #f ==> ok
test =(1 1 1 1 0), expects #f ==> ok
test <(1 1 1 1 0), expects #f ==> ok
test <=(1 1 1 1 0), expects #f ==> ok
test >(1 1 1 1 0), expects #f ==> ok
test >=(1 1 1 1 0), expects #t ==> ok
test =(1 1 1 1 1 1), expects #t ==> ok
test <(1 1 1 1 1 1), expects #f ==> ok
test <=(1 1 1 1 1 1), expects #t ==> ok
test >(1 1 1 1 1 1), expects #f ==> ok
test >=(1 1 1 1 1 1), expects #t ==> ok
test =(1 1 1 1 1 2), expects #f ==> ok
test <(1 1 1 1 1 2), expects #f ==> ok
test <=(1 1 1 1 1 2), expects #t ==> ok
test >(1 1 1 1 1 2), expects #f ==> ok
test >=(1 1 1 1 1 2), expects #f ==> ok
test =(1 1 1 1 1 0), expects #f ==> ok
test <(1 1 1 1 1 0), expects #f ==> ok
test <=(1 1 1 1 1 0), expects #f ==> ok
test >(1 1 1 1 1 0), expects #f ==> ok
test >=(1 1 1 1 1 0), expects #t ==> ok
test fixnum/ratnum comparison, expects #f ==> ok
test fixnum? fixnum, expects #t ==> ok
test fixnum? ratnum, expects #f ==> ok
test fixnum? bignum, expects #f ==> ok
test fixnum? flonum, expects #f ==> ok
test fixnum? compnum, expects #f ==> ok
test fixnum? greatest, expects #t ==> ok
test fixnum? greatest+1, expects #f ==> ok
test fixnum? least, expects #t ==> ok
test fixnum? least-1, expects #f ==> ok
test greatest fixnum & width, expects 536870911 ==> ok
test least fixnum & width, expects -536870912 ==> ok
<integer addition>-------------------------------------------------------------
test bignum + bignum, expects 340282367000166625996085689103316680704 ==> ok
test bignum + -bignum, expects 340282366683253975939028338711961010176 ==> ok
test bignum - bignum, expects 340282366841710300949110269833929293823 ==> ok
test bignum - bignum, expects 340282366841710300967557013907638845440 ==> ok
test -bignum + bignum, expects -340282366683253975939028338711961010176 ==> ok
test -bignum + -bignum, expects -340282367000166625996085689103316680704 ==> ok
test -bignum - bignum, expects -340282367000166625996085689103316680704 ==> ok
test -bignum - -bignum, expects -340282366683253975939028338711961010176 ==> ok
test 0 + bignum, expects (340282366841710300967557013907638845440 340282366841710300967557013907638845440) ==> ok
test 0 - bignum, expects (-340282366841710300967557013907638845440 340282366841710300967557013907638845440) ==> ok
test 0 * bignum, expects (0 0) ==> ok
test 1 * bignum, expects (340282366841710300967557013907638845440 340282366841710300967557013907638845440) ==> ok
test bignum / 1, expects 340282366841710300967557013907638845440 ==> ok
<small immediate integer constants>--------------------------------------------
test PUSHI, expects (0 524287 524288 -524287 -524288) ==> ok
test PUSHI, expects (0 2251799813685247 2251799813685248 -2251799813685247 -2251799813685248) ==> ok
<small immediate integer additions>--------------------------------------------
test NUMADDI, expects 5 ==> ok
test NUMADDI, expects 5 ==> ok
test NUMADDI, expects 1 ==> ok
test NUMADDI, expects 1 ==> ok
test NUMSUBI, expects 1 ==> ok
test NUMSUBI, expects -1 ==> ok
test NUMSUBI, expects -5 ==> ok
test NUMSUBI, expects 5 ==> ok
test NUMADDI, expects 5.0 ==> ok
test NUMADDI, expects 5.0 ==> ok
test NUMADDI, expects 1.0 ==> ok
test NUMADDI, expects 1.0 ==> ok
test NUMSUBI, expects 1.0 ==> ok
test NUMSUBI, expects -1.0 ==> ok
test NUMSUBI, expects -5.0 ==> ok
test NUMSUBI, expects 5.0 ==> ok
test NUMADDI, expects 4294967299 ==> ok
test NUMADDI, expects 4294967299 ==> ok
test NUMADDI, expects 4294967295 ==> ok
test NUMADDI, expects 4294967295 ==> ok
test NUMSUBI, expects -4294967293 ==> ok
test NUMSUBI, expects 4294967293 ==> ok
test NUMSUBI, expects -4294967299 ==> ok
test NUMSUBI, expects 4294967299 ==> ok
test NUMADDI, expects 54/7 ==> ok
test NUMADDI, expects 54/7 ==> ok
test NUMADDI, expects 26/7 ==> ok
test NUMADDI, expects 26/7 ==> ok
test NUMADDI, expects -12/7 ==> ok
test NUMADDI, expects 12/7 ==> ok
test NUMADDI, expects -54/7 ==> ok
test NUMADDI, expects 54/7 ==> ok
test NUMADDI, expects 30 ==> ok
test NUMADDI, expects 30 ==> ok
test NUMADDI, expects 35 ==> ok
test NUMADDI, expects 35 ==> ok
test NUMADDI, expects 30 ==> ok
test NUMADDI, expects 30 ==> ok
test NUMADDI, expects 35 ==> ok
test NUMADDI, expects 35 ==> ok
test NUMADDI, expects 21 ==> ok
test NUMADDI, expects 21 ==> ok
test NUMSUBI, expects -10 ==> ok
test NUMSUBI, expects 10 ==> ok
test NUMSUBI, expects -15 ==> ok
test NUMSUBI, expects 15 ==> ok
test NUMSUBI, expects -10 ==> ok
test NUMSUBI, expects 10 ==> ok
test NUMSUBI, expects -15 ==> ok
test NUMSUBI, expects 15 ==> ok
test NUMSUBI, expects -1 ==> ok
test NUMSUBI, expects 1 ==> ok
<immediate flonum integer arith>-----------------------------------------------
test NUMADDF, expects 5.0 ==> ok
test NUMADDF, expects 5.0 ==> ok
test NUMADDF, expects 1.0 ==> ok
test NUMADDF, expects 1.0 ==> ok
test NUMADDF, expects 2.0+1.0i ==> ok
test NUMADDF, expects 2.0+1.0i ==> ok
test NUMSUBF, expects 1.0 ==> ok
test NUMSUBF, expects -1.0 ==> ok
test NUMSUBF, expects -5.0 ==> ok
test NUMSUBF, expects 5.0 ==> ok
test NUMSUBF, expects -2.0+1.0i ==> ok
test NUMSUBF, expects 2.0-1.0i ==> ok
test NUMMULF, expects 4.0 ==> ok
test NUMMULF, expects 4.0 ==> ok
test NUMMULF, expects 3.0 ==> ok
test NUMMULF, expects 3.0 ==> ok
test NUMMULF, expects 0.0+2.0i ==> ok
test NUMMULF, expects 0.0+2.0i ==> ok
test NUMDIVF, expects 0.5 ==> ok
test NUMDIVF, expects 2.0 ==> ok
test NUMDIVF, expects 0.5 ==> ok
test NUMDIVF, expects 2.0 ==> ok
test NUMDIVF, expects 0.0-0.5i ==> ok
test NUMDIVF, expects 0.0+2.0i ==> ok
<rational number addition>-----------------------------------------------------
test ratnum +, expects 482/247 ==> ok
test ratnum -, expects -64/247 ==> ok
test ratnum + 0, expects (11/13 11/13) ==> ok
test ratnum - 0, expects (-11/13 11/13) ==> ok
test ratnum * 0, expects (0 0) ==> ok
test ratnum * 1, expects (11/13 11/13) ==> ok
test ratnum / 1, expects 11/13 ==> ok
<promotions in addition>-------------------------------------------------------
test +, expects (0 #t) ==> ok
test +, expects (1 #t) ==> ok
test +, expects (3 #t) ==> ok
test +, expects (6 #t) ==> ok
test +, expects (1 #t) ==> ok
test +, expects (1.0 #f) ==> ok
test +, expects (3.0 #f) ==> ok
test +, expects (3.0 #f) ==> ok
test +, expects (6.0 #f) ==> ok
test +, expects (1.0 #f) ==> ok
test +, expects (1.0+1.0i #f) ==> ok
test +, expects (3.0+1.0i #f) ==> ok
test +, expects (3.0+1.0i #f) ==> ok
test +, expects (3.0+1.0i #f) ==> ok
test +, expects (3.0+1.0i #f) ==> ok
test +, expects (4.294967298e9 #f) ==> ok
test +, expects (4.294967299e9 #f) ==> ok
test +, expects (4.294967298e9-1.0i #f) ==> ok
test +, expects (4.294967298e9-1.0i #f) ==> ok
test +, expects (4.294967298e9-1.0i #f) ==> ok
<integer multiplication>-------------------------------------------------------
test fix*fix->big[1], expects (727836879 -727836879 -727836879 727836879 727836879 -727836879 -727836879 727836879) ==> ok
test fix*fix->big[1], expects (3663846879 -3663846879 -3663846879 3663846879 3663846879 -3663846879 -3663846879 3663846879) ==> ok
test fix*fix->big[2], expects (4294967296 -4294967296 -4294967296 4294967296 4294967296 -4294967296 -4294967296 4294967296) ==> ok
test fix*fix->big[2], expects (366384949959 -366384949959 -366384949959 366384949959 366384949959 -366384949959 -366384949959 366384949959) ==> ok
test fix*big[1]->big[1], expects (3378812463 -3378812463 -3378812463 3378812463 3378812463 -3378812463 -3378812463 3378812463) ==> ok
test fix*big[1]->big[2], expects (368276265762816 -368276265762816 -368276265762816 368276265762816 368276265762816 -368276265762816 -368276265762816 368276265762816) ==> ok
test big[1]*fix->big[1], expects (3378812463 -3378812463 -3378812463 3378812463 3378812463 -3378812463 -3378812463 3378812463) ==> ok
test big[1]*fix->big[2], expects (368276265762816 -368276265762816 -368276265762816 368276265762816 368276265762816 -368276265762816 -368276265762816 368276265762816) ==> ok
test big[2]*fix->big[2], expects (12312849128741 -12312849128741 -12312849128741 12312849128741 12312849128741 -12312849128741 -12312849128741 12312849128741) ==> ok
test big[1]*big[1]->big[2], expects (1345585795375391817 -1345585795375391817 -1345585795375391817 1345585795375391817 1345585795375391817 -1345585795375391817 -1345585795375391817 1345585795375391817) ==> ok
test fermat(7), expects 340282366920938463463374607431768211457 ==> ok
test fermat(8), expects 115792089237316195423570985008687907853269984665640564039457584007913129639937 ==> ok
test fermat(9), expects 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084097 ==> ok
test fermat(10), expects 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137217 ==> ok
test fermat(11), expects 32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230657 ==> ok
<multiplication short cuts>----------------------------------------------------
test bignum * 0, expects 0 ==> ok
test 0 * bignum, expects 0 ==> ok
test bignum * 1, expects 100000000000000000000 ==> ok
test 1 * bignum, expects 100000000000000000000 ==> ok
test bignum * 0.0, expects 0.0 ==> ok
test 0.0 * bignum, expects 0.0 ==> ok
test bignum * 1.0, expects 1.0e20 ==> ok
test 1.0 * bignum, expects 1.0e20 ==> ok
test ratnum * 0, expects 0 ==> ok
test 0 * ratnum, expects 0 ==> ok
test ratnum * 1, expects 1/2 ==> ok
test 1 * ratnum, expects 1/2 ==> ok
test ratnum * 0.0, expects 0.0 ==> ok
test 0.0 * ratnum, expects 0.0 ==> ok
test ratnum * 1.0, expects 0.5 ==> ok
test 1.0 * ratnum, expects 0.5 ==> ok
test flonum * 0, expects 0 ==> ok
test 0 * flonum, expects 0 ==> ok
test flonum * 1, expects 3.0 ==> ok
test 1 * flonum, expects 3.0 ==> ok
test flonum * 0.0, expects 0.0 ==> ok
test 0.0 * flonum, expects 0.0 ==> ok
test flonum * 1.0, expects 3.0 ==> ok
test 1.0 * flonum, expects 3.0 ==> ok
test compnum * 0, expects 0 ==> ok
test 0 * compnum, expects 0 ==> ok
test compnum * 1, expects 0.0+1.0i ==> ok
test 1 * compnum, expects 0.0+1.0i ==> ok
test compnum * 0.0, expects 0.0 ==> ok
test 0.0 * compnum, expects 0.0 ==> ok
test compnum * 1.0, expects 0.0+1.0i ==> ok
test 1.0 * compnum, expects 0.0+1.0i ==> ok
<division>---------------------------------------------------------------------
test exact division, expects 3/20 ==> ok
test exact division, expects 1/2 ==> ok
test exact division, expects 4692297364841/7 ==> ok
test exact division, expects 7/4692297364841 ==> ok
test exact division, expects -7/4692297364841 ==> ok
test exact division, expects 7/4692297364841 ==> ok
test exact reciprocal, expects 1/3 ==> ok
test exact reciprocal, expects -1/3 ==> ok
test exact reciprocal, expects 5/6 ==> ok
test exact reciprocal, expects -5/6 ==> ok
test exact reciprocal, expects 7/4692297364841 ==> ok
test exact/inexact -> inexact, expects (3.25 -3.25 -3.25 3.25 #f) ==> ok
test exact/inexact -> inexact, expects (1.625 -1.625 -1.625 1.625 #f) ==> ok
test inexact/exact -> inexact, expects (3.25 -3.25 -3.25 3.25 #f) ==> ok
test inexact/exact -> inexact, expects (9.75 -9.75 -9.75 9.75 #f) ==> ok
test inexact/inexact -> inexact, expects (3.25 -3.25 -3.25 3.25 #f) ==> ok
test complex division, expects 0.0 ==> ok
<quotient>---------------------------------------------------------------------
test big[1]/fix->fix, expects (17353 -17353 -17353 17353 #t) ==> ok
test big[1]/fix->fix, expects (136582 -136582 -136582 136582 #t) ==> ok
test big[2]/fix->big[1], expects (535341266467 -535341266467 -535341266467 535341266467 #t) ==> ok
test big[2]/fix->big[2], expects (12312849128741 -12312849128741 -12312849128741 12312849128741 #t) ==> ok
test big[1]/fix->fix, expects (41943 -41943 -41943 41943 #t) ==> ok
test big[2]/fix->fix, expects (19088743 -19088743 -19088743 19088743 #t) ==> ok
test big[2]/fix->fix, expects (92894912 -92894912 -92894912 92894912 #t) ==> ok
test big[2]/fix->big[1], expects (2582762030 -2582762030 -2582762030 2582762030 #t) ==> ok
test big[1]/big[1]->fix, expects (2 -2 -2 2 #t) ==> ok
test big[1]/big[1] -> fix, expects (0 0 0 0 #t) ==> ok
test big[3]/big[2] -> big[1], expects (4294901761 -4294901761 -4294901761 4294901761 #t) ==> ok
test big[3]/big[2] -> fix, expects (61438 -61438 -61438 61438 #t) ==> ok
test exact/inexact -> inexact, expects (3.0 -3.0 -3.0 3.0 #f) ==> ok
test inexact/exact -> inexact, expects (3.0 -3.0 -3.0 3.0 #f) ==> ok
test inexact/inexact -> inexact, expects (3.0 -3.0 -3.0 3.0 #f) ==> ok
test exact/inexact -> inexact, expects (17353.0 -17353.0 -17353.0 17353.0 #f) ==> ok
test inexact/exact -> inexact, expects (17353.0 -17353.0 -17353.0 17353.0 #f) ==> ok
test inexact/inexact -> inexact, expects (17353.0 -17353.0 -17353.0 17353.0 #f) ==> ok
test fermat(7), expects 59649589127497217 ==> ok
test fermat(8), expects 1238926361552897 ==> ok
test fermat(9), expects 2424833 ==> ok
test fermat(10), expects 4659775785220018543264560743076778192897 ==> ok
test fermat(11), expects 3560841906445833920513 ==> ok
<remainder>--------------------------------------------------------------------
test fix rem fix -> fix, expects (1 -1 1 -1 #t) ==> ok
test fix rem fix -> fix, expects (1234 -1234 1234 -1234 #t) ==> ok
test fix rem big[1] -> fix, expects (12345 -12345 12345 -12345 #t) ==> ok
test big[1] rem fix -> fix, expects (0 0 0 0 #t) ==> ok
test big[1] rem fix -> fix, expects (1113 -1113 1113 -1113 #t) ==> ok
test big[2] rem fix -> fix, expects (15 -15 15 -15 #t) ==> ok
test big[2] rem fix -> fix, expects (0 0 0 0 #t) ==> ok
test big[1] rem fix -> fix, expects (0 0 0 0 #t) ==> ok
test big[2] rem fix -> fix, expects (725433 -725433 725433 -725433 #t) ==> ok
test big[2] rem fix -> fix, expects (122789 -122789 122789 -122789 #t) ==> ok
test big[2] rem fix -> fix, expects (19735 -19735 19735 -19735 #t) ==> ok
test big[1] rem big[1] -> fix, expects (115598656 -115598656 115598656 -115598656 #t) ==> ok
test big[1] rem big[1] -> fix, expects (1952679221 -1952679221 1952679221 -1952679221 #t) ==> ok
test big[3] rem big[2] -> big[1], expects (4294836225 -4294836225 4294836225 -4294836225 #t) ==> ok
test big[3] rem big[2] -> big[2], expects (140736164327422 -140736164327422 140736164327422 -140736164327422 #t) ==> ok
test exact rem inexact -> inexact, expects (1.0 -1.0 1.0 -1.0 #f) ==> ok
test inexact rem exact -> inexact, expects (1.0 -1.0 1.0 -1.0 #f) ==> ok
test inexact rem inexact -> inexact, expects (1.0 -1.0 1.0 -1.0 #f) ==> ok
test exact rem inexact -> inexact, expects (1113.0 -1113.0 1113.0 -1113.0 #f) ==> ok
test inexact rem exact -> inexact, expects (1113.0 -1113.0 1113.0 -1113.0 #f) ==> ok
test inexact rem inexact -> inexact, expects (1113.0 -1113.0 1113.0 -1113.0 #f) ==> ok
<modulo>-----------------------------------------------------------------------
test fix mod fix -> fix, expects (1 3 -3 -1 #t) ==> ok
test fix mod fix -> fix, expects (1234 86701 -86701 -1234 #t) ==> ok
test fix mod big[1] -> fix/big, expects (12345 3735916214 -3735916214 -12345 #t) ==> ok
test big[1] mod fix -> fix, expects (0 0 0 0 #t) ==> ok
test big[1] mod fix -> fix, expects (1113 26240 -26240 -1113 #t) ==> ok
test big[2] mod fix -> fix, expects (15 8 -8 -15 #t) ==> ok
test big[2] mod fix -> fix, expects (0 0 0 0 #t) ==> ok
test big[1] mod fix -> fix, expects (0 0 0 0 #t) ==> ok
test big[2] mod fix -> fix, expects (725433 36259007 -36259007 -725433 #t) ==> ok
test big[2] mod fix -> fix, expects (122789 9757 -9757 -122789 #t) ==> ok
test big[2] mod fix -> fix, expects (19735 145165 -145165 -19735 #t) ==> ok
test big[1] mod big[1] -> fix, expects (115598656 1837080565 -1837080565 -115598656 #t) ==> ok
test big[1] mod big[1] -> fix, expects (1952679221 2068277877 -2068277877 -1952679221 #t) ==> ok
test big[3] mod big[2] -> big[1], expects (4294836225 196606 -196606 -4294836225 #t) ==> ok
test big[3] mod big[2] -> big[2], expects (140736164327422 3614773249 -3614773249 -140736164327422 #t) ==> ok
test exact mod inexact -> inexact, expects (1.0 3.0 -3.0 -1.0 #f) ==> ok
test inexact mod exact -> inexact, expects (1.0 3.0 -3.0 -1.0 #f) ==> ok
test inexact mod inexact -> inexact, expects (1.0 3.0 -3.0 -1.0 #f) ==> ok
test exact mod inexact -> inexact, expects (1113.0 26240.0 -26240.0 -1113.0 #f) ==> ok
test inexact mod exact -> inexact, expects (1113.0 26240.0 -26240.0 -1113.0 #f) ==> ok
test inexact mod inexact -> inexact, expects (1113.0 26240.0 -26240.0 -1113.0 #f) ==> ok
test mersenne prime, expects (#t #t #t #t #t #t #t #t #t #t #t #t #t #t) ==> ok
<quotient&remainder>-----------------------------------------------------------
test quotient&remainder 3 2, expects (1 1) ==> ok
test quotient&remainder -3 2, expects (-1 -1) ==> ok
test quotient&remainder 3 -2, expects (-1 1) ==> ok
test quotient&remainder -3 -2, expects (1 -1) ==> ok
test quotient&remainder 3.0 2, expects (1.0 1.0) ==> ok
test quotient&remainder -3.0 2, expects (-1.0 -1.0) ==> ok
test quotient&remainder 3.0 -2, expects (-1.0 1.0) ==> ok
test quotient&remainder -3.0 -2, expects (1.0 -1.0) ==> ok
test quotient&remainder 3 2.0, expects (1.0 1.0) ==> ok
test quotient&remainder -3 2.0, expects (-1.0 -1.0) ==> ok
test quotient&remainder 3 -2.0, expects (-1.0 1.0) ==> ok
test quotient&remainder -3 -2.0, expects (1.0 -1.0) ==> ok
test quotient&remainder 7 3, expects (2 1) ==> ok
test quotient&remainder -7 3, expects (-2 -1) ==> ok
test quotient&remainder 7 -3, expects (-2 1) ==> ok
test quotient&remainder -7 -3, expects (2 -1) ==> ok
test quotient&remainder 7.0 3, expects (2.0 1.0) ==> ok
test quotient&remainder -7.0 3, expects (-2.0 -1.0) ==> ok
test quotient&remainder 7.0 -3, expects (-2.0 1.0) ==> ok
test quotient&remainder -7.0 -3, expects (2.0 -1.0) ==> ok
test quotient&remainder 7 3.0, expects (2.0 1.0) ==> ok
test quotient&remainder -7 3.0, expects (-2.0 -1.0) ==> ok
test quotient&remainder 7 -3.0, expects (-2.0 1.0) ==> ok
test quotient&remainder -7 -3.0, expects (2.0 -1.0) ==> ok
test quotient&remainder 7 9, expects (0 7) ==> ok
test quotient&remainder -7 9, expects (0 -7) ==> ok
test quotient&remainder 7 -9, expects (0 7) ==> ok
test quotient&remainder -7 -9, expects (0 -7) ==> ok
test quotient&remainder 7.0 9, expects (0.0 7.0) ==> ok
test quotient&remainder -7.0 9, expects (0.0 -7.0) ==> ok
test quotient&remainder 7.0 -9, expects (0.0 7.0) ==> ok
test quotient&remainder -7.0 -9, expects (0.0 -7.0) ==> ok
test quotient&remainder 7 9.0, expects (0.0 7.0) ==> ok
test quotient&remainder -7 9.0, expects (0.0 -7.0) ==> ok
test quotient&remainder 7 -9.0, expects (0.0 7.0) ==> ok
test quotient&remainder -7 -9.0, expects (0.0 -7.0) ==> ok
<div and mod>------------------------------------------------------------------
test 3 div 2, expects (#t #t) ==> ok
test -3 div 2, expects (#t #t) ==> ok
test 3 div -2, expects (#t #t) ==> ok
test -3 div -2, expects (#t #t) ==> ok
test 3.0 div 2, expects (#t #t) ==> ok
test -3.0 div 2, expects (#t #t) ==> ok
test 3.0 div -2, expects (#t #t) ==> ok
test -3.0 div -2, expects (#t #t) ==> ok
test 123 div 10, expects (#t #t) ==> ok
test -123 div 10, expects (#t #t) ==> ok
test 123 div -10, expects (#t #t) ==> ok
test -123 div -10, expects (#t #t) ==> ok
test 123.0 div 10.0, expects (#t #t) ==> ok
test -123.0 div 10.0, expects (#t #t) ==> ok
test 123.0 div -10.0, expects (#t #t) ==> ok
test -123.0 div -10.0, expects (#t #t) ==> ok
test 123/7 div 10/7, expects (#t #t) ==> ok
test -123/7 div 10/7, expects (#t #t) ==> ok
test 123/7 div -10/7, expects (#t #t) ==> ok
test -123/7 div -10/7, expects (#t #t) ==> ok
test 123/7 div 5, expects (#t #t) ==> ok
test -123/7 div 5, expects (#t #t) ==> ok
test 123/7 div -5, expects (#t #t) ==> ok
test -123/7 div -5, expects (#t #t) ==> ok
test 123 div 5/7, expects (#t #t) ==> ok
test -123 div 5/7, expects (#t #t) ==> ok
test 123 div -5/7, expects (#t #t) ==> ok
test -123 div -5/7, expects (#t #t) ==> ok
test 130.75 div 10.5, expects (#t #t) ==> ok
test -130.75 div 10.5, expects (#t #t) ==> ok
test 130.75 div -10.5, expects (#t #t) ==> ok
test -130.75 div -10.5, expects (#t #t) ==> ok
test 123 div0 10, expects (#t #t) ==> ok
test -123 div0 10, expects (#t #t) ==> ok
test 123 div0 -10, expects (#t #t) ==> ok
test -123 div0 -10, expects (#t #t) ==> ok
test 129 div0 10, expects (#t #t) ==> ok
test -129 div0 10, expects (#t #t) ==> ok
test 129 div0 -10, expects (#t #t) ==> ok
test -129 div0 -10, expects (#t #t) ==> ok
test 123.0 div0 10.0, expects (#t #t) ==> ok
test -123.0 div0 10.0, expects (#t #t) ==> ok
test 123.0 div0 -10.0, expects (#t #t) ==> ok
test -123.0 div0 -10.0, expects (#t #t) ==> ok
test 129.0 div0 10.0, expects (#t #t) ==> ok
test -129.0 div0 10.0, expects (#t #t) ==> ok
test 129.0 div0 -10.0, expects (#t #t) ==> ok
test -129.0 div0 -10.0, expects (#t #t) ==> ok
test 123/7 div0 10/7, expects (#t #t) ==> ok
test -123/7 div0 10/7, expects (#t #t) ==> ok
test 123/7 div0 -10/7, expects (#t #t) ==> ok
test -123/7 div0 -10/7, expects (#t #t) ==> ok
test 129/7 div0 10/7, expects (#t #t) ==> ok
test -129/7 div0 10/7, expects (#t #t) ==> ok
test 129/7 div0 -10/7, expects (#t #t) ==> ok
test -129/7 div0 -10/7, expects (#t #t) ==> ok
test 121/7 div0 5, expects (#t #t) ==> ok
test -121/7 div0 5, expects (#t #t) ==> ok
test 121/7 div0 -5, expects (#t #t) ==> ok
test -121/7 div0 -5, expects (#t #t) ==> ok
test 124/7 div0 5, expects (#t #t) ==> ok
test -124/7 div0 5, expects (#t #t) ==> ok
test 124/7 div0 -5, expects (#t #t) ==> ok
test -124/7 div0 -5, expects (#t #t) ==> ok
test 121 div0 5/7, expects (#t #t) ==> ok
test -121 div0 5/7, expects (#t #t) ==> ok
test 121 div0 -5/7, expects (#t #t) ==> ok
test -121 div0 -5/7, expects (#t #t) ==> ok
test 124 div0 5/7, expects (#t #t) ==> ok
test -124 div0 5/7, expects (#t #t) ==> ok
test 124 div0 -5/7, expects (#t #t) ==> ok
test -124 div0 -5/7, expects (#t #t) ==> ok
test 130.75 div0 10.5, expects (#t #t) ==> ok
test -130.75 div0 10.5, expects (#t #t) ==> ok
test 130.75 div0 -10.5, expects (#t #t) ==> ok
test -130.75 div0 -10.5, expects (#t #t) ==> ok
test 129.75 div0 10.5, expects (#t #t) ==> ok
test -129.75 div0 10.5, expects (#t #t) ==> ok
test 129.75 div0 -10.5, expects (#t #t) ==> ok
test -129.75 div0 -10.5, expects (#t #t) ==> ok
<rounding>---------------------------------------------------------------------
test rounding 0, expects (#t 0 0 0 0) ==> ok
test rounding 3, expects (#t 3 3 3 3) ==> ok
test rounding -3, expects (#t -3 -3 -3 -3) ==> ok
test rounding 633825300114114700748351602688, expects (#t 633825300114114700748351602688 633825300114114700748351602688 633825300114114700748351602688 633825300114114700748351602688) ==> ok
test rounding -633825300114114700748351602688, expects (#t -633825300114114700748351602688 -633825300114114700748351602688 -633825300114114700748351602688 -633825300114114700748351602688) ==> ok
test rounding 9/4, expects (#t 3 2 2 2) ==> ok
test rounding -9/4, expects (#t -2 -3 -2 -2) ==> ok
test rounding 34985495387484938453495/17, expects (#t 2057970316910878732559 2057970316910878732558 2057970316910878732558 2057970316910878732559) ==> ok
test rounding -34985495387484938453495/17, expects (#t -2057970316910878732558 -2057970316910878732559 -2057970316910878732558 -2057970316910878732559) ==> ok
test rounding 35565/2, expects (#t 17783 17782 17782 17782) ==> ok
test rounding -35565/2, expects (#t -17782 -17783 -17782 -17782) ==> ok
test rounding 35567/2, expects (#t 17784 17783 17783 17784) ==> ok
test rounding -35567/2, expects (#t -17783 -17784 -17783 -17784) ==> ok
test round->exact, expects 3 ==> ok
test round->exact, expects 4 ==> ok
test floor->exact, expects 3 ==> ok
test floor->exact, expects -4 ==> ok
test ceiling->exact, expects 4 ==> ok
test ceiling->exact, expects -3 ==> ok
test truncate->exact, expects 3 ==> ok
test truncate->exact, expects -3 ==> ok
<clamping>---------------------------------------------------------------------
test clamp (1), expects 1 ==> ok
test clamp (1 #f), expects 1 ==> ok
test clamp (1 #f #f), expects 1 ==> ok
test clamp (1.0), expects 1.0 ==> ok
test clamp (1.0 #f), expects 1.0 ==> ok
test clamp (1.0 #f #f), expects 1.0 ==> ok
test clamp (1 0), expects 1 ==> ok
test clamp (1 0 #f), expects 1 ==> ok
test clamp (1 0 2), expects 1 ==> ok
test clamp (1 5/4), expects 5/4 ==> ok
test clamp (1 5/4 #f), expects 5/4 ==> ok
test clamp (1 #f 5/4), expects 1 ==> ok
test clamp (1 0 3/4), expects 3/4 ==> ok
test clamp (1 #f 3/4), expects 3/4 ==> ok
test clamp (1.0 0), expects 1.0 ==> ok
test clamp (1.0 0 #f), expects 1.0 ==> ok
test clamp (1.0 0 2), expects 1.0 ==> ok
test clamp (1.0 5/4), expects 1.25 ==> ok
test clamp (1.0 5/4 #f), expects 1.25 ==> ok
test clamp (1.0 #f 5/4), expects 1.0 ==> ok
test clamp (1.0 0 3/4), expects 0.75 ==> ok
test clamp (1.0 #f 3/4), expects 0.75 ==> ok
test clamp (1 0.0), expects 1.0 ==> ok
test clamp (1 0.0 #f), expects 1.0 ==> ok
test clamp (1 0.0 2), expects 1.0 ==> ok
test clamp (1 0 2.0), expects 1.0 ==> ok
test clamp (1 1.25), expects 1.25 ==> ok
test clamp (1 #f 1.25), expects 1.0 ==> ok
test clamp (1 1.25 #f), expects 1.25 ==> ok
test clamp (1 0.0 3/4), expects 0.75 ==> ok
test clamp (1 0 0.75), expects 0.75 ==> ok
test clamp (1 -inf.0 +inf.0), expects 1.0 ==> ok
<logical operations>-----------------------------------------------------------
test ash (fixnum), expects 4227072 ==> ok
test ash (fixnum), expects 129 ==> ok
test ash (fixnum), expects 1 ==> ok
test ash (fixnum), expects 0 ==> ok
test ash (fixnum), expects 0 ==> ok
test ash (fixnum), expects 0 ==> ok
test ash (fixnum), expects 129 ==> ok
test ash (neg. fixnum), expects -4227072 ==> ok
test ash (neg. fixnum), expects -129 ==> ok
test ash (fixnum), expects -2 ==> ok
test ash (fixnum), expects -1 ==> ok
test ash (fixnum), expects -1 ==> ok
test ash (fixnum), expects -1 ==> ok
test ash (fixnum), expects -4227072 ==> ok
test ash (fixnum->bignum), expects 2164260864 ==> ok
test ash (fixnum->bignum), expects 277025390592 ==> ok
test ash (fixnum->bignum), expects 554050781184 ==> ok
test ash (fixnum->bignum), expects 9295429630892703744 ==> ok
test ash (fixnum->bignum), expects 1189814992754266079232 ==> ok
test ash (fixnum->bignum), expects 2379629985508532158464 ==> ok
test ash (neg.fixnum->bignum), expects -2164260864 ==> ok
test ash (neg.fixnum->bignum), expects -277025390592 ==> ok
test ash (neg.fixnum->bignum), expects -554050781184 ==> ok
test ash (neg.fixnum->bignum), expects -9295429630892703744 ==> ok
test ash (neg.fixnum->bignum), expects -1189814992754266079232 ==> ok
test ash (neg.fixnum->bignum), expects -2379629985508532158464 ==> ok
test ash (bignum->fixnum), expects 129 ==> ok
test ash (bignum->fixnum), expects 64 ==> ok
test ash (bignum->fixnum), expects 1 ==> ok
test ash (bignum->fixnum), expects 0 ==> ok
test ash (bignum->fixnum), expects 0 ==> ok
test ash (bignum->fixnum), expects 129 ==> ok
test ash (bignum->fixnum), expects 129 ==> ok
test ash (bignum->fixnum), expects 64 ==> ok
test ash (bignum->fixnum), expects 1 ==> ok
test ash (bignum->fixnum), expects 0 ==> ok
test ash (bignum->fixnum), expects 0 ==> ok
test ash (bignum->fixnum), expects 129 ==> ok
test ash (bignum->fixnum), expects 129 ==> ok
test ash (bignum->fixnum), expects 64 ==> ok
test ash (bignum->fixnum), expects 32 ==> ok
test ash (bignum->fixnum), expects 1 ==> ok
test ash (bignum->fixnum), expects 0 ==> ok
test ash (bignum->fixnum), expects 0 ==> ok
test ash (neg.bignum->fixnum), expects -129 ==> ok
test ash (neg.bignum->fixnum), expects -65 ==> ok
test ash (neg.bignum->fixnum), expects -33 ==> ok
test ash (neg.bignum->fixnum), expects -2 ==> ok
test ash (neg.bignum->fixnum), expects -1 ==> ok
test ash (neg.bignum->fixnum), expects -1 ==> ok
test ash (neg.bignum->fixnum), expects -1 ==> ok
test ash (neg.bignum->fixnum), expects -129 ==> ok
test ash (neg.bignum->fixnum), expects -65 ==> ok
test ash (neg.bignum->fixnum), expects -33 ==> ok
test ash (neg.bignum->fixnum), expects -2 ==> ok
test ash (neg.bignum->fixnum), expects -1 ==> ok
test ash (neg.bignum->fixnum), expects -1 ==> ok
test ash (neg.bignum->fixnum), expects -129 ==> ok
test ash (neg.bignum->fixnum), expects -65 ==> ok
test ash (neg.bignum->fixnum), expects -33 ==> ok
test ash (neg.bignum->fixnum), expects -2 ==> ok
test ash (neg.bignum->fixnum), expects -1 ==> ok
test ash (neg.bignum->fixnum), expects -1 ==> ok
test ash (bignum->bignum), expects 20988295442770257792 ==> ok
test ash (bignum->bignum), expects 1512366072563232197553754448238477312 ==> ok
test ash (bignum->bignum), expects 24197857161011715160860071171815636992 ==> ok
test ash (bignum->bignum), expects 81985529073321319 ==> ok
test ash (bignum->bignum), expects 305419896 ==> ok
test ash (neg.bignum->bignum), expects -81985529073321320 ==> ok
test ash (bignum->bignum), expects -305419897 ==> ok
test lognot (fixnum), expects -1 ==> ok
test lognot (fixnum), expects 0 ==> ok
test lognot (fixnum), expects -65536 ==> ok
test lognot (fixnum), expects 65535 ==> ok
test lognot (bignum), expects -4722366482869645213697 ==> ok
test lognot (bignum), expects 4722366482869645213696 ==> ok
test logand (+fix & 0), expects 0 ==> ok
test logand (+big & 0), expects 0 ==> ok
test logand (+fix & -1), expects 1193046 ==> ok
test logand (+big & -1), expects 1311768465173141112 ==> ok
test logand (+fix & +fix), expects 8772 ==> ok
test logand (+fix & +big), expects 8772 ==> ok
test logand (+big & +fix), expects 17442 ==> ok
test logand (+big & +big), expects 147171984418 ==> ok
test logand (+big & +big), expects 72978173061156010 ==> ok
test logand (+big & +big), expects 4194304 ==> ok
test logand (+fix & -fix), expects 34832 ==> ok
test logand (+fix & -big), expects 34832 ==> ok
test logand (+big & -fix), expects 731581649290 ==> ok
test logand (+big & -big), expects 584409682314 ==> ok
test logand (+big & -big), expects 9007356155330886 ==> ok
test logand (-fix & +fix), expects 17442 ==> ok
test logand (-fix & +big), expects 439804642338 ==> ok
test logand (-big & +fix), expects 8774 ==> ok
test logand (-big & +big), expects 292632666694 ==> ok
test logand (-big & +big), expects 22201630775426042613582817010070262539096080 ==> ok
test logand (-fix & -fix), expects -61046 ==> ok
test logand (-fix & -big), expects -439804685942 ==> ok
test logand (-big & -fix), expects -731581675502 ==> ok
test logand (-big & -big), expects -1024214333422 ==> ok
test logand (-big & -big), expects -22201630775426042613582817092055791755582976 ==> ok
test logior (+fix | 0), expects 1193046 ==> ok
test logior (+big | 0), expects 1311768465173141112 ==> ok
test logior (+fix | -1), expects -1 ==> ok
test logior (+big | -1), expects -1 ==> ok
test logior (+fix | +fix), expects 61047 ==> ok
test logior (+fix | +big), expects 439804685943 ==> ok
test logior (+big | +fix), expects 731581675502 ==> ok
test logior (+big | +big), expects 1024214333422 ==> ok
test logior (+big | +big), expects 22201630775426042613582817092055791755582975 ==> ok
test logior (+fix | -fix), expects -17441 ==> ok
test logior (+fix | -big), expects -439804642337 ==> ok
test logior (+big | -fix), expects -8774 ==> ok
test logior (+big | -big), expects -292632666694 ==> ok
test logior (+big | -big), expects -22201630775426042613582817010070262539096081 ==> ok
test logior (-fix | +fix), expects -34833 ==> ok
test logior (-fix | +big), expects -34833 ==> ok
test logior (-big | +fix), expects -731581649290 ==> ok
test logior (-big | +big), expects -584409682314 ==> ok
test logior (-big | +big), expects -9007356155330885 ==> ok
test logior (-fix | -fix), expects -8773 ==> ok
test logior (-fix | -big), expects -8773 ==> ok
test logior (-big | -fix), expects -17442 ==> ok
test logior (-big | -big), expects -147171984418 ==> ok
test logior (-big | -big), expects -72978173061156009 ==> ok
test lognot (error), expects #<error> ==> ok
test logand (error), expects #<error> ==> ok
test logior (error), expects #<error> ==> ok
test logxor (error), expects #<error> ==> ok
test logand (0arg), expects -1 ==> ok
test logand (1arg), expects 1 ==> ok
test logand (1arg), expects #<error> ==> ok
test logior (0arg), expects 0 ==> ok
test logior (1arg), expects 1 ==> ok
test logior (1arg), expects #<error> ==> ok
test logxor (0arg), expects 0 ==> ok
test logxor (1arg), expects 1 ==> ok
test logxor (1arg), expects #<error> ==> ok
test logtest, expects #t ==> ok
test logtest, expects #f ==> ok
test logcount (positive, 100...) 1, expects 1 ==> ok
test logcount (positive, 111...) 1, expects 1 ==> ok
test logcount (negative, 100...) 1, expects 0 ==> ok
test logcount (negative, 100..1) 1, expects 1 ==> ok
test logcount (positive, 100...) 2, expects 1 ==> ok
test logcount (positive, 111...) 2, expects 2 ==> ok
test logcount (negative, 100...) 2, expects 1 ==> ok
test logcount (negative, 100..1) 2, expects 1 ==> ok
test logcount (positive, 100...) 3, expects 1 ==> ok
test logcount (positive, 111...) 3, expects 3 ==> ok
test logcount (negative, 100...) 3, expects 2 ==> ok
test logcount (negative, 100..1) 3, expects 1 ==> ok
test logcount (positive, 100...) 4, expects 1 ==> ok
test logcount (positive, 111...) 4, expects 4 ==> ok
test logcount (negative, 100...) 4, expects 3 ==> ok
test logcount (negative, 100..1) 4, expects 1 ==> ok
test logcount (positive, 100...) 5, expects 1 ==> ok
test logcount (positive, 111...) 5, expects 5 ==> ok
test logcount (negative, 100...) 5, expects 4 ==> ok
test logcount (negative, 100..1) 5, expects 1 ==> ok
test logcount (positive, 100...) 6, expects 1 ==> ok
test logcount (positive, 111...) 6, expects 6 ==> ok
test logcount (negative, 100...) 6, expects 5 ==> ok
test logcount (negative, 100..1) 6, expects 1 ==> ok
test logcount (positive, 100...) 7, expects 1 ==> ok
test logcount (positive, 111...) 7, expects 7 ==> ok
test logcount (negative, 100...) 7, expects 6 ==> ok
test logcount (negative, 100..1) 7, expects 1 ==> ok
test logcount (positive, 100...) 8, expects 1 ==> ok
test logcount (positive, 111...) 8, expects 8 ==> ok
test logcount (negative, 100...) 8, expects 7 ==> ok
test logcount (negative, 100..1) 8, expects 1 ==> ok
test logcount (positive, 100...) 9, expects 1 ==> ok
test logcount (positive, 111...) 9, expects 9 ==> ok
test logcount (negative, 100...) 9, expects 8 ==> ok
test logcount (negative, 100..1) 9, expects 1 ==> ok
test logcount (positive, 100...) 10, expects 1 ==> ok
test logcount (positive, 111...) 10, expects 10 ==> ok
test logcount (negative, 100...) 10, expects 9 ==> ok
test logcount (negative, 100..1) 10, expects 1 ==> ok
test logcount (positive, 100...) 11, expects 1 ==> ok
test logcount (positive, 111...) 11, expects 11 ==> ok
test logcount (negative, 100...) 11, expects 10 ==> ok
test logcount (negative, 100..1) 11, expects 1 ==> ok
test logcount (positive, 100...) 12, expects 1 ==> ok
test logcount (positive, 111...) 12, expects 12 ==> ok
test logcount (negative, 100...) 12, expects 11 ==> ok
test logcount (negative, 100..1) 12, expects 1 ==> ok
test logcount (positive, 100...) 13, expects 1 ==> ok
test logcount (positive, 111...) 13, expects 13 ==> ok
test logcount (negative, 100...) 13, expects 12 ==> ok
test logcount (negative, 100..1) 13, expects 1 ==> ok
test logcount (positive, 100...) 14, expects 1 ==> ok
test logcount (positive, 111...) 14, expects 14 ==> ok
test logcount (negative, 100...) 14, expects 13 ==> ok
test logcount (negative, 100..1) 14, expects 1 ==> ok
test logcount (positive, 100...) 15, expects 1 ==> ok
test logcount (positive, 111...) 15, expects 15 ==> ok
test logcount (negative, 100...) 15, expects 14 ==> ok
test logcount (negative, 100..1) 15, expects 1 ==> ok
test logcount (positive, 100...) 16, expects 1 ==> ok
test logcount (positive, 111...) 16, expects 16 ==> ok
test logcount (negative, 100...) 16, expects 15 ==> ok
test logcount (negative, 100..1) 16, expects 1 ==> ok
test logcount (positive, 100...) 17, expects 1 ==> ok
test logcount (positive, 111...) 17, expects 17 ==> ok
test logcount (negative, 100...) 17, expects 16 ==> ok
test logcount (negative, 100..1) 17, expects 1 ==> ok
test logcount (positive, 100...) 18, expects 1 ==> ok
test logcount (positive, 111...) 18, expects 18 ==> ok
test logcount (negative, 100...) 18, expects 17 ==> ok
test logcount (negative, 100..1) 18, expects 1 ==> ok
test logcount (positive, 100...) 19, expects 1 ==> ok
test logcount (positive, 111...) 19, expects 19 ==> ok
test logcount (negative, 100...) 19, expects 18 ==> ok
test logcount (negative, 100..1) 19, expects 1 ==> ok
test logcount (positive, 100...) 20, expects 1 ==> ok
test logcount (positive, 111...) 20, expects 20 ==> ok
test logcount (negative, 100...) 20, expects 19 ==> ok
test logcount (negative, 100..1) 20, expects 1 ==> ok
test logcount (positive, 100...) 21, expects 1 ==> ok
test logcount (positive, 111...) 21, expects 21 ==> ok
test logcount (negative, 100...) 21, expects 20 ==> ok
test logcount (negative, 100..1) 21, expects 1 ==> ok
test logcount (positive, 100...) 22, expects 1 ==> ok
test logcount (positive, 111...) 22, expects 22 ==> ok
test logcount (negative, 100...) 22, expects 21 ==> ok
test logcount (negative, 100..1) 22, expects 1 ==> ok
test logcount (positive, 100...) 23, expects 1 ==> ok
test logcount (positive, 111...) 23, expects 23 ==> ok
test logcount (negative, 100...) 23, expects 22 ==> ok
test logcount (negative, 100..1) 23, expects 1 ==> ok
test logcount (positive, 100...) 24, expects 1 ==> ok
test logcount (positive, 111...) 24, expects 24 ==> ok
test logcount (negative, 100...) 24, expects 23 ==> ok
test logcount (negative, 100..1) 24, expects 1 ==> ok
test logcount (positive, 100...) 25, expects 1 ==> ok
test logcount (positive, 111...) 25, expects 25 ==> ok
test logcount (negative, 100...) 25, expects 24 ==> ok
test logcount (negative, 100..1) 25, expects 1 ==> ok
test logcount (positive, 100...) 26, expects 1 ==> ok
test logcount (positive, 111...) 26, expects 26 ==> ok
test logcount (negative, 100...) 26, expects 25 ==> ok
test logcount (negative, 100..1) 26, expects 1 ==> ok
test logcount (positive, 100...) 27, expects 1 ==> ok
test logcount (positive, 111...) 27, expects 27 ==> ok
test logcount (negative, 100...) 27, expects 26 ==> ok
test logcount (negative, 100..1) 27, expects 1 ==> ok
test logcount (positive, 100...) 28, expects 1 ==> ok
test logcount (positive, 111...) 28, expects 28 ==> ok
test logcount (negative, 100...) 28, expects 27 ==> ok
test logcount (negative, 100..1) 28, expects 1 ==> ok
test logcount (positive, 100...) 29, expects 1 ==> ok
test logcount (positive, 111...) 29, expects 29 ==> ok
test logcount (negative, 100...) 29, expects 28 ==> ok
test logcount (negative, 100..1) 29, expects 1 ==> ok
test logcount (positive, 100...) 30, expects 1 ==> ok
test logcount (positive, 111...) 30, expects 30 ==> ok
test logcount (negative, 100...) 30, expects 29 ==> ok
test logcount (negative, 100..1) 30, expects 1 ==> ok
test logcount (positive, 100...) 31, expects 1 ==> ok
test logcount (positive, 111...) 31, expects 31 ==> ok
test logcount (negative, 100...) 31, expects 30 ==> ok
test logcount (negative, 100..1) 31, expects 1 ==> ok
test logcount (positive, 100...) 32, expects 1 ==> ok
test logcount (positive, 111...) 32, expects 32 ==> ok
test logcount (negative, 100...) 32, expects 31 ==> ok
test logcount (negative, 100..1) 32, expects 1 ==> ok
test logcount (positive, 100...) 33, expects 1 ==> ok
test logcount (positive, 111...) 33, expects 33 ==> ok
test logcount (negative, 100...) 33, expects 32 ==> ok
test logcount (negative, 100..1) 33, expects 1 ==> ok
test logcount (positive, 100...) 34, expects 1 ==> ok
test logcount (positive, 111...) 34, expects 34 ==> ok
test logcount (negative, 100...) 34, expects 33 ==> ok
test logcount (negative, 100..1) 34, expects 1 ==> ok
test logcount (positive, 100...) 35, expects 1 ==> ok
test logcount (positive, 111...) 35, expects 35 ==> ok
test logcount (negative, 100...) 35, expects 34 ==> ok
test logcount (negative, 100..1) 35, expects 1 ==> ok
test logcount (positive, 100...) 36, expects 1 ==> ok
test logcount (positive, 111...) 36, expects 36 ==> ok
test logcount (negative, 100...) 36, expects 35 ==> ok
test logcount (negative, 100..1) 36, expects 1 ==> ok
test logcount (positive, 100...) 37, expects 1 ==> ok
test logcount (positive, 111...) 37, expects 37 ==> ok
test logcount (negative, 100...) 37, expects 36 ==> ok
test logcount (negative, 100..1) 37, expects 1 ==> ok
test logcount (positive, 100...) 38, expects 1 ==> ok
test logcount (positive, 111...) 38, expects 38 ==> ok
test logcount (negative, 100...) 38, expects 37 ==> ok
test logcount (negative, 100..1) 38, expects 1 ==> ok
test logcount (positive, 100...) 39, expects 1 ==> ok
test logcount (positive, 111...) 39, expects 39 ==> ok
test logcount (negative, 100...) 39, expects 38 ==> ok
test logcount (negative, 100..1) 39, expects 1 ==> ok
test logcount (positive, 100...) 40, expects 1 ==> ok
test logcount (positive, 111...) 40, expects 40 ==> ok
test logcount (negative, 100...) 40, expects 39 ==> ok
test logcount (negative, 100..1) 40, expects 1 ==> ok
test logcount (positive, 100...) 41, expects 1 ==> ok
test logcount (positive, 111...) 41, expects 41 ==> ok
test logcount (negative, 100...) 41, expects 40 ==> ok
test logcount (negative, 100..1) 41, expects 1 ==> ok
test logcount (positive, 100...) 42, expects 1 ==> ok
test logcount (positive, 111...) 42, expects 42 ==> ok
test logcount (negative, 100...) 42, expects 41 ==> ok
test logcount (negative, 100..1) 42, expects 1 ==> ok
test logcount (positive, 100...) 43, expects 1 ==> ok
test logcount (positive, 111...) 43, expects 43 ==> ok
test logcount (negative, 100...) 43, expects 42 ==> ok
test logcount (negative, 100..1) 43, expects 1 ==> ok
test logcount (positive, 100...) 44, expects 1 ==> ok
test logcount (positive, 111...) 44, expects 44 ==> ok
test logcount (negative, 100...) 44, expects 43 ==> ok
test logcount (negative, 100..1) 44, expects 1 ==> ok
test logcount (positive, 100...) 45, expects 1 ==> ok
test logcount (positive, 111...) 45, expects 45 ==> ok
test logcount (negative, 100...) 45, expects 44 ==> ok
test logcount (negative, 100..1) 45, expects 1 ==> ok
test logcount (positive, 100...) 46, expects 1 ==> ok
test logcount (positive, 111...) 46, expects 46 ==> ok
test logcount (negative, 100...) 46, expects 45 ==> ok
test logcount (negative, 100..1) 46, expects 1 ==> ok
test logcount (positive, 100...) 47, expects 1 ==> ok
test logcount (positive, 111...) 47, expects 47 ==> ok
test logcount (negative, 100...) 47, expects 46 ==> ok
test logcount (negative, 100..1) 47, expects 1 ==> ok
test logcount (positive, 100...) 48, expects 1 ==> ok
test logcount (positive, 111...) 48, expects 48 ==> ok
test logcount (negative, 100...) 48, expects 47 ==> ok
test logcount (negative, 100..1) 48, expects 1 ==> ok
test logcount (positive, 100...) 49, expects 1 ==> ok
test logcount (positive, 111...) 49, expects 49 ==> ok
test logcount (negative, 100...) 49, expects 48 ==> ok
test logcount (negative, 100..1) 49, expects 1 ==> ok
test logcount (positive, 100...) 50, expects 1 ==> ok
test logcount (positive, 111...) 50, expects 50 ==> ok
test logcount (negative, 100...) 50, expects 49 ==> ok
test logcount (negative, 100..1) 50, expects 1 ==> ok
test logcount (positive, 100...) 51, expects 1 ==> ok
test logcount (positive, 111...) 51, expects 51 ==> ok
test logcount (negative, 100...) 51, expects 50 ==> ok
test logcount (negative, 100..1) 51, expects 1 ==> ok
test logcount (positive, 100...) 52, expects 1 ==> ok
test logcount (positive, 111...) 52, expects 52 ==> ok
test logcount (negative, 100...) 52, expects 51 ==> ok
test logcount (negative, 100..1) 52, expects 1 ==> ok
test logcount (positive, 100...) 53, expects 1 ==> ok
test logcount (positive, 111...) 53, expects 53 ==> ok
test logcount (negative, 100...) 53, expects 52 ==> ok
test logcount (negative, 100..1) 53, expects 1 ==> ok
test logcount (positive, 100...) 54, expects 1 ==> ok
test logcount (positive, 111...) 54, expects 54 ==> ok
test logcount (negative, 100...) 54, expects 53 ==> ok
test logcount (negative, 100..1) 54, expects 1 ==> ok
test logcount (positive, 100...) 55, expects 1 ==> ok
test logcount (positive, 111...) 55, expects 55 ==> ok
test logcount (negative, 100...) 55, expects 54 ==> ok
test logcount (negative, 100..1) 55, expects 1 ==> ok
test logcount (positive, 100...) 56, expects 1 ==> ok
test logcount (positive, 111...) 56, expects 56 ==> ok
test logcount (negative, 100...) 56, expects 55 ==> ok
test logcount (negative, 100..1) 56, expects 1 ==> ok
test logcount (positive, 100...) 57, expects 1 ==> ok
test logcount (positive, 111...) 57, expects 57 ==> ok
test logcount (negative, 100...) 57, expects 56 ==> ok
test logcount (negative, 100..1) 57, expects 1 ==> ok
test logcount (positive, 100...) 58, expects 1 ==> ok
test logcount (positive, 111...) 58, expects 58 ==> ok
test logcount (negative, 100...) 58, expects 57 ==> ok
test logcount (negative, 100..1) 58, expects 1 ==> ok
test logcount (positive, 100...) 59, expects 1 ==> ok
test logcount (positive, 111...) 59, expects 59 ==> ok
test logcount (negative, 100...) 59, expects 58 ==> ok
test logcount (negative, 100..1) 59, expects 1 ==> ok
test logcount (positive, 100...) 60, expects 1 ==> ok
test logcount (positive, 111...) 60, expects 60 ==> ok
test logcount (negative, 100...) 60, expects 59 ==> ok
test logcount (negative, 100..1) 60, expects 1 ==> ok
test logcount (positive, 100...) 61, expects 1 ==> ok
test logcount (positive, 111...) 61, expects 61 ==> ok
test logcount (negative, 100...) 61, expects 60 ==> ok
test logcount (negative, 100..1) 61, expects 1 ==> ok
test logcount (positive, 100...) 62, expects 1 ==> ok
test logcount (positive, 111...) 62, expects 62 ==> ok
test logcount (negative, 100...) 62, expects 61 ==> ok
test logcount (negative, 100..1) 62, expects 1 ==> ok
test logcount (positive, 100...) 63, expects 1 ==> ok
test logcount (positive, 111...) 63, expects 63 ==> ok
test logcount (negative, 100...) 63, expects 62 ==> ok
test logcount (negative, 100..1) 63, expects 1 ==> ok
test logcount (positive, 100...) 64, expects 1 ==> ok
test logcount (positive, 111...) 64, expects 64 ==> ok
test logcount (negative, 100...) 64, expects 63 ==> ok
test logcount (negative, 100..1) 64, expects 1 ==> ok
test logcount (positive, 100...) 65, expects 1 ==> ok
test logcount (positive, 111...) 65, expects 65 ==> ok
test logcount (negative, 100...) 65, expects 64 ==> ok
test logcount (negative, 100..1) 65, expects 1 ==> ok
test logcount (positive, 100...) 66, expects 1 ==> ok
test logcount (positive, 111...) 66, expects 66 ==> ok
test logcount (negative, 100...) 66, expects 65 ==> ok
test logcount (negative, 100..1) 66, expects 1 ==> ok
test logcount (positive, 100...) 67, expects 1 ==> ok
test logcount (positive, 111...) 67, expects 67 ==> ok
test logcount (negative, 100...) 67, expects 66 ==> ok
test logcount (negative, 100..1) 67, expects 1 ==> ok
test logcount (positive, 100...) 68, expects 1 ==> ok
test logcount (positive, 111...) 68, expects 68 ==> ok
test logcount (negative, 100...) 68, expects 67 ==> ok
test logcount (negative, 100..1) 68, expects 1 ==> ok
test logbit?, expects (#f #t #t #f #t #f #f) ==> ok
test logbit?, expects (#f #t #f #t #f #t #t) ==> ok
test copy-bit, expects 214 ==> ok
test copy-bit, expects 198 ==> ok
test copy-bit, expects 134 ==> ok
test bit-field, expects 10 ==> ok
test bit-field, expects 22 ==> ok
test copy-bit-field, expects 864 ==> ok
test copy-bit-field, expects 879 ==> ok
test copy-bit-field, expects 65514 ==> ok
test integer-length, expects 8 ==> ok
test integer-length, expects 4 ==> ok
test integer-length, expects 0 ==> ok
test integer-length, expects 0 ==> ok
test integer-length, expects 1 ==> ok
test integer-length, expects 1 ==> ok
test integer-length, expects 29 ==> ok
test integer-length, expects 30 ==> ok
test integer-length, expects 61 ==> ok
test integer-length, expects 62 ==> ok
test integer-length, expects 29 ==> ok
test integer-length, expects 30 ==> ok
test integer-length, expects 61 ==> ok
test integer-length, expects 62 ==> ok
test integer-length, expects 1025 ==> ok
<inexact arithmetics>----------------------------------------------------------
test +. (0) inlined, expects 0.0 ==> ok
test +. (0) applied, expects 0.0 ==> ok
test +. (1) inlined, expects 1.0 ==> ok
test +. (1) applied, expects 1.0 ==> ok
test +. (1big) inlined, expects 1.0e20 ==> ok
test +. (1big) applied, expects 1.0e20 ==> ok
test +. (1rat) inlined, expects 1.5 ==> ok
test +. (1rat) applied, expects 1.5 ==> ok
test +. (1cmp) inlined, expects 1.0+1.0i ==> ok
test +. (1cmp) applied, expects 1.0+1.0i ==> ok
test +. (2) inlined, expects 1.0 ==> ok
test +. (2) applied, expects 1.0 ==> ok
test +. (2big) inlined, expects 1.0e20 ==> ok
test +. (2big) applied, expects 1.0e20 ==> ok
test +. (2rat) inlined, expects 1.5 ==> ok
test +. (2rat) applied, expects 1.5 ==> ok
test +. (many) inlined, expects 15.0 ==> ok
test +. (many) applied, expects 15.0 ==> ok
test -. (1) inlined, expects -1.0 ==> ok
test -. (1) applied, expects -1.0 ==> ok
test -. (1big) inlined, expects -1.0e20 ==> ok
test -. (1big) applied, expects -1.0e20 ==> ok
test -. (1rat) inlined, expects -1.5 ==> ok
test -. (1rat) applied, expects -1.5 ==> ok
test -. (1cmp) inlined, expects -1.0-1.0i ==> ok
test -. (1cmp) applied, expects -1.0-1.0i ==> ok
test -. (2) inlined, expects -1.0 ==> ok
test -. (2) applied, expects -1.0 ==> ok
test -. (2big) inlined, expects -1.0e20 ==> ok
test -. (2big) applied, expects -1.0e20 ==> ok
test -. (2rat) inlined, expects 0.5 ==> ok
test -. (2rat) applied, expects 0.5 ==> ok
test -. (many) inlined, expects -13.0 ==> ok
test -. (many) applied, expects -13.0 ==> ok
test *. (0) inlined, expects 1.0 ==> ok
test *. (0) applied, expects 1.0 ==> ok
test *. (1) inlined, expects 1.0 ==> ok
test *. (1) applied, expects 1.0 ==> ok
test *. (1big) inlined, expects 1.0e20 ==> ok
test *. (1big) applied, expects 1.0e20 ==> ok
test *. (1rat) inlined, expects 1.5 ==> ok
test *. (1rat) applied, expects 1.5 ==> ok
test *. (1cmp) inlined, expects 1.0+1.0i ==> ok
test *. (1cmp) applied, expects 1.0+1.0i ==> ok
test *. (2) inlined, expects 0.0 ==> ok
test *. (2) applied, expects 0.0 ==> ok
test *. (2big) inlined, expects 1.0e20 ==> ok
test *. (2big) applied, expects 1.0e20 ==> ok
test *. (2rat) inlined, expects 0.5 ==> ok
test *. (2rat) applied, expects 0.5 ==> ok
test *. (many) inlined, expects 120.0 ==> ok
test *. (many) applied, expects 120.0 ==> ok
test /. (1) inlined, expects 1.0 ==> ok
test /. (1) applied, expects 1.0 ==> ok
test /. (1big) inlined, expects 1.0e-20 ==> ok
test /. (1big) applied, expects 1.0e-20 ==> ok
test /. (1rat) inlined, expects 0.6666666666666666 ==> ok
test /. (1rat) applied, expects 0.6666666666666666 ==> ok
test /. (1cmp) inlined, expects 0.5-0.5i ==> ok
test /. (1cmp) applied, expects 0.5-0.5i ==> ok
test /. (2) inlined, expects 0.0 ==> ok
test /. (2) applied, expects 0.0 ==> ok
test /. (2big) inlined, expects 1.0e-20 ==> ok
test /. (2big) applied, expects 1.0e-20 ==> ok
test /. (2rat) inlined, expects 2.0 ==> ok
test /. (2rat) applied, expects 2.0 ==> ok
test /. (2rat1) inlined, expects 0.5 ==> ok
test /. (2rat1) applied, expects 0.5 ==> ok
test /. (2rat2) inlined, expects 2.0 ==> ok
test /. (2rat2) applied, expects 2.0 ==> ok
test /. (many) inlined, expects 0.1 ==> ok
test /. (many) applied, expects 0.1 ==> ok
test /. fixnum bignum inlined, expects 0.0 ==> ok
test /. fixnum bignum applied, expects 0.0 ==> ok
test /. bignum fixnum inlined, expects +inf.0 ==> ok
test /. bignum fixnum applied, expects +inf.0 ==> ok
test /. bignum fixnum inlined, expects -inf.0 ==> ok
test /. bignum fixnum applied, expects -inf.0 ==> ok
test /. bignum bignum inlined, expects 10.0 ==> ok
test /. bignum bignum applied, expects 10.0 ==> ok
<sqrt>-------------------------------------------------------------------------
test exact-integer-sqrt 0, expects (#t #t) ==> ok
test exact-integer-sqrt 1, expects (#t #t) ==> ok
test exact-integer-sqrt 2, expects (#t #t) ==> ok
test exact-integer-sqrt 3, expects (#t #t) ==> ok
test exact-integer-sqrt 4, expects (#t #t) ==> ok
test exact-integer-sqrt 10, expects (#t #t) ==> ok
test exact-integer-sqrt 4294967296, expects (#t #t) ==> ok
test exact-integer-sqrt 9007199254740991, expects (#t #t) ==> ok
test exact-integer-sqrt 9007199254740992, expects (#t #t) ==> ok
test exact-integer-sqrt 9007199254740993, expects (#t #t) ==> ok
test exact-integer-sqrt 9999999999999999999999999999999999999999999999999999, expects (#t #t) ==> ok
test exact-integer-sqrt 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003141592653589, expects (#t #t) ==> ok
test exact-integer-sqrt -1, expects #<error> ==> ok
test exact-integer-sqrt 1.0, expects #<error> ==> ok
test exact-integer-sqrt 1/4, expects #<error> ==> ok
test sqrt, exact, expects 0 ==> ok
test sqrt, exact, expects 4 ==> ok
test sqrt, inexact, expects 4.0 ==> ok
test sqrt, inexact, expects 0.0+4.0i ==> ok
test sqrt, exact, expects 1/4 ==> ok
test sqrt, inexact, expects 0.25 ==> ok
<posix math functions>---------------------------------------------------------
test fmod, expects 0.25 ==> ok
test fmod, expects 2.3 ==> ok
test fmod, expects 8.3 ==> ok
test frexp, expects (0.785 2) ==> ok
test ldexp, expects 3.14 ==> ok
test modf, expects (0.14 3.0) ==> ok
<ffx optimization>-------------------------------------------------------------
test probit(0.025), expects -1.959964 ==> ok
test probit(0.975), expects 1.959964 ==> ok
<arithmetic operation overload>------------------------------------------------
test object-+, expects "a+b" ==> ok
test object-+, expects "a+b" ==> ok
test object-+, expects "a+b" ==> ok
test object-+, expects "3+a" ==> ok
test object-+, expects "3+a" ==> ok
test object--, expects "a-b" ==> ok
test object--, expects "a-b" ==> ok
test object--, expects "a-b" ==> ok
test object--, expects "3-a" ==> ok
test object--, expects "-3+a" ==> ok
test object--, expects "-a" ==> ok
test object-*, expects "a*b" ==> ok
test object-*, expects "a*b" ==> ok
test object-*, expects "a*b" ==> ok
test object-*, expects "3*a" ==> ok
test object-*, expects "a*3" ==> ok
test object-/, expects "a/b" ==> ok
test object-/, expects "a/b" ==> ok
test object-/, expects "a/b" ==> ok
test object-/, expects "3/a" ==> ok
test object-/, expects "a/3" ==> ok
test object-/, expects "/a" ==> ok
failed.
discrepancies found.  Errors are:
test inexact->exact->inexact roundtrip "1+d": expects 1.0000000000000002 => got 1.0000000000000004
test inexact->exact->inexact roundtrip "1-d": expects 0.9999999999999999 => got 0.9999999999999998
Testing characters ============================================================
<basic comparison>-------------------------------------------------------------
test #<subr char=?> (#\a #\a), expects #t ==> ok
test #<subr char<?> (#\a #\a), expects #f ==> ok
test #<subr char<=?> (#\a #\a), expects #t ==> ok
test #<subr char>?> (#\a #\a), expects #f ==> ok
test #<subr char>=?> (#\a #\a), expects #t ==> ok
test #<subr char=?> (#\a #\a #\a), expects #t ==> ok
test #<subr char<?> (#\a #\a #\a), expects #f ==> ok
test #<subr char<=?> (#\a #\a #\a), expects #t ==> ok
test #<subr char>?> (#\a #\a #\a), expects #f ==> ok
test #<subr char>=?> (#\a #\a #\a), expects #t ==> ok
test #<subr char=?> (#\a #\a #\a #\a), expects #t ==> ok
test #<subr char<?> (#\a #\a #\a #\a), expects #f ==> ok
test #<subr char<=?> (#\a #\a #\a #\a), expects #t ==> ok
test #<subr char>?> (#\a #\a #\a #\a), expects #f ==> ok
test #<subr char>=?> (#\a #\a #\a #\a), expects #t ==> ok
test #<subr char=?> (#\a #\b), expects #f ==> ok
test #<subr char<?> (#\a #\b), expects #t ==> ok
test #<subr char<=?> (#\a #\b), expects #t ==> ok
test #<subr char>?> (#\a #\b), expects #f ==> ok
test #<subr char>=?> (#\a #\b), expects #f ==> ok
test #<subr char=?> (#\a #\b #\b), expects #f ==> ok
test #<subr char<?> (#\a #\b #\b), expects #f ==> ok
test #<subr char<=?> (#\a #\b #\b), expects #t ==> ok
test #<subr char>?> (#\a #\b #\b), expects #f ==> ok
test #<subr char>=?> (#\a #\b #\b), expects #f ==> ok
test #<subr char=?> (#\a #\b #\b #\c), expects #f ==> ok
test #<subr char<?> (#\a #\b #\b #\c), expects #f ==> ok
test #<subr char<=?> (#\a #\b #\b #\c), expects #t ==> ok
test #<subr char>?> (#\a #\b #\b #\c), expects #f ==> ok
test #<subr char>=?> (#\a #\b #\b #\c), expects #f ==> ok
test #<subr char=?> (#\a #\b #\b #\a), expects #f ==> ok
test #<subr char<?> (#\a #\b #\b #\a), expects #f ==> ok
test #<subr char<=?> (#\a #\b #\b #\a), expects #f ==> ok
test #<subr char>?> (#\a #\b #\b #\a), expects #f ==> ok
test #<subr char>=?> (#\a #\b #\b #\a), expects #f ==> ok
test #<subr char=?> (#\a #\b #\c), expects #f ==> ok
test #<subr char<?> (#\a #\b #\c), expects #t ==> ok
test #<subr char<=?> (#\a #\b #\c), expects #t ==> ok
test #<subr char>?> (#\a #\b #\c), expects #f ==> ok
test #<subr char>=?> (#\a #\b #\c), expects #f ==> ok
test #<subr char=?> (#\a #\b #\c #\d), expects #f ==> ok
test #<subr char<?> (#\a #\b #\c #\d), expects #t ==> ok
test #<subr char<=?> (#\a #\b #\c #\d), expects #t ==> ok
test #<subr char>?> (#\a #\b #\c #\d), expects #f ==> ok
test #<subr char>=?> (#\a #\b #\c #\d), expects #f ==> ok
test #<subr char=?> (#\a #\b #\c #\b), expects #f ==> ok
test #<subr char<?> (#\a #\b #\c #\b), expects #f ==> ok
test #<subr char<=?> (#\a #\b #\c #\b), expects #f ==> ok
test #<subr char>?> (#\a #\b #\c #\b), expects #f ==> ok
test #<subr char>=?> (#\a #\b #\c #\b), expects #f ==> ok
test #<subr char=?> (#\c #\b), expects #f ==> ok
test #<subr char<?> (#\c #\b), expects #f ==> ok
test #<subr char<=?> (#\c #\b), expects #f ==> ok
test #<subr char>?> (#\c #\b), expects #t ==> ok
test #<subr char>=?> (#\c #\b), expects #t ==> ok
test #<subr char=?> (#\c #\b #\b), expects #f ==> ok
test #<subr char<?> (#\c #\b #\b), expects #f ==> ok
test #<subr char<=?> (#\c #\b #\b), expects #f ==> ok
test #<subr char>?> (#\c #\b #\b), expects #f ==> ok
test #<subr char>=?> (#\c #\b #\b), expects #t ==> ok
test #<subr char=?> (#\c #\b #\b #\a), expects #f ==> ok
test #<subr char<?> (#\c #\b #\b #\a), expects #f ==> ok
test #<subr char<=?> (#\c #\b #\b #\a), expects #f ==> ok
test #<subr char>?> (#\c #\b #\b #\a), expects #f ==> ok
test #<subr char>=?> (#\c #\b #\b #\a), expects #t ==> ok
test #<subr char=?> (#\c #\b #\b #\c), expects #f ==> ok
test #<subr char<?> (#\c #\b #\b #\c), expects #f ==> ok
test #<subr char<=?> (#\c #\b #\b #\c), expects #f ==> ok
test #<subr char>?> (#\c #\b #\b #\c), expects #f ==> ok
test #<subr char>=?> (#\c #\b #\b #\c), expects #f ==> ok
test #<subr char=?> (#\d #\c #\b #\a), expects #f ==> ok
test #<subr char<?> (#\d #\c #\b #\a), expects #f ==> ok
test #<subr char<=?> (#\d #\c #\b #\a), expects #f ==> ok
test #<subr char>?> (#\d #\c #\b #\a), expects #t ==> ok
test #<subr char>=?> (#\d #\c #\b #\a), expects #t ==> ok
test #<subr char=?> (#\d #\c #\b #\c), expects #f ==> ok
test #<subr char<?> (#\d #\c #\b #\c), expects #f ==> ok
test #<subr char<=?> (#\d #\c #\b #\c), expects #f ==> ok
test #<subr char>?> (#\d #\c #\b #\c), expects #f ==> ok
test #<subr char>=?> (#\d #\c #\b #\c), expects #f ==> ok
test #<subr char-ci=?> (#\A #\a), expects #t ==> ok
test #<subr char-ci<?> (#\A #\a), expects #f ==> ok
test #<subr char-ci<=?> (#\A #\a), expects #t ==> ok
test #<subr char-ci>?> (#\A #\a), expects #f ==> ok
test #<subr char-ci>=?> (#\A #\a), expects #t ==> ok
test #<subr char-ci=?> (#\a #\A #\a), expects #t ==> ok
test #<subr char-ci<?> (#\a #\A #\a), expects #f ==> ok
test #<subr char-ci<=?> (#\a #\A #\a), expects #t ==> ok
test #<subr char-ci>?> (#\a #\A #\a), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\A #\a), expects #t ==> ok
test #<subr char-ci=?> (#\a #\A #\A #\a), expects #t ==> ok
test #<subr char-ci<?> (#\a #\A #\A #\a), expects #f ==> ok
test #<subr char-ci<=?> (#\a #\A #\A #\a), expects #t ==> ok
test #<subr char-ci>?> (#\a #\A #\A #\a), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\A #\A #\a), expects #t ==> ok
test #<subr char-ci=?> (#\a #\B), expects #f ==> ok
test #<subr char-ci<?> (#\a #\B), expects #t ==> ok
test #<subr char-ci<=?> (#\a #\B), expects #t ==> ok
test #<subr char-ci>?> (#\a #\B), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\B), expects #f ==> ok
test #<subr char-ci=?> (#\a #\B #\b), expects #f ==> ok
test #<subr char-ci<?> (#\a #\B #\b), expects #f ==> ok
test #<subr char-ci<=?> (#\a #\B #\b), expects #t ==> ok
test #<subr char-ci>?> (#\a #\B #\b), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\B #\b), expects #f ==> ok
test #<subr char-ci=?> (#\a #\B #\b #\C), expects #f ==> ok
test #<subr char-ci<?> (#\a #\B #\b #\C), expects #f ==> ok
test #<subr char-ci<=?> (#\a #\B #\b #\C), expects #t ==> ok
test #<subr char-ci>?> (#\a #\B #\b #\C), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\B #\b #\C), expects #f ==> ok
test #<subr char-ci=?> (#\a #\B #\b #\A), expects #f ==> ok
test #<subr char-ci<?> (#\a #\B #\b #\A), expects #f ==> ok
test #<subr char-ci<=?> (#\a #\B #\b #\A), expects #f ==> ok
test #<subr char-ci>?> (#\a #\B #\b #\A), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\B #\b #\A), expects #f ==> ok
test #<subr char-ci=?> (#\A #\b #\C), expects #f ==> ok
test #<subr char-ci<?> (#\A #\b #\C), expects #t ==> ok
test #<subr char-ci<=?> (#\A #\b #\C), expects #t ==> ok
test #<subr char-ci>?> (#\A #\b #\C), expects #f ==> ok
test #<subr char-ci>=?> (#\A #\b #\C), expects #f ==> ok
test #<subr char-ci=?> (#\a #\B #\c #\D), expects #f ==> ok
test #<subr char-ci<?> (#\a #\B #\c #\D), expects #t ==> ok
test #<subr char-ci<=?> (#\a #\B #\c #\D), expects #t ==> ok
test #<subr char-ci>?> (#\a #\B #\c #\D), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\B #\c #\D), expects #f ==> ok
test #<subr char-ci=?> (#\a #\B #\c #\b), expects #f ==> ok
test #<subr char-ci<?> (#\a #\B #\c #\b), expects #f ==> ok
test #<subr char-ci<=?> (#\a #\B #\c #\b), expects #f ==> ok
test #<subr char-ci>?> (#\a #\B #\c #\b), expects #f ==> ok
test #<subr char-ci>=?> (#\a #\B #\c #\b), expects #f ==> ok
test #<subr char-ci=?> (#\C #\b), expects #f ==> ok
test #<subr char-ci<?> (#\C #\b), expects #f ==> ok
test #<subr char-ci<=?> (#\C #\b), expects #f ==> ok
test #<subr char-ci>?> (#\C #\b), expects #t ==> ok
test #<subr char-ci>=?> (#\C #\b), expects #t ==> ok
test #<subr char-ci=?> (#\C #\b #\B), expects #f ==> ok
test #<subr char-ci<?> (#\C #\b #\B), expects #f ==> ok
test #<subr char-ci<=?> (#\C #\b #\B), expects #f ==> ok
test #<subr char-ci>?> (#\C #\b #\B), expects #f ==> ok
test #<subr char-ci>=?> (#\C #\b #\B), expects #t ==> ok
test #<subr char-ci=?> (#\C #\b #\B #\a), expects #f ==> ok
test #<subr char-ci<?> (#\C #\b #\B #\a), expects #f ==> ok
test #<subr char-ci<=?> (#\C #\b #\B #\a), expects #f ==> ok
test #<subr char-ci>?> (#\C #\b #\B #\a), expects #f ==> ok
test #<subr char-ci>=?> (#\C #\b #\B #\a), expects #t ==> ok
test #<subr char-ci=?> (#\C #\b #\B #\c), expects #f ==> ok
test #<subr char-ci<?> (#\C #\b #\B #\c), expects #f ==> ok
test #<subr char-ci<=?> (#\C #\b #\B #\c), expects #f ==> ok
test #<subr char-ci>?> (#\C #\b #\B #\c), expects #f ==> ok
test #<subr char-ci>=?> (#\C #\b #\B #\c), expects #f ==> ok
test #<subr char-ci=?> (#\D #\c #\B #\a), expects #f ==> ok
test #<subr char-ci<?> (#\D #\c #\B #\a), expects #f ==> ok
test #<subr char-ci<=?> (#\D #\c #\B #\a), expects #f ==> ok
test #<subr char-ci>?> (#\D #\c #\B #\a), expects #t ==> ok
test #<subr char-ci>=?> (#\D #\c #\B #\a), expects #t ==> ok
test #<subr char-ci=?> (#\D #\c #\B #\c), expects #f ==> ok
test #<subr char-ci<?> (#\D #\c #\B #\c), expects #f ==> ok
test #<subr char-ci<=?> (#\D #\c #\B #\c), expects #f ==> ok
test #<subr char-ci>?> (#\D #\c #\B #\c), expects #f ==> ok
test #<subr char-ci>=?> (#\D #\c #\B #\c), expects #f ==> ok
<case mappings and properties>-------------------------------------------------
test case mapping i -> (upcase, downcase, titlecase, foldcase), expects (#\I #\i #\I #\i) ==> ok
test case mapping ß -> (upcase, downcase, titlecase, foldcase), expects (#\ß #\ß #\ß #\ß) ==> ok
test case mapping Σ -> (upcase, downcase, titlecase, foldcase), expects (#\Σ #\σ #\Σ #\σ) ==> ok
test case mapping σ -> (upcase, downcase, titlecase, foldcase), expects (#\Σ #\σ #\Σ #\σ) ==> ok
test case mapping ς -> (upcase, downcase, titlecase, foldcase), expects (#\Σ #\ς #\Σ #\σ) ==> ok
test case mapping µ -> (upcase, downcase, titlecase, foldcase), expects (#\Μ #\µ #\Μ #\μ) ==> ok
test case mapping ÿ -> (upcase, downcase, titlecase, foldcase), expects (#\Ÿ #\ÿ #\Ÿ #\ÿ) ==> ok
test case mapping DZ -> (upcase, downcase, titlecase, foldcase), expects (#\DZ #\dz #\Dz #\dz) ==> ok
test case mapping Dz -> (upcase, downcase, titlecase, foldcase), expects (#\DZ #\dz #\Dz #\dz) ==> ok
test case mapping dz -> (upcase, downcase, titlecase, foldcase), expects (#\DZ #\dz #\Dz #\dz) ==> ok
test (char-ci<? z Z), expects #f ==> ok
test (char-ci<? Z z), expects #f ==> ok
test (char-ci<? a Z), expects #t ==> ok
test (char-ci<? Z a), expects #f ==> ok
test (char-ci<=? z Z), expects #t ==> ok
test (char-ci<=? Z z), expects #t ==> ok
test (char-ci<=? a Z), expects #t ==> ok
test (char-ci<=? Z a), expects #f ==> ok
test (char-ci=? z a), expects #f ==> ok
test (char-ci=? z Z), expects #t ==> ok
test (char-ci=? ς σ), expects #t ==> ok
test (char-ci=? ι ͅ), expects #t ==> ok
test (char-ci>? z Z), expects #f ==> ok
test (char-ci>? Z z), expects #f ==> ok
test (char-ci>? a Z), expects #f ==> ok
test (char-ci>? Z a), expects #t ==> ok
test (char-ci>=? Z z), expects #t ==> ok
test (char-ci>=? z Z), expects #t ==> ok
test (char-ci>=? z Z), expects #t ==> ok
test (char-ci>=? a z), expects #f ==> ok
test (char-alphabetic? a), expects #t ==> ok
test (char-alphabetic? 1), expects #f ==> ok
test (char-numeric? 1), expects #t ==> ok
test (char-numeric? a), expects #f ==> ok
test (char-whitespace?  ), expects #t ==> ok
test (char-whitespace?  ), expects #t ==> ok
test (char-whitespace? a), expects #f ==> ok
test (char-upper-case? a), expects #f ==> ok
test (char-upper-case? A), expects #t ==> ok
test (char-upper-case? Σ), expects #t ==> ok
test (char-lower-case? a), expects #t ==> ok
test (char-lower-case? A), expects #f ==> ok
test (char-lower-case? σ), expects #t ==> ok
test (char-lower-case? ª), expects #t ==> ok
test (char-title-case? a), expects #f ==> ok
test (char-title-case? A), expects #f ==> ok
test (char-title-case? I), expects #f ==> ok
test (char-title-case? 〄), expects #f ==> ok
test (char-title-case? Dž), expects #t ==> ok
test (char-general-category a), expects Ll ==> ok
test (char-general-category  ), expects Zs ==> ok
test (char-general-category 􏿿), expects Cn ==> ok
passed.
Testing strings (basic) =======================================================
<builtins>---------------------------------------------------------------------
test string, expects "abcdefg" ==> ok
test string, expects "" ==> ok
test list->string, expects "abcdefg" ==> ok
test list->string, expects "" ==> ok
test make-string, expects "aaaaa" ==> ok
test make-string, expects "" ==> ok
test immutable, expects #t ==> ok
test immutable, expects #t ==> ok
test immutable, expects #f ==> ok
test immutable, expects #f ==> ok
test immutable, expects #f ==> ok
test string->list, expects (#\a #\b #\c #\d #\e #\f #\g) ==> ok
test string->list, expects (#\c #\d #\e #\f #\g) ==> ok
test string->list, expects (#\c #\d #\e) ==> ok
test string->list, expects (#\a) ==> ok
test string->list, expects () ==> ok
test string-copy, expects ("abcde" #f) ==> ok
test string-copy, expects "cde" ==> ok
test string-copy, expects "cd" ==> ok
test string-ref, expects #\b ==> ok
test string-set!, expects "abZde" ==> ok
test string-fill!, expects "ZZZZZZ" ==> ok
test string-fill!, expects "000ZZZ" ==> ok
test string-fill!, expects "000ZZ0" ==> ok
test string-join, expects "foo bar baz" ==> ok
test string-join, expects "foo::bar::baz" ==> ok
test string-join, expects "foo::bar::baz" ==> ok
test string-join, expects "" ==> ok
test string-join, expects "foo::bar::baz::" ==> ok
test string-join, expects "" ==> ok
test string-join, expects "::foo::bar::baz" ==> ok
test string-join, expects "" ==> ok
test string-join, expects "foo::bar::baz" ==> ok
test string-scan, expects 3 ==> ok
test string-scan-right, expects 3 ==> ok
test string-scan, expects 3 ==> ok
test string-scan-right, expects 3 ==> ok
test string-scan, expects 6 ==> ok
test string-scan-right, expects 6 ==> ok
test string-scan, expects 0 ==> ok
test string-scan-right, expects 0 ==> ok
test string-scan, expects 0 ==> ok
test string-scan-right, expects 6 ==> ok
test string-scan, expects "abc" ==> ok
test string-scan-right, expects "abc" ==> ok
test string-scan, expects "ghi" ==> ok
test string-scan-right, expects "ghi" ==> ok
test string-scan, expects ("abc" "defghi") ==> ok
test string-scan-right, expects ("abc" "defghi") ==> ok
test string-scan, expects ("abcdef" "ghi") ==> ok
test string-scan-right, expects ("abcdef" "ghi") ==> ok
test string-scan, expects ("abc" "ghi") ==> ok
test string-scan-right, expects ("abc" "ghi") ==> ok
test string-scan, expects 4 ==> ok
test string-scan-right, expects 4 ==> ok
test string-scan, expects 8 ==> ok
test string-scan-right, expects 8 ==> ok
test string-scan, expects 0 ==> ok
test string-scan-right, expects 0 ==> ok
test string-scan, expects 0 ==> ok
test string-scan-right, expects 8 ==> ok
test string-scan, expects "abcd" ==> ok
test string-scan-right, expects "abcd" ==> ok
test string-scan, expects "fghi" ==> ok
test string-scan-right, expects "fghi" ==> ok
test string-scan, expects ("abcd" "efghi") ==> ok
test string-scan-right, expects ("abcd" "efghi") ==> ok
test string-scan, expects ("abcde" "fghi") ==> ok
test string-scan-right, expects ("abcde" "fghi") ==> ok
test string-scan, expects ("abcd" "fghi") ==> ok
test string-scan-right, expects ("abcd" "fghi") ==> ok
test string-scan, expects 216 ==> ok
test string-scan-right, expects 216 ==> ok
test string-scan, expects 0 ==> ok
test string-scan-right, expects 365 ==> ok
test string-scan, expects 1 ==> ok
test string-scan-right, expects 8 ==> ok
test string-scan, expects "acadabra" ==> ok
test string-scan-right, expects "a" ==> ok
test string-scan, expects "a" ==> ok
test string-scan-right, expects "abracada" ==> ok
test string-scan, expects ("abr" "acadabra") ==> ok
test string-scan-right, expects ("abracadabr" "a") ==> ok
test string-scan, expects ("a" "bracadabra") ==> ok
test string-scan-right, expects ("abracada" "bra") ==> ok
test string-scan, expects ("a" "acadabra") ==> ok
test string-scan-right, expects ("abracada" "a") ==> ok
test string-scan, expects 0 ==> ok
test string-scan-right, expects 11 ==> ok
test string-scan, expects "abakjrgaker" ==> ok
test string-scan-right, expects "" ==> ok
test string-scan, expects "" ==> ok
test string-scan-right, expects "abakjrgaker" ==> ok
test string-scan, expects ("" "abakjrgaker") ==> ok
test string-scan-right, expects ("abakjrgaker" "") ==> ok
test string-scan, expects ("" "abakjrgaker") ==> ok
test string-scan-right, expects ("abakjrgaker" "") ==> ok
test string-scan, expects ("" "abakjrgaker") ==> ok
test string-scan-right, expects ("abakjrgaker" "") ==> ok
test string-scan, expects 3 ==> ok
test string-scan-right, expects 3 ==> ok
test string-scan, expects 3 ==> ok
test string-scan-right, expects 3 ==> ok
test string-scan, expects #*"ghi" ==> ok
test string-scan-right, expects #*"ghi" ==> ok
test string-scan, expects #*"abc" ==> ok
test string-scan-right, expects #*"abc" ==> ok
test string-scan, expects (#*"abcdef" #*"ghi") ==> ok
test string-scan-right, expects (#*"abcdef" #*"ghi") ==> ok
test string-scan, expects (#*"abc" #*"defghi") ==> ok
test string-scan-right, expects (#*"abc" #*"defghi") ==> ok
test string-scan, expects (#*"abc" #*"ghi") ==> ok
test string-scan-right, expects (#*"abc" #*"ghi") ==> ok
test string-scan, expects (#*"abc" #*"ghi") ==> ok
test string-scan-right, expects (#*"abc" #*"ghi") ==> ok
test string-scan, expects (#*"abcd" #*"fghi") ==> ok
test string-scan-right, expects (#*"abcd" #*"fghi") ==> ok
<string-split>-----------------------------------------------------------------
test string-split (char), expects ("aa" "bbb" "c") ==> ok
test string-split (char), expects ("aa" "bbb" "c" "") ==> ok
test string-split (char), expects ("aa" "bbb" "c" "" "") ==> ok
test string-split (char), expects ("aa") ==> ok
test string-split (char), expects ("") ==> ok
test string-split (char), expects ("" "") ==> ok
test string-split (1-char string), expects ("aa" "bbb" "c") ==> ok
test string-split (string), expects ("aa" "bbb" "c*c") ==> ok
test string-split (string), expects ("aa**bbb**c*c") ==> ok
test string-split (string), expects ("aa" "bbb" "c*c" "") ==> ok
test string-split (string), expects ("") ==> ok
test string-split (string), expects ("" "") ==> ok
test string-split (regexp), expects ("aa" "bbb" "c" "c") ==> ok
test string-split (regexp), expects ("aa" "bbb" "-c-c") ==> ok
test string-split (regexp), expects ("" "aa" "bbb" "c" "c" "") ==> ok
test string-split (regexp), expects ("--" "--" "---" "-" "-") ==> ok
test string-split (regexp), expects ("--aa--bbb---c-c-") ==> ok
test string-split (regexp), expects #<error> ==> ok
test string-split (charset), expects ("aa" "bbb" "c" "d") ==> ok
test string-split (charset), expects ("" "---" "***" "&" "") ==> ok
test string-split (charset), expects ("") ==> ok
test string-split (charset), expects ("" "") ==> ok
test string-split (predicate), expects ("" "---" "***" "&" "") ==> ok
<incomplete strings>-----------------------------------------------------------
test string-incomplete?, expects #f ==> ok
test string-incomplete?, expects #t ==> ok
test string-incomplete?, expects #f ==> ok
test string-incomplete?, expects #t ==> ok
test string-complete->incomplete, expects #*"xyz" ==> ok
test string-complete->incomplete, expects #*"xyz" ==> ok
test string-incomplete->complete, expects "xyz" ==> ok
test string-incomplete->complete, expects "xyz" ==> ok
test string=?, expects #t ==> ok
test string-byte-ref, expects 98 ==> ok
test string-byte-ref, expects 0 ==> ok
test string-append, expects #*"abcdef" ==> ok
test string-append, expects #*"abcdef" ==> ok
test string-append, expects #*"abcdef" ==> ok
test string-append, expects #*"abcdef" ==> ok
test string-join, expects #*"a:b:c" ==> ok
test string-join, expects #*"a:b:c" ==> ok
test string-set!, expects #*"abQde" ==> ok
test string-byte-set!, expects #*"abQde" ==> ok
test string-byte-set!, expects #*"abQde" ==> ok
test string-byte-set!, expects #*"\x01\x81\x82" ==> ok
test substring, expects #*"ab" ==> ok
<string-pointer>---------------------------------------------------------------
test make-string-pointer, expects #t ==> ok
test string-pointer-next!, expects #\a ==> ok
test string-pointer-next!, expects #\b ==> ok
test string-pointer-prev!, expects #\b ==> ok
test string-pointer-prev!, expects #\a ==> ok
test string-pointer-prev!, expects #t ==> ok
test string-pointer-index, expects 0 ==> ok
test string-pointer-index, expects 7 ==> ok
test string-pointer-substring, expects ("abcdefg" "") ==> ok
test string-pointer-substring, expects ("abcd" "efg") ==> ok
test string-pointer-substring, expects ("" "abcdefg") ==> ok
test string-pointer-substring, expects ("" "") ==> ok
test make-string-pointer (bound), expects #t ==> ok
test string-pointer-next! (bound), expects #\d ==> ok
test string-pointer-next! (bound), expects #\e ==> ok
test string-pointer-next! (bound), expects #t ==> ok
test string-pointer-prev! (bound), expects #\e ==> ok
test string-pointer-prev! (bound), expects #\d ==> ok
test string-pointer-prev! (bound), expects #\c ==> ok
test string-pointer-prev! (bound), expects #t ==> ok
test string-pointer-next! (bound), expects #\c ==> ok
test string-pointer-substring (bound), expects ("c" "de") ==> ok
<input string port>------------------------------------------------------------
test read-char, expects #\a ==> ok
test peek-char, expects #\b ==> ok
test read-byte, expects 98 ==> ok
test read-byte from ungotten buffer, expects 99 ==> ok
test read-block using ungotten buffer, expects #*"d" ==> ok
test read-block using ungotten buffer, expects #*"efg" ==> ok
test termination, expects #t ==> ok
test termination, expects #t ==> ok
test termination, expects #t ==> ok
test get-remaining-input-string, expects "defg" ==> ok
test get-remaining-input-string, expects "" ==> ok
test get-remaining-input-string, expects "cdefg" ==> ok
test get-remaining-input-string, expects "cdefg" ==> ok
test line continuation, expects "abcdefgh" ==> ok
test line continuation, expects "abcdefgh2" ==> ok
test line continuation, expects "abcdefgh3" ==> ok
test line continuation, expects "ABCDEFGH" ==> ok
test line continuation, expects "ABCDEFGH2" ==> ok
test line continuation, expects "ABCDEFGH3" ==> ok
test line continuation, expects "ABCDefgh" ==> ok
test line continuation, expects "ABCDefgh2" ==> ok
test line continuation, expects "ABCDefgh3" ==> ok
test line continuation, expects "0123 4567" ==> ok
test line continuation, expects "0123 4567" ==> ok
test line continuation, expects "0123-4567" ==> ok
test line continuation (invalid), expects #<error> ==> ok
test line continuation (extended chars), expects "abc def1" ==> ok
test line continuation (extended chars), expects "abc def2" ==> ok
test line continuation (extended chars), expects "abc def3" ==> ok
test line continuation (extended chars), expects "ABC DEF1" ==> ok
test line continuation (extended chars), expects "ABC DEF2" ==> ok
test line continuation (extended chars), expects "uvw xyz1" ==> ok
test read-line (nullstr), expects () ==> ok
test read-line (NL), expects ("") ==> ok
test read-line (CR), expects ("") ==> ok
test read-line (CRNL), expects ("") ==> ok
test read-line (mix), expects ("ab" "cd" "" "ef" "g") ==> ok
test read-line (ungotten), expects ("ab" "cd") ==> ok
<output string port>-----------------------------------------------------------
test string-port (0), expects "" ==> ok
test string-port (0), expects "" ==> ok
test string-port (small-1), expects #t ==> ok
test string-port (small-1), expects #t ==> ok
test string-port (small-1), expects #t ==> ok
test string-port (small-1), expects #t ==> ok
test string-port (small), expects #t ==> ok
test string-port (small), expects #t ==> ok
test string-port (small), expects #t ==> ok
test string-port (small), expects #t ==> ok
test string-port (small+1), expects #t ==> ok
test string-port (small+1), expects #t ==> ok
test string-port (small+1), expects #t ==> ok
test string-port (small+1), expects #t ==> ok
test string-port (mid-1), expects #t ==> ok
test string-port (mid-1), expects #t ==> ok
test string-port (mid-1), expects #t ==> ok
test string-port (mid-1), expects #t ==> ok
test string-port (mid), expects #t ==> ok
test string-port (mid), expects #t ==> ok
test string-port (mid), expects #t ==> ok
test string-port (mid), expects #t ==> ok
test string-port (mid+1), expects #t ==> ok
test string-port (mid+1), expects #t ==> ok
test string-port (mid+1), expects #t ==> ok
test string-port (mid+1), expects #t ==> ok
test string-port (large), expects #t ==> ok
test string-port (large), expects #t ==> ok
test string-port (large), expects #t ==> ok
test string-port (large), expects #t ==> ok
test string-port (large), expects #t ==> ok
test string-port (large), expects #t ==> ok
<string interpolation>---------------------------------------------------------
test string interpolation, expects "string interpolation" ==> ok
test string interpolation, expects "string interpolation" ==> ok
test string interpolation, expects "string interpolation" ==> ok
passed.
Testing symbols and keywords ==================================================
<symbols>----------------------------------------------------------------------
test symbol->string, expects "foo" ==> ok
test string->symbol, expects foo ==> ok
test gensym, expects (#t #t #f) ==> ok
test interned?, expects #t ==> ok
test interned?, expects #f ==> ok
test symbol reader, expects foo ==> ok
test symbol reader, expects foo ==> ok
test symbol reader escaped, expects foo ==> ok
test symbol reader escaped, expects foo ==> ok
test symbol reader escaped, expects |foo bar| ==> ok
test symbol writer, expects foo ==> ok
test symbol writer, expects |foo bar| ==> ok
test symbol reader uninterned, expects "foo" ==> ok
test symbol reader uninterned, expects "foo bar" ==> ok
test symbol reader uninterned, expects #f ==> ok
test symbol writer uninterned, expects "#:foo" ==> ok
test symbol writer uninterned, expects "#:|foo bar|" ==> ok
test symbol writer uninterned, expects "(#0=#:foo #0#)" ==> ok
test symbol writer uninterned, expects "(#:foo #:foo)" ==> ok
test prefix, expects bar ==> ok
test prefix, expects #f ==> ok
<keywords>---------------------------------------------------------------------
test reader, expects #t ==> ok
test reader, expects #t ==> ok
test reader, expects #t ==> ok
test reader, expects #t ==> ok
test reader, expects #t ==> ok
test keyword?, expects #f ==> ok
test make-keyword, expects #t ==> ok
test keyword->string, expects "abc" ==> ok
test keyword->string, expects "a b" ==> ok
test writer, expects ":abc" ==> ok
test writer, expects ":|a b c|" ==> ok
test writer, expects ":" ==> ok
test writer, expects "::" ==> ok
test writer, expects ":3" ==> ok
test writer, expects ":-i" ==> ok
test eq?, expects #t ==> ok
test eq?, expects #f ==> ok
test eqv?, expects #t ==> ok
test eqv?, expects #f ==> ok
<get-keyword>------------------------------------------------------------------
test get-keyword, expects "foo" ==> ok
test get-keyword, expects 33 ==> ok
test get-keyword, expects ook ==> ok
test get-keyword, expects #<error> ==> ok
test get-keyword, expects 88 ==> ok
test get-keyword, expects #<error> ==> ok
test get-keyword*, expects "foo" ==> ok
test get-keyword*, expects 33 ==> ok
test get-keyword*, expects ook ==> ok
test get-keyword*, expects ook ==> ok
test get-keyword*, expects #<error> ==> ok
test get-keyword*, expects 88 ==> ok
test get-keyword*, expects #<error> ==> ok
<delete-keyword>---------------------------------------------------------------
test delete-keyword :b (:a 3 :b 5), expects (:a 3) ==> ok
test delete-keyword! :b (:a 3 :b 5), expects ((:a 3) (:a 3)) ==> ok
test delete-keywords (:b) (:a 3 :b 5), expects (:a 3) ==> ok
test delete-keywords! (:b) (:a 3 :b 5), expects ((:a 3) (:a 3)) ==> ok
test delete-keyword :a (:a 3 :b 5), expects (:b 5) ==> ok
test delete-keyword! :a (:a 3 :b 5), expects ((:b 5) (:a 3 :b 5)) ==> ok
test delete-keywords (:a) (:a 3 :b 5), expects (:b 5) ==> ok
test delete-keywords! (:a) (:a 3 :b 5), expects ((:b 5) (:a 3 :b 5)) ==> ok
test delete-keyword :c (:a 3 :b 5), expects (:a 3 :b 5) ==> ok
test delete-keyword! :c (:a 3 :b 5), expects ((:a 3 :b 5) (:a 3 :b 5)) ==> ok
test delete-keywords (:c) (:a 3 :b 5), expects (:a 3 :b 5) ==> ok
test delete-keywords! (:c) (:a 3 :b 5), expects ((:a 3 :b 5) (:a 3 :b 5)) ==> ok
test delete-keyword :a (:a 3), expects () ==> ok
test delete-keyword! :a (:a 3), expects (() (:a 3)) ==> ok
test delete-keywords (:a) (:a 3), expects () ==> ok
test delete-keywords! (:a) (:a 3), expects (() (:a 3)) ==> ok
test delete-keyword :a (), expects () ==> ok
test delete-keyword! :a (), expects (() ()) ==> ok
test delete-keywords (:a) (), expects () ==> ok
test delete-keywords! (:a) (), expects (() ()) ==> ok
test delete-keyword :a (:a 3 :a 5), expects () ==> ok
test delete-keyword! :a (:a 3 :a 5), expects (() (:a 3 :a 5)) ==> ok
test delete-keywords (:a) (:a 3 :a 5), expects () ==> ok
test delete-keywords! (:a) (:a 3 :a 5), expects (() (:a 3 :a 5)) ==> ok
test delete-keyword :b (:a 3 :b 4 :b 5), expects (:a 3) ==> ok
test delete-keyword! :b (:a 3 :b 4 :b 5), expects ((:a 3) (:a 3)) ==> ok
test delete-keywords (:b) (:a 3 :b 4 :b 5), expects (:a 3) ==> ok
test delete-keywords! (:b) (:a 3 :b 4 :b 5), expects ((:a 3) (:a 3)) ==> ok
test delete-keyword :a (:a 3 :b 4 :a 5), expects (:b 4) ==> ok
test delete-keyword! :a (:a 3 :b 4 :a 5), expects ((:b 4) (:a 3 :b 4)) ==> ok
test delete-keywords (:a) (:a 3 :b 4 :a 5), expects (:b 4) ==> ok
test delete-keywords! (:a) (:a 3 :b 4 :a 5), expects ((:b 4) (:a 3 :b 4)) ==> ok
test delete-keyword :b (:a 3 :b 4 :a 5), expects (:a 3 :a 5) ==> ok
test delete-keyword! :b (:a 3 :b 4 :a 5), expects ((:a 3 :a 5) (:a 3 :a 5)) ==> ok
test delete-keywords (:b) (:a 3 :b 4 :a 5), expects (:a 3 :a 5) ==> ok
test delete-keywords! (:b) (:a 3 :b 4 :a 5), expects ((:a 3 :a 5) (:a 3 :a 5)) ==> ok
test delete-keywords (:a :b) (:a 3 :b 4), expects () ==> ok
test delete-keywords! (:a :b) (:a 3 :b 4), expects (() (:a 3 :b 4)) ==> ok
test delete-keywords (:a :c) (:a 3 :b 4), expects (:b 4) ==> ok
test delete-keywords! (:a :c) (:a 3 :b 4), expects ((:b 4) (:a 3 :b 4)) ==> ok
test delete-keywords (:c :b) (:a 3 :b 4), expects (:a 3) ==> ok
test delete-keywords! (:c :b) (:a 3 :b 4), expects ((:a 3) (:a 3)) ==> ok
test delete-keywords () (:a 3 :b 4), expects (:a 3 :b 4) ==> ok
test delete-keywords! () (:a 3 :b 4), expects ((:a 3 :b 4) (:a 3 :b 4)) ==> ok
test delete-keywords (:a :c) (:a 3 :b 4 :c 5), expects (:b 4) ==> ok
test delete-keywords! (:a :c) (:a 3 :b 4 :c 5), expects ((:b 4) (:a 3 :b 4)) ==> ok
test delete-keywords (:b :c) (:a 3 :b 4 :c 5), expects (:a 3) ==> ok
test delete-keywords! (:b :c) (:a 3 :b 4 :c 5), expects ((:a 3) (:a 3)) ==> ok
test delete-keywords (:a :b) (:a 3 :b 4 :c 5), expects (:c 5) ==> ok
test delete-keywords! (:a :b) (:a 3 :b 4 :c 5), expects ((:c 5) (:a 3 :b 4 :c 5)) ==> ok
passed.
Testing hash tables ===========================================================
<eq?-hash>---------------------------------------------------------------------
test make-hash-table, expects #t ==> ok
test hash-table-type, expects eq? ==> ok
test a => 8, expects 8 ==> ok
test b => non, expects #t ==> ok
test b => error, expects #<error> ==> ok
test b => "b", expects "b" ==> ok
test c => #C, expects #\C ==> ok
test c => #c, expects #\c ==> ok
test e => 10, expects 10 ==> ok
test f => 1, expects 3 ==> ok
test eq? test, expects 7 ==> ok
test hash-table-values(1), expects #t ==> ok
test delete!, expects (#t #f #f) ==> ok
test clear!, expects () ==> ok
<eqv?-hash>--------------------------------------------------------------------
test make-hash-table, expects #t ==> ok
test hash-table-type, expects eqv? ==> ok
test a => 8, expects 8 ==> ok
test b => non, expects #t ==> ok
test b => error, expects #<error> ==> ok
test b => "b", expects "b" ==> ok
test 2.0 => #C, expects #\C ==> ok
test 2.0 => #c, expects #\c ==> ok
test 87592876592374659237845692374523694756 => 0, expects 0 ==> ok
test 87592876592374659237845692374523694756 => -1, expects -1 ==> ok
test 377/120 => pi, expects pi ==> ok
test 377/120 => PI, expects PI ==> ok
test eqv? test, expects 7 ==> ok
test hash-table-values(2), expects #t ==> ok
test delete!, expects #f ==> ok
test copy, expects #t ==> ok
<equal?-hash>------------------------------------------------------------------
test make-hash-table, expects #t ==> ok
test hash-table-type, expects equal? ==> ok
test a => 8, expects 8 ==> ok
test b => non, expects #t ==> ok
test b => error, expects #<error> ==> ok
test b => "b", expects "b" ==> ok
test 2.0 => #C, expects #\C ==> ok
test 2.0 => #c, expects #\c ==> ok
test 87592876592374659237845692374523694756 => 0, expects 0 ==> ok
test 87592876592374659237845692374523694756 => -1, expects -1 ==> ok
test e => "e", expects "E" ==> ok
test equal? test, expects 6 ==> ok
test equal? test, expects 7 ==> ok
test equal? test, expects 8 ==> ok
test hash-table-values(3), expects #t ==> ok
test delete!, expects #f ==> ok
<string?-hash>-----------------------------------------------------------------
test make-hash-table, expects #t ==> ok
test hash-table-type, expects string=? ==> ok
test "a" => 8, expects 8 ==> ok
test "b" => non, expects #t ==> ok
test "b" => non, expects #<error> ==> ok
test "b" => "b", expects "b" ==> ok
test string=? test, expects 3 ==> ok
test "e" => 9, expects 9 ==> ok
test hash-table-values(4), expects #t ==> ok
test delete!, expects #f ==> ok
<iterators>--------------------------------------------------------------------
test hash-table, expects (a b c d) ==> ok
test hash-table-map, expects ((a . 3) (b . 4) (c . 8) (d . 10)) ==> ok
test hash-table-for-each, expects ((a . 3) (b . 4) (c . 8) (d . 10)) ==> ok
test hash-table-fold, expects ((a . 3) (b . 4) (c . 8) (d . 10)) ==> ok
test alist->hash-table, expects (a b) ==> ok
test hash-table->alist, expects (("a" . 3) ("b" . 5)) ==> ok
testing bindings in #<module gauche.hashutil> ... ok
passed.
Testing builtin list operations ===============================================
<iota>-------------------------------------------------------------------------
test iota, expects (0 1 2 3 4) ==> ok
test iota, expects (5 6 7 8 9) ==> ok
test iota, expects (10 20 30 40 50) ==> ok
test iota, expects (1.0 1.5 2.0 2.5 3.0) ==> ok
<append and reverse>-----------------------------------------------------------
test append, expects (1 2 3 4 5) ==> ok
test append, expects (1 2 3 . 5) ==> ok
test append!, expects (1 2 3 4 5) ==> ok
test append!, expects (1 2 3 . 5) ==> ok
test reverse, expects (5 4 3 2 1) ==> ok
test reverse, expects () ==> ok
test reverse!, expects (5 4 3 2 1) ==> ok
test reverse!, expects () ==> ok
test reverse 2args, expects (1 2 3 4 5) ==> ok
test reverse 2args, expects (1 2 3 4 . 5) ==> ok
test reverse! 2args, expects (1 2 3 4 5) ==> ok
test reverse! 2args, expects (1 2 3 4 . 5) ==> ok
<folding>----------------------------------------------------------------------
test fold, expects 55 ==> ok
test fold, expects (e d c b a) ==> ok
test fold, expects 3 ==> ok
test fold, expects (c 3 b 2 a 1) ==> ok
test fold-right, expects (1 2 3 4 5) ==> ok
test fold-right, expects (2 4 6) ==> ok
test fold-right, expects (a 1 b 2 c 3) ==> ok
test fold-left, expects (((z . a) . b) . c) ==> ok
test fold-left, expects (c b a . z) ==> ok
test fold-left, expects 21 ==> ok
test fold-left, expects (((z a A) b B) c C) ==> ok
<filtering>--------------------------------------------------------------------
test filter-map, expects (1 9 49) ==> ok
test filter, expects (0 8 8 -4) ==> ok
test remove, expects (7 43) ==> ok
test filter!, expects (0 8 8 -4) ==> ok
test remove!, expects (7 43) ==> ok
<searching>--------------------------------------------------------------------
test find, expects 4 ==> ok
test find, expects #f ==> ok
test find-tail, expects (-8 -5 0 0) ==> ok
test find-tail, expects #f ==> ok
test member, expects #f ==> ok
test member, expects (2.0 3.0) ==> ok
test member, expects ("b" "c") ==> ok
test member, expects ("b" "c") ==> ok
test member, expects ("b" "c") ==> ok
test member, expects ("b" "c") ==> ok
test delete, expects (b c d e) ==> ok
test delete, expects (b c d e) ==> ok
test delete, expects (b c d e) ==> ok
test delete, expects (b c d e) ==> ok
test delete, expects (b c d e) ==> ok
test delete, expects (b c d e . f) ==> ok
test delete, expects (2.0 3.0 4.0 5.0) ==> ok
test delete, expects ("b" "c" "d" "e") ==> ok
test delete, expects ("b" "c" "d" "e") ==> ok
test delete, expects ("b" "c" "d" "e") ==> ok
test delete!, expects (b c d e) ==> ok
test delete!, expects (b c d e) ==> ok
test delete!, expects (b c d e) ==> ok
test delete!, expects (b c d e) ==> ok
test delete!, expects (b c d e) ==> ok
test delete!, expects (b c d e . f) ==> ok
test delete!, expects (2.0 3.0 4.0 5.0) ==> ok
test delete!, expects ("b" "c" "d" "e") ==> ok
test delete!, expects ("b" "c" "d" "e") ==> ok
test delete!, expects ("b" "c" "d" "e") ==> ok
test delete-duplicates, expects (a b c d e) ==> ok
test delete-duplicates, expects (a b c d e) ==> ok
test delete-duplicates, expects (a b c d . e) ==> ok
test delete-duplicates, expects (1.0 2.0 3.0 4.0 5.0) ==> ok
test delete-duplicates, expects ("a" "b" "c" "d" "e") ==> ok
test delete-duplicates, expects ("a" "b" "c" "d" "e") ==> ok
test delete-duplicates, expects ("A" "b" "c" "d" "e") ==> ok
test delete-duplicates!, expects (a b c d e) ==> ok
test delete-duplicates!, expects (a b c d e) ==> ok
test delete-duplicates!, expects (1.0 2.0 3.0 4.0 5.0) ==> ok
test delete-duplicates!, expects ("a" "b" "c" "d" "e") ==> ok
test delete-duplicates!, expects ("a" "b" "c" "d" "e") ==> ok
test delete-duplicates!, expects ("A" "b" "c" "d" "e") ==> ok
test any, expects #f ==> ok
test any, expects #f ==> ok
test any, expects #t ==> ok
test any, expects 1 ==> ok
test any, expects 1 ==> ok
test any, expects 1 ==> ok
test any, expects 1 ==> ok
test any, expects #f ==> ok
test every, expects #t ==> ok
test every, expects #t ==> ok
test every, expects #f ==> ok
test every, expects #f ==> ok
test every, expects 2 ==> ok
test every, expects 2 ==> ok
test every, expects 1 ==> ok
test every, expects #t ==> ok
<take and drop>----------------------------------------------------------------
test take, expects (a b) ==> ok
test drop, expects (c d e) ==> ok
test take, expects (1 2) ==> ok
test drop, expects (3 . d) ==> ok
test take, expects (1 2 3) ==> ok
test drop, expects d ==> ok
test take-right, expects (d e) ==> ok
test drop-right, expects (a b c) ==> ok
test take-right, expects (2 3 . d) ==> ok
test drop-right, expects (1) ==> ok
test take-right, expects d ==> ok
test drop-right, expects (1 2 3) ==> ok
test take!, expects (1 2) ==> ok
test drop-right!, expects (1 2) ==> ok
test split-at, expects ((a b c) (d e f g h)) ==> ok
test split-at!, expects ((a b c) (d e f g h)) ==> ok
test split-at* (normal), expects ((a b c) (d)) ==> ok
test split-at* (boundary), expects (() (a b c d)) ==> ok
test split-at* (boundary), expects ((a b c d) ()) ==> ok
test split-at* (error), expects #<error> ==> ok
test split-at* (shorten), expects ((a b c d) ()) ==> ok
test split-at* (fill), expects ((a b c d #f #f) ()) ==> ok
test split-at* (fill), expects ((a b c d z z) ()) ==> ok
test take* (normal), expects (a b c) ==> ok
test take* (boundary), expects () ==> ok
test take* (boundary), expects (a b c d) ==> ok
test take* (error), expects #<error> ==> ok
test take* (shorten), expects (a b c d) ==> ok
test take* (fill), expects (a b c d #f #f) ==> ok
test take* (fill), expects (a b c d z z) ==> ok
test drop* (normal), expects (c d) ==> ok
test drop* (boundary), expects (a b c d) ==> ok
test drop* (boundary), expects () ==> ok
test drop* (error), expects #<error> ==> ok
test drop* (past), expects () ==> ok
test take-right* (normal), expects (b c d) ==> ok
test take-right* (boundary), expects () ==> ok
test take-right* (boundary), expects (a b c d) ==> ok
test take-right* (error), expects #<error> ==> ok
test take-right* (shorten), expects (a b c d) ==> ok
test take-right* (fill), expects (z z a b c d) ==> ok
test drop-right* (normal), expects (a b c) ==> ok
test drop-right* (boundary), expects () ==> ok
test drop-right* (boundary), expects (a b c d) ==> ok
test drop-right* (error), expects #<error> ==> ok
test drop-right* (past), expects () ==> ok
test slices (normal), expects ((0 1 2 3) (4 5 6 7) (8 9 10 11) (12 13 14 15)) ==> ok
test slices (boundary), expects () ==> ok
test slices (short), expects ((0 1 2 3) (4 5 6 7) (8 9 10 11) (12)) ==> ok
test slices (short), expects ((0 1)) ==> ok
test slices (fill), expects ((0 1 2 3) (4 5 6 7) (8 9 10 11) (12 #f #f #f)) ==> ok
test slices (fill), expects ((0 1 2 3) (4 5 6 7) (8 9 10 11) (12 -1 -1 -1)) ==> ok
test intersperse, expects (1 + 2 + 3) ==> ok
test intersperse, expects (1 + 2) ==> ok
test intersperse, expects (1) ==> ok
test intersperse, expects () ==> ok
test assq, expects (a 1) ==> ok
test assq, expects #f ==> ok
test assq, expects #f ==> ok
test assv, expects (b 2) ==> ok
test assv, expects #f ==> ok
test assv, expects #f ==> ok
test assoc, expects ((a)) ==> ok
test assoc, expects ("a") ==> ok
test assoc, expects ("a") ==> ok
test acons, expects ((1 . 2) . 3) ==> ok
test alist-copy, expects ((a 1) (a 2)) ==> ok
test alist-delete, expects ((a 1) (b 2) (c 3)) ==> ok
test alist-delete, expects ((b 2) (c 3)) ==> ok
test alist-delete, expects ((a 1) (c 3)) ==> ok
test alist-delete, expects ((a 1) (b 2)) ==> ok
test alist-delete!, expects ((a 1) (b 2) (c 3)) ==> ok
test alist-delete!, expects ((b 2) (c 3)) ==> ok
test alist-delete!, expects (z (b 2) (c 3)) ==> ok
test alist-delete!, expects (z (b 2) (c 3)) ==> ok
test alist-delete!, expects ((a 1) (c 3)) ==> ok
test alist-delete!, expects ((a 1) (b 2)) ==> ok
test rassoc, expects (5 . "b") ==> ok
test rassq, expects (5 . b) ==> ok
test rassv, expects ("b" . 5) ==> ok
test assoc-ref, expects 5 ==> ok
test assoc-ref, expects 7 ==> ok
test assq-ref, expects 5 ==> ok
test assq-ref, expects 7 ==> ok
test assv-ref, expects b ==> ok
test assv-ref, expects c ==> ok
test rassoc-ref, expects 5 ==> ok
test rassoc-ref, expects 7 ==> ok
test rassq-ref, expects 5 ==> ok
test rassq-ref, expects #f ==> ok
test rassv-ref, expects b ==> ok
test rassv-ref, expects #f ==> ok
test assoc-set!, expects (("a" . 3) ("b" . 9)) ==> ok
test assoc-set!, expects (("c" . 9) ("a" . 3) ("b" . 5)) ==> ok
test assq-set!, expects ((a . 3) (b . 9)) ==> ok
test assq-set!, expects ((c . 9) (a . 3) (b . 5)) ==> ok
test assv-set!, expects ((3 . a) (5 . c)) ==> ok
test assv-set!, expects ((9 . c) (3 . a) (5 . b)) ==> ok
<monotonic-merge>--------------------------------------------------------------
test monotonic-merge, expects (menu choice-widget popup-mixin object) ==> ok
test monotonic-merge, expects (pedal-wheel-boat engineless small-catamaran small-multihull day-boat wheel-boat boat object) ==> ok
test monotonic-merge, expects #f ==> ok
passed.
Testing treemap ===============================================================
test make-tree-map, expects #t ==> ok
test tree-map-get, expects #<error> ==> ok
test tree-map-get, expects not-found ==> ok
test tree-map-get, expects #<error> ==> ok
test tree-map-put!, expects #<error> ==> ok
test tree-map-put!, expects "0" ==> ok
test tree-map-put!, expects ("0" "1") ==> ok
test tree-map-put!, expects bar ==> ok
test tree-map-fold, expects (2 bar 1 "1" 0 "0") ==> ok
test tree-map-fold-right, expects (0 "0" 1 "1" 2 bar) ==> ok
test tree-map-delete! (exiting key), expects (#t not-found) ==> ok
test tree-map-delete! (non-existing key), expects #f ==> ok
test tree-map-delete!, expects no-error ==> ok
test tree-map->alist, expects () ==> ok
test tree-map->alist, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test alist->tree-map, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test tree-map-empty?, expects #f ==> ok
test tree-map-empty?, expects #t ==> ok
test tree-map-empty?, expects #<error> ==> ok
test tree-map-exists?, expects (#t #f) ==> ok
test tree-map-num-entries, expects (0 1 0) ==> ok
test tree-map-push!, expects (bar foo) ==> ok
test tree-map-pop!, expects (foo bar) ==> ok
test tree-map-update!, expects 2 ==> ok
test make-tree-map, expects #t ==> ok
test tree-map-get, expects #<error> ==> ok
test tree-map-get, expects not-found ==> ok
test tree-map-get, expects #<error> ==> ok
test tree-map-put!, expects #<error> ==> ok
test tree-map-put!, expects "0" ==> ok
test tree-map-put!, expects ("0" "1") ==> ok
test tree-map-put!, expects bar ==> ok
test tree-map-fold, expects (2 bar 1 "1" 0 "0") ==> ok
test tree-map-fold-right, expects (0 "0" 1 "1" 2 bar) ==> ok
test tree-map-delete! (exiting key), expects (#t not-found) ==> ok
test tree-map-delete! (non-existing key), expects #f ==> ok
test tree-map-delete!, expects no-error ==> ok
test tree-map->alist, expects () ==> ok
test tree-map->alist, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test alist->tree-map, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test tree-map-empty?, expects #f ==> ok
test tree-map-empty?, expects #t ==> ok
test tree-map-empty?, expects #<error> ==> ok
test tree-map-exists?, expects (#t #f) ==> ok
test tree-map-num-entries, expects (0 1 0) ==> ok
test tree-map-push!, expects (bar foo) ==> ok
test tree-map-pop!, expects (foo bar) ==> ok
test tree-map-update!, expects 2 ==> ok
test make-tree-map, expects #t ==> ok
test tree-map-get, expects #<error> ==> ok
test tree-map-get, expects not-found ==> ok
test tree-map-get, expects #<error> ==> ok
test tree-map-put!, expects #<error> ==> ok
test tree-map-put!, expects "0" ==> ok
test tree-map-put!, expects ("0" "1") ==> ok
test tree-map-put!, expects bar ==> ok
test tree-map-fold, expects (2 bar 1 "1" 0 "0") ==> ok
test tree-map-fold-right, expects (0 "0" 1 "1" 2 bar) ==> ok
test tree-map-delete! (exiting key), expects (#t not-found) ==> ok
test tree-map-delete! (non-existing key), expects #f ==> ok
test tree-map-delete!, expects no-error ==> ok
test tree-map->alist, expects () ==> ok
test tree-map->alist, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test alist->tree-map, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test tree-map-empty?, expects #f ==> ok
test tree-map-empty?, expects #t ==> ok
test tree-map-empty?, expects #<error> ==> ok
test tree-map-exists?, expects (#t #f) ==> ok
test tree-map-num-entries, expects (0 1 0) ==> ok
test tree-map-push!, expects (bar foo) ==> ok
test tree-map-pop!, expects (foo bar) ==> ok
test tree-map-update!, expects 2 ==> ok
test tree-map-min, expects (0 . "0") ==> ok
test tree-map-max, expects (2 . "2") ==> ok
test tree-map-min, expects #<error> ==> ok
test tree-map-max, expects #<error> ==> ok
test tree-map-keys, expects (0 1 2) ==> ok
test tree-map-values, expects ("0" "1" "2") ==> ok
test tree-map-copy, expects #t ==> ok
test tree-map-pop-min!, expects ((0 . "0") (1 . "1")) ==> ok
test tree-map-pop-max!, expects ((2 . "2") (1 . "1")) ==> ok
test insertion case 0, expects #t ==> ok
test insetrion case 2, expects #t ==> ok
test insertion case 3&1, expects #t ==> ok
test insertion case 5b, expects #t ==> ok
test insertion case 5a, expects #t ==> ok
test deletion case 1, expects #t ==> ok
test deletion case 8a, expects #t ==> ok
test deletion case8b, expects #t ==> ok
test deletion case6, expects #t ==> ok
test deletion case2, expects #t ==> ok
test deletion case5, expects #t ==> ok
test deletion case7a, expects #t ==> ok
test deletion case4b, expects #t ==> ok
test deletion case3, expects #t ==> ok
test insertion case4a, expects #t ==> ok
test deletion case4a, expects #t ==> ok
test insertion case4b, expects #t ==> ok
test tree-map-floor (am), expects ("aloha" "love") ==> ok
test tree-map-floor-key (am), expects "aloha" ==> ok
test tree-map-floor-value (am), expects "love" ==> ok
test tree-map-ceiling (am), expects ("aoao" "page") ==> ok
test tree-map-ceiling-key (am), expects "aoao" ==> ok
test tree-map-ceiling-value (am), expects "page" ==> ok
test tree-map-predecessor (am), expects ("aloha" "love") ==> ok
test tree-map-predecessor-key (am), expects "aloha" ==> ok
test tree-map-predecessor-value (am), expects "love" ==> ok
test tree-map-successor (am), expects ("aoao" "page") ==> ok
test tree-map-successor-key (am), expects "aoao" ==> ok
test tree-map-successor-value (am), expects "page" ==> ok
test tree-map-floor (aoao), expects ("aoao" "page") ==> ok
test tree-map-floor-key (aoao), expects "aoao" ==> ok
test tree-map-floor-value (aoao), expects "page" ==> ok
test tree-map-ceiling (aoao), expects ("aoao" "page") ==> ok
test tree-map-ceiling-key (aoao), expects "aoao" ==> ok
test tree-map-ceiling-value (aoao), expects "page" ==> ok
test tree-map-predecessor (aoao), expects ("aloha" "love") ==> ok
test tree-map-predecessor-key (aoao), expects "aloha" ==> ok
test tree-map-predecessor-value (aoao), expects "love" ==> ok
test tree-map-successor (aoao), expects ("aumoe" "midnight") ==> ok
test tree-map-successor-key (aoao), expects "aumoe" ==> ok
test tree-map-successor-value (aoao), expects "midnight" ==> ok
test tree-map-floor (av), expects ("aumoe" "midnight") ==> ok
test tree-map-floor-key (av), expects "aumoe" ==> ok
test tree-map-floor-value (av), expects "midnight" ==> ok
test tree-map-ceiling (av), expects (#f #f) ==> ok
test tree-map-ceiling-key (av), expects #f ==> ok
test tree-map-ceiling-value (av), expects #f ==> ok
test tree-map-ceiling (av) / fallback, expects (0 1) ==> ok
test tree-map-ceiling-key (av) / fallback, expects 0 ==> ok
test tree-map-ceiling-value (av) / fallback, expects 0 ==> ok
test tree-map-predecessor (av), expects ("aumoe" "midnight") ==> ok
test tree-map-predecessor-key (av), expects "aumoe" ==> ok
test tree-map-predecessor-value (av), expects "midnight" ==> ok
test tree-map-successor (av), expects (#f #f) ==> ok
test tree-map-successor-key (av), expects #f ==> ok
test tree-map-successor-value (av), expects #f ==> ok
test tree-map-successor (av) / fallback, expects (0 1) ==> ok
test tree-map-successor-key (av) / fallback, expects 0 ==> ok
test tree-map-successor-value (av) / fallback, expects 0 ==> ok
test tree-map-floor (aumoe), expects ("aumoe" "midnight") ==> ok
test tree-map-floor-key (aumoe), expects "aumoe" ==> ok
test tree-map-floor-value (aumoe), expects "midnight" ==> ok
test tree-map-ceiling (aumoe), expects ("aumoe" "midnight") ==> ok
test tree-map-ceiling-key (aumoe), expects "aumoe" ==> ok
test tree-map-ceiling-value (aumoe), expects "midnight" ==> ok
test tree-map-predecessor (aumoe), expects ("aoao" "page") ==> ok
test tree-map-predecessor-key (aumoe), expects "aoao" ==> ok
test tree-map-predecessor-value (aumoe), expects "page" ==> ok
test tree-map-successor (aumoe), expects (#f #f) ==> ok
test tree-map-successor-key (aumoe), expects #f ==> ok
test tree-map-successor-value (aumoe), expects #f ==> ok
test tree-map-successor (aumoe) / fallback, expects (0 1) ==> ok
test tree-map-successor-key (aumoe) / fallback, expects 0 ==> ok
test tree-map-successor-value (aumoe) / fallback, expects 0 ==> ok
test tree-map-floor (aii), expects ("ai" "to eat") ==> ok
test tree-map-floor-key (aii), expects "ai" ==> ok
test tree-map-floor-value (aii), expects "to eat" ==> ok
test tree-map-ceiling (aii), expects ("aka" "but") ==> ok
test tree-map-ceiling-key (aii), expects "aka" ==> ok
test tree-map-ceiling-value (aii), expects "but" ==> ok
test tree-map-predecessor (aii), expects ("ai" "to eat") ==> ok
test tree-map-predecessor-key (aii), expects "ai" ==> ok
test tree-map-predecessor-value (aii), expects "to eat" ==> ok
test tree-map-successor (aii), expects ("aka" "but") ==> ok
test tree-map-successor-key (aii), expects "aka" ==> ok
test tree-map-successor-value (aii), expects "but" ==> ok
test tree-map-floor (ai), expects ("ai" "to eat") ==> ok
test tree-map-floor-key (ai), expects "ai" ==> ok
test tree-map-floor-value (ai), expects "to eat" ==> ok
test tree-map-ceiling (ai), expects ("ai" "to eat") ==> ok
test tree-map-ceiling-key (ai), expects "ai" ==> ok
test tree-map-ceiling-value (ai), expects "to eat" ==> ok
test tree-map-predecessor (ai), expects (#f #f) ==> ok
test tree-map-predecessor-key (ai), expects #f ==> ok
test tree-map-predecessor-value (ai), expects #f ==> ok
test tree-map-predecessor (ai) / fallback, expects (0 1) ==> ok
test tree-map-predecessor-key (ai) / fallback, expects 0 ==> ok
test tree-map-predecessor-value (ai) / fallback, expects 0 ==> ok
test tree-map-successor (ai), expects ("aka" "but") ==> ok
test tree-map-successor-key (ai), expects "aka" ==> ok
test tree-map-successor-value (ai), expects "but" ==> ok
test tree-map-floor (aa), expects (#f #f) ==> ok
test tree-map-floor-key (aa), expects #f ==> ok
test tree-map-floor-value (aa), expects #f ==> ok
test tree-map-floor (aa) / fallback, expects (0 1) ==> ok
test tree-map-floor-key (aa) / fallback, expects 0 ==> ok
test tree-map-floor-value (aa) / fallback, expects 0 ==> ok
test tree-map-ceiling (aa), expects ("ai" "to eat") ==> ok
test tree-map-ceiling-key (aa), expects "ai" ==> ok
test tree-map-ceiling-value (aa), expects "to eat" ==> ok
test tree-map-predecessor (aa), expects (#f #f) ==> ok
test tree-map-predecessor-key (aa), expects #f ==> ok
test tree-map-predecessor-value (aa), expects #f ==> ok
test tree-map-predecessor (aa) / fallback, expects (0 1) ==> ok
test tree-map-predecessor-key (aa) / fallback, expects 0 ==> ok
test tree-map-predecessor-value (aa) / fallback, expects 0 ==> ok
test tree-map-successor (aa), expects ("ai" "to eat") ==> ok
test tree-map-successor-key (aa), expects "ai" ==> ok
test tree-map-successor-value (aa), expects "to eat" ==> ok
test tree-map-floor (xx), expects (#f #f) ==> ok
test tree-map-floor-key (xx), expects #f ==> ok
test tree-map-floor-value (xx), expects #f ==> ok
test tree-map-floor (xx) / fallback, expects (0 1) ==> ok
test tree-map-floor-key (xx) / fallback, expects 0 ==> ok
test tree-map-floor-value (xx) / fallback, expects 0 ==> ok
test tree-map-ceiling (xx), expects (#f #f) ==> ok
test tree-map-ceiling-key (xx), expects #f ==> ok
test tree-map-ceiling-value (xx), expects #f ==> ok
test tree-map-ceiling (xx) / fallback, expects (0 1) ==> ok
test tree-map-ceiling-key (xx) / fallback, expects 0 ==> ok
test tree-map-ceiling-value (xx) / fallback, expects 0 ==> ok
test tree-map-predecessor (xx), expects (#f #f) ==> ok
test tree-map-predecessor-key (xx), expects #f ==> ok
test tree-map-predecessor-value (xx), expects #f ==> ok
test tree-map-predecessor (xx) / fallback, expects (0 1) ==> ok
test tree-map-predecessor-key (xx) / fallback, expects 0 ==> ok
test tree-map-predecessor-value (xx) / fallback, expects 0 ==> ok
test tree-map-successor (xx), expects (#f #f) ==> ok
test tree-map-successor-key (xx), expects #f ==> ok
test tree-map-successor-value (xx), expects #f ==> ok
test tree-map-successor (xx) / fallback, expects (0 1) ==> ok
test tree-map-successor-key (xx) / fallback, expects 0 ==> ok
test tree-map-successor-value (xx) / fallback, expects 0 ==> ok
test tree-map-pop-min! and num-entries, expects 0 ==> ok
passed.
Testing io ====================================================================
<file i/o>---------------------------------------------------------------------
test open-input-file, expects #<<system-error>> ==> ok
test open-input-file :if-does-not-exist #f, expects #f ==> ok
test open-output-file :if-does-not-exist :error, expects #<error> ==> ok
test open-output-file :if-does-not-exit #f, expects #f ==> ok
test open-output-file, expects #t ==> ok
test open-input-file, expects abcde ==> ok
test open-output-file :if-exists :error, expects #<error> ==> ok
test open-output-file :if-exists :supersede, expects cdefg ==> ok
test open-output-file :if-exists :append, expects cdefghij ==> ok
test open-output-file :if-exists :append, expects cdefghijklm ==> ok
test open-output-file :if-exists :supersede, expects nopqr ==> ok
test call-with-input-file :if-does-not-exist #f, expects (#f #f) ==> ok
test with-input-from-file :if-does-not-exist #f, expects #f ==> ok
test call-with-output-file :if-exists #f, expects stu ==> ok
test with-output-to-file :if-exists #f, expects stu ==> ok
<port-fd-dup!>-----------------------------------------------------------------
test port-fd-dup!, expects ("foo" "bar") ==> ok
test port-fd-dup!, expects ("foo" "bar") ==> ok
test port-fd-dup!, expects #<error> ==> ok
test port-fd-dup!, expects #<error> ==> ok
<input ports>------------------------------------------------------------------
test read-char (EOF), expects #t ==> ok
test read-byte (EOF), expects #t ==> ok
test read-line (EOF), expects #t ==> ok
test read-block (EOF), expects #t ==> ok
test read-char (a), expects #\a ==> ok
test read-byte (a), expects 97 ==> ok
test read-byte (ungotten), expects 97 ==> ok
test read-line (a), expects "ab" ==> ok
test read-byte (ungotten), expects 97 ==> ok
test peek-byte (a), expects (97 97) ==> ok
test peek-byte (ungotten), expects (97 97) ==> ok
test peek-byte and read-char, expects #\a ==> ok
test peek-byte and peek-char, expects #\a ==> ok
test read-block (a), expects #*"ab" ==> ok
test read-block (ungotten), expects #*"ab" ==> ok
test read-line (LF), expects "" ==> ok
test read-line (LF, ungotten), expects "" ==> ok
test read-line (CR), expects "" ==> ok
test read-line (CR, ungotten), expects "" ==> ok
test read-line (LF), expects ("" "" #t) ==> ok
test read-line (CR, CRLF), expects ("" "" #t) ==> ok
test read-line (mix), expects ("a" "b" "c" #t) ==> ok
test read-line (bad sequence), expects (5 0) ==> ok
test port->string, expects "a b c \"d e\" f g\n(0 1 2\n3 4 5)\n" ==> ok
test port->list, expects (a b c "d e" f g (0 1 2 3 4 5)) ==> ok
test port->list, expects ("a b c \"d e\" f g" "(0 1 2" "3 4 5)") ==> ok
test port->string-list, expects ("a b c \"d e\" f g" "(0 1 2" "3 4 5)") ==> ok
test port->sexp-list, expects (a b c "d e" f g (0 1 2 3 4 5)) ==> ok
test port-fold, expects ((0 1 2 3 4 5) g f "d e" c b a) ==> ok
test port-fold, expects ("3 4 5)" "(0 1 2" "a b c \"d e\" f g") ==> ok
test port-fold, side-effecting, expects (#\c 3 #\b 2 #\a 1) ==> ok
test port-fold-right, expects (a b c "d e" f g (0 1 2 3 4 5)) ==> ok
test port-map, expects (a b c "d e" f g (0 1 2 3 4 5)) ==> ok
test port-map, side-effecting, expects ((#\a 1) (#\b 2) (#\c 3)) ==> ok
<with-ports>-------------------------------------------------------------------
test with-input-from-port, expects (#\b #\d #\c #\a) ==> ok
test with-,|name|-to-port, expects ("ad" "bc") ==> ok
test with-,|name|-to-port, expects ("ad" "bc") ==> ok
test with-ports 1, expects ("a" "b") ==> ok
test with-ports 2, expects ("B" "A") ==> ok
test with-ports 3, expects ("A" "B") ==> ok
test with-ports 4, expects ("" "ab") ==> ok
<seeking>----------------------------------------------------------------------
test seek (istr), expects "abcdecdefgfghijabchij" ==> ok
test seek (istr, boundary), expects #\a ==> ok
test seek (istr, boundary), expects #t ==> ok
test seek (istr, out of range), expects #f ==> ok
test seek (istr, out of range), expects #f ==> ok
test seek (istr, with peek-char), expects ("hello" "hello") ==> ok
test seek (istr, with peek-char), expects (#\b #\b) ==> ok
test seek (ifile), expects "abcdecdefgfghijabchij" ==> ok
test seek (ofile), expects "--//efg**j++" ==> ok
test seek (ifile, large), expects "0000050055019999050100027500" ==> ok
test seek (ofile, large), expects "*0-0*/-0999+" ==> ok
test seek (ifile, with peek-char), expects ("hello" "hello") ==> ok
<format>-----------------------------------------------------------------------
test format ~s, expects "\"abc\"" ==> ok
test format ~s, expects "\"abc\"     " ==> ok
test format ~s, expects "     \"abc\"" ==> ok
test format ~s, expects "\"abc\"      " ==> ok
test format ~s, expects "      \"abc\"" ==> ok
test format ~s, expects "\"abc\" " ==> ok
test format ~s, expects " \"abc\"" ==> ok
test format ~s, expects "\"abc\"*****" ==> ok
test format ~s, expects "*****\"abc\"" ==> ok
test format ~s, expects "\"abc\"*****" ==> ok
test format ~s, expects "*****\"abc\"" ==> ok
test format ~s, expects "(\"abc\" \"def\" \"g" ==> ok
test format ~s, expects "(\"abc\" \"def\" \"g" ==> ok
test format ~s, expects "(\"abc\" \"def ..." ==> ok
test format ~s, expects "(\"abc\" \"def ..." ==> ok
test format ~a, expects "abc" ==> ok
test format ~a, expects "abc       " ==> ok
test format ~a, expects "       abc" ==> ok
test format ~a, expects "abc         " ==> ok
test format ~a, expects "         abc" ==> ok
test format ~a, expects "abc " ==> ok
test format ~a, expects " abc" ==> ok
test format ~a, expects "abc*******" ==> ok
test format ~a, expects "*******abc" ==> ok
test format ~a, expects "(abc def ghi jk" ==> ok
test format ~a, expects "(abc def ghi jk" ==> ok
test format ~a, expects "(abc def gh ..." ==> ok
test format ~a, expects "(abc def gh ..." ==> ok
test format ~d, expects "12345" ==> ok
test format ~d, expects "-12345" ==> ok
test format ~d, expects "+12345" ==> ok
test format ~d, expects "-12345" ==> ok
test format ~d, expects "     12345" ==> ok
test format ~d, expects "    -12345" ==> ok
test format ~d, expects "    +12345" ==> ok
test format ~d, expects "    -12345" ==> ok
test format ~d, expects "0000012345" ==> ok
test format ~d, expects "0000-12345" ==> ok
test format ~:d, expects "1" ==> ok
test format ~:d, expects "-1" ==> ok
test format ~:d, expects "12" ==> ok
test format ~:d, expects "-12" ==> ok
test format ~:d, expects "123" ==> ok
test format ~:d, expects "-123" ==> ok
test format ~:d, expects "+123" ==> ok
test format ~:d, expects "1,234" ==> ok
test format ~:d, expects "-1,234" ==> ok
test format ~:d, expects "+1,234" ==> ok
test format ~:d, expects "12,345" ==> ok
test format ~:d, expects "-12,345" ==> ok
test format ~:d, expects "123,456,789" ==> ok
test format ~:d, expects "-123,456,789" ==> ok
test format ~:d, expects "123.456.789" ==> ok
test format ~:d, expects "-123.456.789" ==> ok
test format ~:d, expects "1.2345.6789" ==> ok
test format ~:d, expects "-1.2345.6789" ==> ok
test format ~:d, expects "    12,345" ==> ok
test format ~:d, expects "   -12,345" ==> ok
test format ~:d, expects "   +12,345" ==> ok
test format ~b, expects "10101" ==> ok
test format ~b, expects "-10101" ==> ok
test format ~b, expects "+10101" ==> ok
test format ~b, expects "-10101" ==> ok
test format ~b, expects "     10101" ==> ok
test format ~b, expects "    -10101" ==> ok
test format ~b, expects "    +10101" ==> ok
test format ~b, expects "    -10101" ==> ok
test format ~b, expects "0000010101" ==> ok
test format ~b, expects "0000-10101" ==> ok
test format ~b, expects "101" ==> ok
test format ~b, expects "101 0101" ==> ok
test format ~o, expects "12345" ==> ok
test format ~o, expects "-12345" ==> ok
test format ~o, expects "+12345" ==> ok
test format ~o, expects "-12345" ==> ok
test format ~o, expects "     12345" ==> ok
test format ~o, expects "    -12345" ==> ok
test format ~o, expects "    +12345" ==> ok
test format ~o, expects "    -12345" ==> ok
test format ~o, expects "0000012345" ==> ok
test format ~o, expects "0000-12345" ==> ok
test format ~x, expects "12345" ==> ok
test format ~x, expects "-12345" ==> ok
test format ~x, expects "+12345" ==> ok
test format ~x, expects "-12345" ==> ok
test format ~x, expects "     12345" ==> ok
test format ~x, expects "    -12345" ==> ok
test format ~x, expects "    +12345" ==> ok
test format ~x, expects "    -12345" ==> ok
test format ~x, expects "0000012345" ==> ok
test format ~x, expects "0000-12345" ==> ok
test format v param, expects "     12345" ==> ok
test format v param, expects "0000012345" ==> ok
test format ~*, expects "1 2 4 5" ==> ok
test format ~*, expects "1 5" ==> ok
test format ~:*, expects "1 2 2 3 4 5" ==> ok
test format ~:*, expects "1 2 3 1 2 3 4 5" ==> ok
test format ~:*, expects "1 2 3 1" ==> ok
test format ~@*, expects "1 2 5" ==> ok
test format incomplete tilde sequence, expects #<error> ==> ok
test format incomplete tilde sequence, expects #<error> ==> ok
test format skip to the end, expects "||" ==> ok
<some corner cases in list reader>---------------------------------------------
test dot (().()), expects (()) ==> ok
test dot ([].[]), expects (()) ==> ok
test dot (x .,y), expects (x unquote y) ==> ok
test dot (x .,@y), expects (x unquote-splicing y) ==> ok
test dot (().), expects #<<read-error>> ==> ok
test dot ((). .), expects #<<read-error>> ==> ok
<nested multi-line comments>---------------------------------------------------
test #|...|#, expects (foo bar baz) ==> ok
test #|...|#, expects (foo bar baz) ==> ok
test #|...|#, expects (foo bar baz) ==> ok
test #|...|# (multiline), expects (foo bar baz) ==> ok
test #|...|# (multiline), expects (foo bar baz) ==> ok
test #|...|# (nested), expects (foo bar baz) ==> ok
test #|...|# (nested), expects (foo bar baz) ==> ok
test #|...|# (intertwined with string), expects (foo bar this is outside of comment "hence this is in a string") ==> ok
test #|...|# (intertwined with string), expects (foo bar "#| this is a string, not a comment" |# and this is not a comment terminator but an escaped symbol|) ==> ok
<#;-style commend (a la Chez)>-------------------------------------------------
test #;123 456, expects 456 ==> ok
test #; (123 456) 789, expects 789 ==> ok
test #;#;(123 456) 789 1, expects 1 ==> ok
test S-expression comment and read-time constructor, expects 2 ==> ok
<port->* basic>----------------------------------------------------------------
test port->string "", expects "" ==> ok
test port->string "abc", expects "abc" ==> ok
test port->string "abc\ndef\n", expects "abc\ndef\n" ==> ok
test (.$ string-complete->incomplete port->string) #*"\0\x80\xc0\xd0\xff\xfe\xef", expects #*"\0\x80\xc0\xd0\xff\xfe\xef" ==> ok
test port->string-list ("abc"), expects ("abc") ==> ok
test port->string-list ("abc" "def"), expects ("abc" "def") ==> ok
test (.$ (cut map string-complete->incomplete <>) port->string-list) (#*"\0\x80\xc0\xd0\xff\xfe\xef" #*"abc"), expects (#*"\0\x80\xc0\xd0\xff\xfe\xef" #*"abc") ==> ok
test port->sexp-list (abc), expects (abc) ==> ok
<coding-aware-port basic>------------------------------------------------------
test ownership, expects #t ==> ok
test read from empty port, expects (#t #t #t #t #t) ==> ok
test read from simple contents, expects ("abc" "abc\n" "\nabc" "abc\ndef\n" "abc\ndef\nghi" "abc\ndef\nghi\n" "abc\r\ndef\r\nghi" "abc\r\ndef\r\nghi\r\n" "abc\rdef\rghi" "abc\rdef\rghi\r" "abc\ndef\nghi\njkl" "abc\ndef\nghi\njkl\n") ==> ok
test to confuse DFA, expects ("coding: abcde\naa" ";coding:\nabcdef\naa" ";coding:\r\nabcdef\r\naa" ";coding:\rabcdef\raa" "coding: coding: coding:; abcde\naa" "coding: coding: coding:; abcde\r\naa" ";; co\nding: foobar\naa" ";; co\r\nding: foobar\r\naa" ";; co\rding: foobar\raa" ";; coding:\n;; foobar\naa" ";; coding : foobar\naa" ";; coding : foobar\r\naa" ";; coding : foobar\raa" "\n\n;; coding: foobar\naa" "\r\n\r\n;; coding: foobar\r\naa" "\r\r;; coding: foobar\raa" "\n;;    codincodincoding:\naa") ==> ok
passed.
Testing procedures ============================================================
<C-stack boundary crossing>----------------------------------------------------
test apply-rec0, expects a ==> ok
test apply-rec1, expects (a . b) ==> ok
test apply-rec2, expects (x y c) ==> ok
test apply-rec3, expects (x y z c) ==> ok
test apply-rec4, expects (x y z w c) ==> ok
test apply-rec, expects (x y z w u v c) ==> ok
<combinatorial programming utilities>------------------------------------------
test pa$, expects 10 ==> ok
test pa$, expects (a b c) ==> ok
test pa$, expects (a b c) ==> ok
test pa$, expects (a b c) ==> ok
test map$, expects (2 4 6) ==> ok
test compose, expects (#t #f #t) ==> ok
test compose, expects a ==> ok
test compose, expects (a b c) ==> ok
test complement, expects (#t #f #t) ==> ok
test complement, expects (#t #f #t) ==> ok
test complement, expects (#f #t #f) ==> ok
test complement, expects (#f #t #f) ==> ok
test complement, expects #t ==> ok
test compose, apply$, map$, expects 32 ==> ok
test any-pred, expects (#t #t #f) ==> ok
test any-pred, expects (b c) ==> ok
test any-pred, expects (#t #f) ==> ok
test every-pred, expects (#t #f #f) ==> ok
test every-pred, expects (3 #f) ==> ok
<scmlib builtins>--------------------------------------------------------------
test map* 1 arg, expects (-1 -2 -3 . 1/4) ==> ok
test map* 1 arg, expects (-1 -2 -3 . #t) ==> ok
test map* 1 arg, expects #f ==> ok
test map* n arg same elements, expects (6 9 12 . 120) ==> ok
test map* n arg uneven elements, expects (6 9 12 4 () (6)) ==> ok
test map* n arg uneven elements, expects ((1 2 3 . 4) () (3 4 5 6)) ==> ok
test map* n arg uneven elements, expects ((1 2 3 . 4) 0 (3 4 5 6)) ==> ok
<optional arguments>-----------------------------------------------------------
test let-optionals*, expects (0 a b c) ==> ok
test let-optionals*, expects (0 1 b c) ==> ok
test let-optionals*, expects (0 1 2 c) ==> ok
test let-optionals*, expects (0 1 2 3) ==> ok
test let-optionals*, expects (0 a b ()) ==> ok
test let-optionals*, expects (0 1 b ()) ==> ok
test let-optionals*, expects (0 1 2 ()) ==> ok
test let-optionals*, expects (0 1 2 (3)) ==> ok
test let-optionals*, expects 1 ==> ok
test let-optionals*, expects 1 ==> ok
test let-optionals*, expects 1 ==> ok
test let-optionals*, expects 1 ==> ok
test get-optional, expects (0 foof) ==> ok
test get-optional, expects (0 1) ==> ok
test get-optional, expects 1 ==> ok
test get-optional, expects 1 ==> ok
test let-keywords*, expects (0 a b c) ==> ok
test let-keywords*, expects (0 1 b c) ==> ok
test let-keywords*, expects (0 a 1 c) ==> ok
test let-keywords*, expects (0 a b 1) ==> ok
test let-keywords*, expects (0 1 2 3) ==> ok
test let-keywords*, expects 1 ==> ok
test let-keywords*, expects 1 ==> ok
test let-keywords*, expects 1 ==> ok
test let-keywords*, expects 1 ==> ok
test let-keywords*, expects 1 ==> ok
test let-keywords, expects (0 a b c) ==> ok
test let-keywords, expects (0 1 b c) ==> ok
test let-keywords, expects (0 a 1 c) ==> ok
test let-keywords, expects (0 a b 1) ==> ok
test let-keywords, expects (0 1 2 3) ==> ok
test let-keywords, expects #<error> ==> ok
test let-keywords, expects 1 ==> ok
test let-keywords, expects 1 ==> ok
test let-keywords, expects 1 ==> ok
test let-keywords, expects 1 ==> ok
test let-keywords, expects 1 ==> ok
test let-keywords, expects #<error> ==> ok
test macro + let-keywords*, expects (1 2 3 #f 5) ==> ok
test macro + let-keywords*, expects #<error> ==> ok
test macro + let-keywords*, expects (1 2 3 4 #f) ==> ok
test macro + let-keywords*, expects (1 2 3 0 1) ==> ok
<extended lambda formals>------------------------------------------------------
test :optional c d, expects (1 2 3 4) ==> ok
test :optional c d, expects (1 2 3 #<undef>) ==> ok
test :optional c d, expects (1 2 #<undef> #<undef>) ==> ok
test :optional c d, expects #<error> ==> ok
test :optional c d, expects #<error> ==> ok
test :optional (c 99) (d 100), expects (1 2 3 4) ==> ok
test :optional (c 99) (d 100), expects (1 2 3 100) ==> ok
test :optional (c 99) (d 100), expects (1 2 99 100) ==> ok
test :optional (c 99) (d 100), expects #<error> ==> ok
test :optional (c 99) (d 100), expects #<error> ==> ok
test :optional a (b 99) (c 100) d, expects (1 2 3 4) ==> ok
test :optional a (b 99) (c 100) d, expects (1 2 3 #<undef>) ==> ok
test :optional a (b 99) (c 100) d, expects (1 2 100 #<undef>) ==> ok
test :optional a (b 99) (c 100) d, expects (1 99 100 #<undef>) ==> ok
test :optional a (b 99) (c 100) d, expects (#<undef> 99 100 #<undef>) ==> ok
test :key (c 99) (d 100), expects (1 2 3 4) ==> ok
test :key (c 99) (d 100), expects #<error> ==> ok
test :key (c 99) (d 100), expects (1 2 3 100) ==> ok
test :key (c 99) (d 100), expects #<error> ==> ok
test :key (c 99) (d 100), expects (1 2 99 100) ==> ok
test :key (c 99) (d 100), expects #<error> ==> ok
test :key (c 99) (d 100), expects #<error> ==> ok
test :optional (c 0) (d 1) :rest z, expects (1 2 3 4 (5 6)) ==> ok
test :optional (c 0) (d 1) :rest z, expects (1 2 3 4 (5)) ==> ok
test :optional (c 0) (d 1) :rest z, expects (1 2 3 4 ()) ==> ok
test :optional (c 0) (d 1) :rest z, expects (1 2 3 1 ()) ==> ok
test :optional (c 0) (d 1) :rest z, expects (1 2 0 1 ()) ==> ok
test :optional (c 0) (d 1) :rest z, expects #<error> ==> ok
test :optional (c 0) (d 1) :rest z, expects #<error> ==> ok
test :rest z :optional (c 0) (d 1), expects (1 2 3 4 (5 6)) ==> ok
test :rest z :optional (c 0) (d 1), expects (1 2 3 4 (5)) ==> ok
test :rest z :optional (c 0) (d 1), expects (1 2 3 4 ()) ==> ok
test :rest z :optional (c 0) (d 1), expects (1 2 3 1 ()) ==> ok
test :rest z :optional (c 0) (d 1), expects (1 2 0 1 ()) ==> ok
test :rest z :optional (c 0) (d 1), expects #<error> ==> ok
test :rest z :optional (c 0) (d 1), expects #<error> ==> ok
test :key (b 0) (c 1) :rest z, expects (1 88 99 (:c 99 :b 88)) ==> ok
test :key (b 0) (c 1) :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :rest z, expects (1 0 99 (:c 99)) ==> ok
test :key (b 0) (c 1) :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :rest z, expects (1 0 1 ()) ==> ok
test :key (b 0) (c 1) :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :allow-other-keys :rest z, expects (1 0 99 (:c 99 :a 77)) ==> ok
test :key (b 0) (c 1) :allow-other-keys :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :allow-other-keys :rest z, expects (1 0 99 (:c 99)) ==> ok
test :key (b 0) (c 1) :allow-other-keys :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :allow-other-keys :rest z, expects (1 0 1 ()) ==> ok
test :key (b 0) (c 1) :allow-other-keys :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects (1 0 99 (:a 77 :d 66) (:d 66 :c 99 :a 77)) ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects (1 0 99 (:d 66) (:d 66 :c 99)) ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects (1 0 1 (:d 66) (:d 66)) ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects #<error> ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects (1 0 1 () ()) ==> ok
test :key (b 0) (c 1) :allow-other-keys y :rest z, expects #<error> ==> ok
test :optional b c :key (d 0) (e 1) :rest z, expects (1 :e 99 66 1 (:d 66)) ==> ok
test :optional b c :key (d 0) (e 1) :rest z, expects #<error> ==> ok
test :optional b c :key (d 0) (e 1) :rest z, expects (1 :e 99 0 1 ()) ==> ok
test :optional b c :key (d 0) (e 1) :rest z, expects (1 :e #<undef> 0 1 ()) ==> ok
test :optional b c :key (d 0) (e 1) :rest z, expects (1 #<undef> #<undef> 0 1 ()) ==> ok
test :optional b c :key (d 0) (e 1) :rest z, expects #<error> ==> ok
<case-lambda>------------------------------------------------------------------
test case-lambda [0..] 0, expects 0 ==> ok
test case-lambda [0..] 1, expects 1 ==> ok
test case-lambda [0..] 2, expects 3 ==> ok
test case-lambda [0..] 3, expects 6 ==> ok
test case-lambda [0..] 4, expects 10 ==> ok
test case-lambda [2..4] 0, expects #<error> ==> ok
test case-lambda [2..4] 1, expects #<error> ==> ok
test case-lambda [2..4] 2, expects (two 1 2) ==> ok
test case-lambda [2..4] 3, expects (three 1 2 3) ==> ok
test case-lambda [2..4] 4, expects (four 1 2 3 4) ==> ok
test case-lambda [2..4] 5, expects #<error> ==> ok
test case-lambda [1..] matching order 0, expects #<error> ==> ok
test case-lambda [1..] matching order 1, expects (bar 1 ()) ==> ok
test case-lambda [1..] matching order 2, expects (foo 1 2) ==> ok
test case-lambda [1..] matching order 3, expects (bar 1 (2 3)) ==> ok
test case-lambda [0..] matching order 1, expects (foo (1)) ==> ok
test case-lambda [0,2] 0, expects yot ==> ok
test case-lambda [0,2] 1, expects #<error> ==> ok
test case-lambda [0,2] 2, expects (bot 1 2) ==> ok
test case-lambda one lambda 0, expects #<error> ==> ok
test case-lambda one lambda 1, expects (foo 1 ()) ==> ok
test case-lambda one lambda 2, expects (foo 1 (2)) ==> ok
<generator-*>------------------------------------------------------------------
test generator-fold, 1 arg, expects (e d c b a . z) ==> ok
test generator-fold-right, 1 arg, expects (a b c d e . z) ==> ok
test generator-map, 1 arg, expects ("a" "b" "c" "d" "e") ==> ok
test generator-for-each, 1 arg, expects (e d c b a) ==> ok
test generator-fold, 2 args, expects (e 5 (d 4 (c 3 (b 2 (a 1 z))))) ==> ok
test generator-fold-right, 2 args, expects (a 1 (b 2 (c 3 (d 4 (e 5 z))))) ==> ok
test generator-map, 2 args, expects (7 9 11 13) ==> ok
test generator-for-each, 2 args, expects (13 11 9 7) ==> ok
passed.
Testing dynamic-wind and call/cc ==============================================
test call/cc (env), expects (2048 1024 512 256 128 64 32 16 8 4 2) ==> ok
test call/cc (values), expects (1 2 3) ==> ok
test call/cc (values2), expects (1 2 3) ==> ok
test call/cc (values3), expects (1 2 (3)) ==> ok
test call/cc (values4), expects #<error> ==> ok
test call/cc (inline), expects ((1 2 3 4 5 6 7 8) (1 2 3 4 -1 6 7 8)) ==> ok
test call/cc (do), expects 6 ==> ok
test call/cc (cstack), expects 10 ==> ok
test call/cc (cstack2), expects (10 . 11) ==> ok
test call/cc (cstack, values), expects (10 11) ==> ok
test call/cc (cstack, two level), expects (10 . 11) ==> ok
test call/cc (cstack, two level, two hop), expects (11 . 11) ==> ok
test call/cc (ghost continuation), expects #<error> ==> ok
test call/cc (ghost continuation, escaping out by call/cc), expects (1 . 2) ==> ok
test call/cc (ghost continuation, escaping out by error), expects (1 . 2) ==> ok
test call/cc (ghost continuation, escaping out by error 2), expects (1 . 2) ==> ok
test call/cc & dynwind (cstack), expects (a b c) ==> ok
test dynamic-wind, expects (connect talk1 disconnect connect talk2 disconnect) ==> ok
test dynamic-wind, expects (3 connect talk1 disconnect connect talk2 disconnect 1) ==> ok
test dynamic-wind, expects (a b c d e f g b c d e f g h) ==> ok
test dynamic-wind (multival), expects (a b c) ==> ok
test dynamic-wind (multival), expects () ==> ok
test dynamic-wind - error in before thunk, expects (a b c d h) ==> ok
test dynamic-wind - error in after thunk, expects (a b c d e f h) ==> ok
test restart & dynamic-wind with error(1), expects (a b c x d) ==> ok
test restart & dynamic-wind with error(2), expects (a b c x d) ==> ok
test compiler optimizer for dynamic-wind, expects 2 ==> ok
test optimization and inlined dynamic-wind, expects 2 ==> ok
test stack overflow, expects 500500 ==> ok
test stack overflow, expects 8002000 ==> ok
test stack overflow (apply), expects 2001000 ==> ok
test stack overflow (apply), expects 4501500 ==> ok
test call-with-output-file -> port-closed?, expects #t ==> ok
test call-with-input-file -> port-closed?, expects (#t a b c d e) ==> ok
test with-output-to-file -> port-closed?, expects (#t #f) ==> ok
test with-input-from-file -> port-closed?, expects (#t #f) ==> ok
test Al's call/cc test, expects 1 ==> ok
<partial continuations>--------------------------------------------------------
testing bindings in #<module gauche.partcont> ... ok
test reset, expects 6 ==> ok
test reset, expects (1 2) ==> ok
test shift, ignoring k, expects 4 ==> ok
test shift, ignoring k, expects (1 3) ==> ok
test calling pc, expects 10 ==> ok
test calling pc, expects (1 3 2 4) ==> ok
test calling pc multi, expects 14 ==> ok
test calling pc multi, expects (1 3 2 2 4) ==> ok
test www, expects 2400 ==> ok
test wwww, expects 48000 ==> ok
test inversion, expects 1 ==> ok
test inversion, expects 2 ==> ok
test inversion, expects 3 ==> ok
test inversion, expects 4 ==> ok
test inversion, expects 5 ==> ok
test inversion, expects #<eof> ==> ok
test inversion, expects #<eof> ==> ok
test a-normal, expects (lambda (x) (lambda (y) (let ((t (x y))) t))) ==> ok
test sprintf, expects "hello, world" ==> ok
test sprintf, expects "world" ==> ok
passed.
Testing load ==================================================================
<require and provide>----------------------------------------------------------
test double require, expects #t ==> ok
test detecting loop of require, expects #<error> ==> ok
test reload after error, expects 1 ==> ok
<load environment>-------------------------------------------------------------
test :environment argument, expects 3 ==> ok
test eval & load & environment, expects 6 ==> ok
<current-load-* info>----------------------------------------------------------
test current-load-history (1), expects #/^\(\(#<iport (?:[^>])*test\/load\.scm/ ==> ok
test current-load-next (1), expects "()" ==> ok
test current-load-port (1), expects #/^#<iport (?:[^>])*\/test\.o\/c1\.scm/ ==> ok
test current-load-path (1), expects "./test.o/c1.scm" ==> ok
test current-load-history (2), expects #/^\(\(#<iport (?:[^>])*test\.o\/c1\.scm (?:[^)])*\) \(#<iport (?:[^>])*test\/load\.scm (?:[^)])*\)/ ==> ok
test current-load-next (2), expects "()" ==> ok
test current-load-port (2), expects #/^#<iport (?:[^>])*\/test\.o\/c2\.scm/ ==> ok
test current-load-path (2), expects "./test.o/c2.scm" ==> ok
test current-load-history (3), expects #/^\(\(#<iport (?:[^>])*test\/load\.scm/ ==> ok
test current-load-next (3), expects "()" ==> ok
test current-load-port (3), expects #/^#<iport (?:[^>])*\/test\.o\/c1\.scm/ ==> ok
test current-load-path (3), expects "./test.o/c1.scm" ==> ok
<include>----------------------------------------------------------------------
test include (relative to current, expands into toplevel), expects 4 ==> ok
test include (relative to current, expands inside let), expects 4 ==> ok
test include (absolute, expands into toplevel), expects 4 ==> ok
test include (nested), expects 14 ==> ok
test include (postcondition), expects 10 ==> ok
test include (within init part), expects 4 ==> ok
<autoload>---------------------------------------------------------------------
test autoload (file), expects 0 ==> ok
test autoload (file/error), expects #<error> ==> ok
test autoload environment, expects #t ==> ok
<libutil>----------------------------------------------------------------------
test library-fold _test, expects ((_test . "test.o/_test.scm")) ==> ok
test library-fold _test, expects (("_test" . "test.o/_test.scm")) ==> ok
test library-fold _test (multi), expects ((_test . "test.o/_test.scm")) ==> ok
test library-fold _test (multi), expects ((_test . "test.o/_test.scm")) ==> ok
test library-fold _test (multi), expects (("_test" . "test.o/_test/_test.scm")) ==> ok
test library-fold _test (multi), expects (("_test" . "test.o/_tset/_test.scm") ("_test" . "test.o/_test.scm") ("_test" . "test.o/_test/_test.scm")) ==> ok
test library-fold _test (non-strict), expects ((_test . "test.o/_tset/_test.scm") (_test . "test.o/_test.scm") (_test . "test.o/_test/_test.scm")) ==> ok
test library-fold _test._test, expects ((_test._test . "test.o/_test/_test.scm")) ==> ok
test library-fold _test/_test, expects (("_test/_test" . "test.o/_test/_test.scm")) ==> ok
test library-fold _test.*, expects ((_test._test . "test.o/_test/_test.scm") (_test._test1 . "test.o/_test/_test1.scm")) ==> ok
test library-fold _tset.*, expects ((_tset._test . "test.o/_tset/_test.scm")) ==> ok
test library-fold _tset/*, expects (("_tset/_test" . "test.o/_tset/_test.scm") ("_tset/_test2" . "test.o/_tset/_test2.scm")) ==> ok
test library-fold _test.*1, expects ((_test._test1 . "test.o/_test/_test1.scm")) ==> ok
test library-fold _*t._te*, expects ((_test._test . "test.o/_test/_test.scm") (_test._test1 . "test.o/_test/_test1.scm") (_tset._test . "test.o/_tset/_test.scm")) ==> ok
test library-fold */*, expects (("_test/_test" . "test.o/_test/_test.scm") ("_test/_test1" . "test.o/_test/_test1.scm") ("_tset/_test" . "test.o/_tset/_test.scm") ("_tset/_test2" . "test.o/_tset/_test2.scm")) ==> ok
test library-fold _t??t._test?, expects ((_test._test1 . "test.o/_test/_test1.scm")) ==> ok
test library-fold ?test.?test, expects ((_test._test . "test.o/_test/_test.scm")) ==> ok
test library-fold _t??t._test?, expects ((_test._test1 . "test.o/_test/_test1.scm") (_tset._test2 . "test.o/_tset/_test2.scm")) ==> ok
test library-fold _t??t/_test?, expects (("_test/_test1" . "test.o/_test/_test1.scm") ("_tset/_test2" . "test.o/_tset/_test2.scm")) ==> ok
test library-fold _t??t?/_test?, expects () ==> ok
test library-map, expects ((_test._test . "test.o/_test/_test.scm") (_test._test1 . "test.o/_test/_test1.scm")) ==> ok
test library-for-each, expects ((_test._test . "test.o/_test/_test.scm") (_test._test1 . "test.o/_test/_test1.scm")) ==> ok
test library-exists? _test, expects #t ==> ok
test library-exists? _test1, expects #f ==> ok
test library-exists? _test1, non-strict, expects #t ==> ok
test library-exists? _tset._test, expects #t ==> ok
test library-exists? "_test1", expects #t ==> ok
test library-exists? "_tset/_test2", expects #t ==> ok
test library-exists? "_test9", expects #f ==> ok
test library-exists? gauche, expects #t ==> ok
test library-exists? gauche, force-search, expects #f ==> ok
test library-exists? gauche, expects #f ==> ok
testing bindings in #<module gauche.libutil> ... ok
<load-path hook>---------------------------------------------------------------
test dummy-load-path-hook, expects "/home/shuji/gauche-dev/Gauche/src/test.o/non/existent/file.scm" ==> ok
passed.
Testing SRFIs =================================================================
<srfi-0>-----------------------------------------------------------------------
test cond-expand, expects 0 ==> ok
test cond-expand, expects 1 ==> ok
test cond-expand, expects 0 ==> ok
test cond-expand, expects #t ==> ok
test cond-expand, expects 0 ==> ok
test cond-expand, expects 0 ==> ok
test cond-expand, expects 1 ==> ok
test cond-expand, expects 0 ==> ok
test cond-expand, expects 0 ==> ok
<srfi-2>-----------------------------------------------------------------------
testing bindings in #<module srfi-2> ... ok
test and-let*, expects 3 ==> ok
test and-let*, expects #f ==> ok
test and-let*, expects 3 ==> ok
test and-let*, expects #f ==> ok
<srfi-5>-----------------------------------------------------------------------
testing bindings in #<module srfi-5> ... ok
test let - standard, expects 3 ==> ok
test let - standard, expects 1 ==> ok
test let - standard, expects 1 ==> ok
test let - standard, named, expects 55 ==> ok
test let - signature style, expects 55 ==> ok
test let - signature style, expects #t ==> ok
test let - rest binding, expects (0 1 (2 3 4)) ==> ok
test let - rest binding, named, expects ((2 3 4) 0 (1)) ==> ok
<srfi-7>-----------------------------------------------------------------------
test program (empty), expects ok ==> ok
test program (requires, code), expects #t ==> ok
test program (requires, multiple code), expects (1 2 1) ==> ok
test program (requires, no such feature), expects #<error> ==> ok
test program (files (empty)), expects (1 . 2) ==> ok
test program (files), expects 6 ==> ok
test program (files (multi)), expects 6 ==> ok
test program (feature-cond), expects 2 ==> ok
test program (feature-cond), expects 4 ==> ok
test program (feature-cond), expects 6 ==> ok
test program (feature-cond w/o else), expects #<error> ==> ok
<srfi-14>----------------------------------------------------------------------
testing bindings in #<module srfi-14> ... ok
test char-set-printer, expects "#[ace]" ==> ok
test char-set-printer, expects "#[ab]" ==> ok
test char-set-printer, expects "#[a-c]" ==> ok
test char-set-printer, expects "#[a-d]" ==> ok
test char-set-printer, expects "#[a-ce]" ==> ok
test char-set-printer, expects "#[acd]" ==> ok
test char-set-printer, expects "#[ac-e]" ==> ok
test char-set-printer, expects "#[ac-e]" ==> ok
test char-set-printer, expects "#[\\-\\[\\]]" ==> ok
test char-set-printer, expects "#[\\^a]" ==> ok
test char-set-printer, expects "#[!^]" ==> ok
test char-set?, expects #f ==> ok
test char-set?, expects #t ==> ok
test char-set=, expects #t ==> ok
test char-set=, expects #t ==> ok
test char-set=, expects #t ==> ok
test char-set=, expects #f ==> ok
test char-set<=, expects #t ==> ok
test char-set<=, expects #t ==> ok
test char-set<=, expects #t ==> ok
test char-set<=, expects #t ==> ok
test char-set-hash, expects #t ==> ok
test char-set-fold, expects #t ==> ok
test char-set-unfold, expects #t ==> ok
test char-set-unfold (default), expects #t ==> ok
test char-set-unfold!, expects #t ==> ok
test char-set-unfold!, expects #f ==> ok
test char-set-for-each, expects #t ==> ok
test char-set-for-each, expects #t ==> ok
test char-set-map, expects #t ==> ok
test char-set-map, expects #f ==> ok
test char-set-copy, expects #t ==> ok
test string->char-set, expects #t ==> ok
test string->char-set, expects #t ==> ok
test list->char-set, expects #t ==> ok
test list->char-set, expects #f ==> ok
test list->char-set, expects #t ==> ok
test list->char-set, expects #f ==> ok
test list->char-set!, expects #t ==> ok
test list->char-set!, expects #f ==> ok
test char-set-filter, expects #t ==> ok
test char-set-filter, expects #f ==> ok
test char-set-filter!, expects #t ==> ok
test char-set-filter!, expects #f ==> ok
test ucs-range->char-set, expects #t ==> ok
test ucs-range->char-set, expects #f ==> ok
test ucs-range->char-set!, expects #t ==> ok
test ucs-range->char-set!, expects #f ==> ok
test integer-range->char-set, expects #t ==> ok
test integer-range->char-set, expects #f ==> ok
test integer-range->char-set!, expects #t ==> ok
test integer-range->char-set!, expects #f ==> ok
test ->char-set, expects #t ==> ok
test ->char-set, expects #f ==> ok
test ->char-set, expects #t ==> ok
test char-set-size, expects 10 ==> ok
test char-set-count, expects 5 ==> ok
test char-set->list, expects #t ==> ok
test char-set->list, expects #f ==> ok
test char-set->string, expects #t ==> ok
test char-set->string, expects #f ==> ok
test char-set-contains?, expects #t ==> ok
test char-set-contains?, expects #f ==> ok
test char-set-complement (ascii, nohit), expects #f ==> ok
test char-set-complement (ascii, hit), expects #t ==> ok
test char-set-complement (~#x80, nohit), expects #f ==> ok
test char-set-complement (~#x80, hit), expects #t ==> ok
test char-set-complement (~~#x80, hit), expects #t ==> ok
test char-set-complement (~~#x80, nohit), expects #f ==> ok
test char-set-complement (~#x82, nohit), expects #f ==> ok
test char-set-complement (~#x82, hit-upper), expects #t ==> ok
test char-set-complement (~#x82, hit-lower), expects #t ==> ok
test char-set-complement (~~#x82, hit), expects #t ==> ok
test char-set-complement (~~#x82, nohit-upper), expects #f ==> ok
test char-set-complement (~~#x82, nohit-lower), expects #f ==> ok
test char-set-complement (~empty), expects #t ==> ok
test char-set-complement (~~empty), expects #f ==> ok
test char-set-every, expects #t ==> ok
test char-set-every, expects #f ==> ok
test char-set-any, expects #t ==> ok
test char-set-any, expects #f ==> ok
test char-set iterators, expects #t ==> ok
test char-set-adjoin, expects #t ==> ok
test char-set-adjoin, expects #f ==> ok
test char-set-adjoin!, expects #t ==> ok
test char-set-adjoin!, expects #f ==> ok
test char-set-delete, expects #t ==> ok
test char-set-delete, expects #f ==> ok
test char-set-delete, expects #t ==> ok
test char-set-delete!, expects #t ==> ok
test char-set-delete!, expects #f ==> ok
test char-set-delete!, expects #[\u0081\u0083\u0084\u0086] ==> ok
test char-set-intersection, expects #t ==> ok
test char-set-intersection!, expects #t ==> ok
test char-set-union, expects #t ==> ok
test char-set-union!, expects #t ==> ok
test char-set-union!, expects #[\u0081-\u0089] ==> ok
test char-set-difference, expects #t ==> ok
test char-set-difference!, expects #t ==> ok
test char-set-xor, expects #t ==> ok
test char-set-xor!, expects #t ==> ok
test char-set-diff+intersection, expects #t ==> ok
test char-set-diff+intersection!, expects #t ==> ok
<srfi-17>----------------------------------------------------------------------
test (setter car), expects ((3 3) . 2) ==> ok
test (setter cdr), expects ((3 3) 4 5) ==> ok
test (setter caar), expects (((8 9) 3) 4 5) ==> ok
test (setter cadr), expects (((8 9) 3) (7 6) 5) ==> ok
test (setter cdar), expects (((8 9) 4 5) (7 6) 5) ==> ok
test (setter cddr), expects (((8 9) 4 5) (7 6) 11 12) ==> ok
test (setter caaar), expects ((((13 14) 9) 4 5) (7 6) 11 12) ==> ok
test (setter caadr), expects ((((13 14) 9) 4 5) ((0 1) 6) 11 12) ==> ok
test (setter cadar), expects ((((13 14) 9) (2 3) 5) ((0 1) 6) 11 12) ==> ok
test (setter caddr), expects ((((13 14) 9) (2 3) 5) ((0 1) 6) (4 5) 12) ==> ok
test (setter cdaar), expects ((((13 14) 5 6) (2 3) 5) ((0 1) 6) (4 5) 12) ==> ok
test (setter cdadr), expects ((((13 14) 5 6) (2 3) 5) ((0 1) 7 8) (4 5) 12) ==> ok
test (setter cddar), expects ((((13 14) 5 6) (2 3) 9 10) ((0 1) 7 8) (4 5) 12) ==> ok
test (setter cdddr), expects ((((13 14) 5 6) (2 3) 9 10) ((0 1) 7 8) (4 5) -1 -2) ==> ok
test (setter caaaar), expects (((((1 3) 14) 5 6) (2 3) 9 10) ((0 1) 7 8) (4 5) -1 -2) ==> ok
test (setter caaadr), expects (((((1 3) 14) 5 6) (2 3) 9 10) (((2 3) 1) 7 8) (4 5) -1 -2) ==> ok
test (setter caadar), expects (((((1 3) 14) 5 6) ((0 1) 3) 9 10) (((2 3) 1) 7 8) (4 5) -1 -2) ==> ok
test (setter caaddr), expects (((((1 3) 14) 5 6) ((0 1) 3) 9 10) (((2 3) 1) 7 8) ((0 1) 5) -1 -2) ==> ok
test (setter cadaar), expects (((((1 3) 14) (0 1) 6) ((0 1) 3) 9 10) (((2 3) 1) 7 8) ((0 1) 5) -1 -2) ==> ok
test (setter cadadr), expects (((((1 3) 14) (0 1) 6) ((0 1) 3) 9 10) (((2 3) 1) (0 1) 8) ((0 1) 5) -1 -2) ==> ok
test (setter caddar), expects (((((1 3) 14) (0 1) 6) ((0 1) 3) (0 1) 10) (((2 3) 1) (0 1) 8) ((0 1) 5) -1 -2) ==> ok
test (setter cadddr), expects (((((1 3) 14) (0 1) 6) ((0 1) 3) (0 1) 10) (((2 3) 1) (0 1) 8) ((0 1) 5) (0 1) -2) ==> ok
test (setter cdaaar), expects (((((1 3) 0 1) (0 1) 6) ((0 1) 3) (0 1) 10) (((2 3) 1) (0 1) 8) ((0 1) 5) (0 1) -2) ==> ok
test (setter cdaadr), expects (((((1 3) 0 1) (0 1) 6) ((0 1) 3) (0 1) 10) (((2 3) 0 1) (0 1) 8) ((0 1) 5) (0 1) -2) ==> ok
test (setter cdadar), expects (((((1 3) 0 1) (0 1) 6) ((0 1) 0 1) (0 1) 10) (((2 3) 0 1) (0 1) 8) ((0 1) 5) (0 1) -2) ==> ok
test (setter cdaddr), expects (((((1 3) 0 1) (0 1) 6) ((0 1) 0 1) (0 1) 10) (((2 3) 0 1) (0 1) 8) ((0 1) 0 1) (0 1) -2) ==> ok
test (setter cddaar), expects (((((1 3) 0 1) (0 1) 0 1) ((0 1) 0 1) (0 1) 10) (((2 3) 0 1) (0 1) 8) ((0 1) 0 1) (0 1) -2) ==> ok
test (setter cddadr), expects (((((1 3) 0 1) (0 1) 0 1) ((0 1) 0 1) (0 1) 10) (((2 3) 0 1) (0 1) 0 1) ((0 1) 0 1) (0 1) -2) ==> ok
test (setter cdddar), expects (((((1 3) 0 1) (0 1) 0 1) ((0 1) 0 1) (0 1) 0 1) (((2 3) 0 1) (0 1) 0 1) ((0 1) 0 1) (0 1) -2) ==> ok
test (setter cddddr), expects (((((1 3) 0 1) (0 1) 0 1) ((0 1) 0 1) (0 1) 0 1) (((2 3) 0 1) (0 1) 0 1) ((0 1) 0 1) (0 1) 0 1) ==> ok
test (setter vector-ref), expects #(1 2 3 #f 5) ==> ok
test (setter string-ref), expects "abcQe" ==> ok
test (setter kar), expects (3 . 2) ==> ok
test set!, expects #f ==> ok
<srfi-26>----------------------------------------------------------------------
testing bindings in #<module srfi-26> ... ok
test cut list, expects () ==> ok
test cut list <...>, expects () ==> ok
test cut list 1, expects (1) ==> ok
test cut list <>, expects (1) ==> ok
test cut list <...>, expects (1) ==> ok
test cut list 1 2, expects (1 2) ==> ok
test cut list 1 <>, expects (1 2) ==> ok
test cut list 1 <...>, expects (1 2) ==> ok
test cut list 1 <...>, expects (1 2 3 4) ==> ok
test cut list 1 <> 3 <>, expects (1 2 3 4) ==> ok
test cut list 1 <> 3 <...>, expects (1 2 3 4 5 6) ==> ok
test cut (eval order), expects (ok) ==> ok
test cut (eval order), expects 2 ==> ok
test cute list, expects () ==> ok
test cute list <...>, expects () ==> ok
test cute list 1, expects (1) ==> ok
test cute list <>, expects (1) ==> ok
test cute list <...>, expects (1) ==> ok
test cute list 1 2, expects (1 2) ==> ok
test cute list 1 <>, expects (1 2) ==> ok
test cute list 1 <...>, expects (1 2) ==> ok
test cute list 1 <...>, expects (1 2 3 4) ==> ok
test cute list 1 <> 3 <>, expects (1 2 3 4) ==> ok
test cute list 1 <> 3 <...>, expects (1 2 3 4 5 6) ==> ok
test cute (eval order), expects (ok) ==> ok
test cute (eval order), expects 1 ==> ok
<srfi-29>----------------------------------------------------------------------
testing bindings in #<module srfi-29> ... ok
test localized-message (en), expects ("Its 12:00, Fred." "Goodbye, Fred.") ==> ok
test localized-message (fr), expects ("Fred, c'est 12:00." "Au revoir, Fred.") ==> ok
<srfi-30>----------------------------------------------------------------------
test srfi-30, expects 1 ==> ok
test srfi-30, expects (1) ==> ok
test srfi-30, multiline, expects (1) ==> ok
test srfi-30, multiline, expects (1) ==> ok
test srfi-30, multiline, expects () ==> ok
test srfi-30, nesting, expects (1) ==> ok
test srfi-30, nesting, expects (1) ==> ok
test srfi-30, nesting, expects (1) ==> ok
test srfi-30, intertwined, expects (1) ==> ok
test srfi-30, dot syntax, expects (1 . 1) ==> ok
test srfi-30, quasiquote, expects (1 #(2 3)) ==> ok
<srfi-31>----------------------------------------------------------------------
test srfi-31, expects 1 ==> ok
test srfi-31, expects 3628800 ==> ok
test srfi-31, expects "11111" ==> ok
<srfi-37>----------------------------------------------------------------------
test srfi-37 (short), expects ((i l b) ()) ==> ok
test srfi-37 (short, arg), expects ((i (o . "foo") l (d . "8")) ()) ==> ok
test srfi-37 (short, arg), expects (((o . "foo") (d . #f)) ("bar")) ==> ok
test srfi-37 (short, missing arg), expects (((o . "-d")) ("bar")) ==> ok
test srfi-37 (short, missing arg), expects (((o . #f)) ()) ==> ok
test srfi-37 (long, arg), expects ((l i (d . "v") b (d . #f)) ()) ==> ok
test srfi-37 (long, arg), expects ((l i (d . "v") b (d . #f)) ()) ==> ok
test srfi-37 (operand), expects ((i b) ("foo" "bar")) ==> ok
test srfi-37 (operand), expects ((i) ("foo" "-b" "bar")) ==> ok
test srfi-37 (operand), expects ((i b) ("-" "foo" "bar")) ==> ok
<srfi-42>----------------------------------------------------------------------
test do-ec, expects 1 ==> ok
test do-ec, expects 10 ==> ok
test do-ec, expects 45 ==> ok
test list-ec, expects (1) ==> ok
test list-ec, expects (0 1 2 3) ==> ok
test list-ec, expects ((0 0) (1 0) (1 1) (2 0) (2 1) (2 2)) ==> ok
test list-ec, expects ((0 0) (2 0) (2 1) (2 2) (4 0) (4 1) (4 2) (4 3) (4 4)) ==> ok
test list-ec, expects ((1 0) (1 1) (3 0) (3 1) (3 2) (3 3)) ==> ok
test list-ec, expects ((4 0) (4 1) (4 2) (4 3) (4 4)) ==> ok
test list-ec, expects ((0 0) (2 0) (2 1) (2 2) (4 0) (4 1) (4 2) (4 3) (4 4)) ==> ok
test list-ec, expects 10 ==> ok
test list-ec, expects (0 0 1) ==> ok
test append-ec, expects (a b) ==> ok
test append-ec, expects () ==> ok
test append-ec, expects (a b) ==> ok
test append-ec, expects (a b a b) ==> ok
test string-ec, expects "a" ==> ok
test string-ec, expects "" ==> ok
test string-ec, expects "a" ==> ok
test string-ec, expects "aa" ==> ok
test string-append-ec, expects "ab" ==> ok
test string-append-ec, expects "" ==> ok
test string-append-ec, expects "ab" ==> ok
test string-append-ec, expects "abab" ==> ok
test vector-ec, expects #(1) ==> ok
test vector-ec, expects #() ==> ok
test vector-ec, expects #(0) ==> ok
test vector-ec, expects #(0 1) ==> ok
test vector-of-length-ec, expects #(1) ==> ok
test vector-of-length-ec, expects #() ==> ok
test vector-of-length-ec, expects #(0) ==> ok
test vector-of-length-ec, expects #(0 1) ==> ok
test sum-ec, expects 1 ==> ok
test sum-ec, expects 0 ==> ok
test sum-ec, expects 0 ==> ok
test sum-ec, expects 1 ==> ok
test sum-ec, expects 3 ==> ok
test product-ec, expects 1 ==> ok
test product-ec, expects 1 ==> ok
test product-ec, expects 1 ==> ok
test product-ec, expects 1 ==> ok
test product-ec, expects 2 ==> ok
test product-ec, expects 6 ==> ok
test min-ec, expects 1 ==> ok
test min-ec, expects 0 ==> ok
test min-ec, expects 0 ==> ok
test max-ec, expects 1 ==> ok
test max-ec, expects 0 ==> ok
test max-ec, expects 1 ==> ok
test first-ec, expects 1 ==> ok
test first-ec, expects #f ==> ok
test first-ec, expects 0 ==> ok
test first-ec, expects 0 ==> ok
test first-ec, expects 0 ==> ok
test last-ec, expects 1 ==> ok
test last-ec, expects #f ==> ok
test last-ec, expects 0 ==> ok
test last-ec, expects 1 ==> ok
test any-ec, expects #f ==> ok
test any-ec, expects #t ==> ok
test any-ec, expects #f ==> ok
test any-ec, expects #t ==> ok
test every-ec, expects #f ==> ok
test every-ec, expects #t ==> ok
test every-ec, expects #t ==> ok
test every-ec, expects #t ==> ok
test every-ec, expects #f ==> ok
test fold-ec, expects 285 ==> ok
test fold3-ec, expects 284 ==> ok
test fold3-ec, expects infinity ==> ok
test :list, expects () ==> ok
test :list, expects (1) ==> ok
test :list, expects (1 2 3) ==> ok
test :list, expects (1 2) ==> ok
test :list, expects (1 2 3) ==> ok
test :string, expects () ==> ok
test :string, expects (#\1) ==> ok
test :string, expects (#\1 #\2 #\3) ==> ok
test :string, expects (#\1 #\2) ==> ok
test :string, expects (#\1 #\2 #\3) ==> ok
test :vector, expects () ==> ok
test :vector, expects (1) ==> ok
test :vector, expects (1 2 3) ==> ok
test :vector, expects (1 2) ==> ok
test :vector, expects (1 2 3) ==> ok
test :range, expects () ==> ok
test :range, expects () ==> ok
test :range, expects () ==> ok
test :range, expects (0) ==> ok
test :range, expects (0 1) ==> ok
test :range, expects (0 1 2) ==> ok
test :range, expects (1 2) ==> ok
test :range, expects (-2) ==> ok
test :range, expects () ==> ok
test :range, expects (1 3) ==> ok
test :range, expects (1 3 5) ==> ok
test :range, expects (5 3) ==> ok
test :range, expects (6 4 2) ==> ok
test :real-range, expects (0.0 1.0 2.0) ==> ok
test :real-range, expects (0.0 1.0 2.0) ==> ok
test :real-range, expects (0.0 1.0 2.0) ==> ok
test :char-range, expects "abcdefghijklmnopqrstuvwxyz" ==> ok
test :port, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test :generator, expects ((9 . 0) (8 . 1) (7 . 2) (6 . 3) (5 . 4) (4 . 5) (3 . 6) (2 . 7) (1 . 8) (0 . 9)) ==> ok
test :generator, expects ((9 . 0) (8 . 1) (7 . 2) (6 . 3) (5 . 4) (4 . 5) (3 . 6) (2 . 7) (1 . 8) (0 . 9)) ==> ok
test :do, expects (0 1 2 3) ==> ok
test :do, expects (10 9 8 7) ==> ok
test :let, expects (1) ==> ok
test :let, expects (2) ==> ok
test :let, expects (2) ==> ok
test :parallel, expects ((1 a) (2 b) (3 c)) ==> ok
test :until, expects (1 2 3 4 5) ==> ok
test :while, expects (1 2 3 4) ==> ok
test :until, expects (1 2 3 4 5) ==> ok
test :while and :parallel, expects ((1 1) (2 2) (3 3) (4 4)) ==> ok
test :until and :parallel, expects ((1 1) (2 2) (3 3) (4 4) (5 5)) ==> ok
test :while stopping loop, expects 5 ==> ok
test :until stopping loop, expects 5 ==> ok
test :while stopping loop, expects 5 ==> ok
test :until stopping loop, expects 5 ==> ok
test : list, expects (a b) ==> ok
test : list, expects (a b c d) ==> ok
test : string, expects (#\a #\b) ==> ok
test : string, expects (#\a #\b #\c #\d) ==> ok
test : vector, expects (a b) ==> ok
test : vector, expects (a b c) ==> ok
test : range, expects () ==> ok
test : range, expects (0) ==> ok
test : range, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test : range, expects (1) ==> ok
test : range, expects (1) ==> ok
test : range, expects (1 4 7) ==> ok
test : real-range, expects (0.0 0.2 0.4 0.6 0.8) ==> ok
test : char, expects (#\a #\b #\c) ==> ok
test : port, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test : port, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test :list index, expects ((a 0) (b 1)) ==> ok
test :string index, expects ((#\a 0)) ==> ok
test :vector index, expects ((a 0)) ==> ok
test :range index, expects ((0 0) (-1 1) (-2 2)) ==> ok
test :real-range index, expects ((0.0 0) (0.2 1) (0.4 2) (0.6 3) (0.8 4)) ==> ok
test :char-range index, expects ((#\a 0) (#\b 1) (#\c 2)) ==> ok
test : index, expects ((a 0) (b 1) (c 2) (d 3)) ==> ok
test : index port, expects ((0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9)) ==> ok
test example 1, expects (0 1 4 9 16) ==> ok
test example 2, expects ((1 0) (2 0) (2 1) (3 0) (3 1) (3 2)) ==> ok
test example 3, expects ((#\a 0) (#\b 1) (#\c 2)) ==> ok
test example 4, expects ((#\a . 0) (#\b . 1)) ==> ok
test :range :range, expects (0 0 1 0 1 2 0 1 2 3) ==> ok
test :list :, expects (0 1 #\2 #\3 4) ==> ok
test :parallel :integers :do, expects ((0 10) (1 9) (2 8) (3 7) (4 6)) ==> ok
test factorial, expects 1 ==> ok
test factorial, expects 1 ==> ok
test factorial, expects 6 ==> ok
test factorial, expects 120 ==> ok
test eratosthenes, expects (2 3 5 7 11 13 17 19 23 29 31 37 41 43 47) ==> ok
test eratosthenes, expects 9592 ==> ok
test pythagoras, expects ((3 4 5) (5 12 13) (6 8 10) (9 12 15)) ==> ok
test pythagoras, expects 127 ==> ok
test qsort, expects (1 1 2 2 3 3 4 4 5 5) ==> ok
test pi-BBP, expects 40413742330349316707/12864093722915635200 ==> ok
test read-lines, expects ("0\n" "1\n" "2\n" "3\n" "4\n" "5\n" "6\n" "7\n" "8\n" "9\n") ==> ok
<srfi-60>----------------------------------------------------------------------
testing bindings in #<module srfi-60> ... ok
test bitwise-if, expects 102 ==> ok
test log2-binary-factors(0), expects -1 ==> ok
test log2-binary-factors(1), expects 0 ==> ok
test log2-binary-factors(2), expects 1 ==> ok
test log2-binary-factors(3), expects 0 ==> ok
test log2-binary-factors(4), expects 2 ==> ok
test log2-binary-factors(5), expects 0 ==> ok
test log2-binary-factors(6), expects 1 ==> ok
test log2-binary-factors(7), expects 0 ==> ok
test log2-binary-factors(8), expects 3 ==> ok
test log2-binary-factors(9), expects 0 ==> ok
test log2-binary-factors(10), expects 1 ==> ok
test log2-binary-factors(11), expects 0 ==> ok
test log2-binary-factors(12), expects 2 ==> ok
test log2-binary-factors(13), expects 0 ==> ok
test log2-binary-factors(14), expects 1 ==> ok
test log2-binary-factors(15), expects 0 ==> ok
test log2-binary-factors(16), expects 4 ==> ok
test log2-binary-factors(-1), expects 0 ==> ok
test log2-binary-factors(-2), expects 1 ==> ok
test log2-binary-factors(-3), expects 0 ==> ok
test log2-binary-factors(-4), expects 2 ==> ok
test log2-binary-factors(-5), expects 0 ==> ok
test log2-binary-factors(-6), expects 1 ==> ok
test log2-binary-factors(-7), expects 0 ==> ok
test log2-binary-factors(-8), expects 3 ==> ok
test log2-binary-factors(-9), expects 0 ==> ok
test log2-binary-factors(-10), expects 1 ==> ok
test log2-binary-factors(-11), expects 0 ==> ok
test log2-binary-factors(-12), expects 2 ==> ok
test log2-binary-factors(-13), expects 0 ==> ok
test log2-binary-factors(-14), expects 1 ==> ok
test log2-binary-factors(-15), expects 0 ==> ok
test log2-binary-factors(-16), expects 4 ==> ok
test rotate-bit-field("100",3,4,0), expects "100" ==> ok
test rotate-bit-field("100",3,0,4), expects "10" ==> ok
test rotate-bit-field("100",-1,0,4), expects "10" ==> ok
test rotate-bit-field("100",10,0,4), expects "1" ==> ok
test rotate-bit-field("110100100010000",-1,5,9), expects "110100010010000" ==> ok
test rotate-bit-field("110100100010000",1,5,9), expects "110100000110000" ==> ok
test reverse-bit-field("10100111",8,0), expects "10100111" ==> ok
test reverse-bit-field("10100111",0,8), expects "11100101" ==> ok
test reverse-bit-field("10100111",1,5), expects "10111001" ==> ok
test integer->list, expects (#t #f #f #t) ==> ok
test integer->list, expects (#f #f #t #f #f #t) ==> ok
test list->integer, expects 9 ==> ok
test list->integer, expects 9 ==> ok
test list->integer, expects 13835058058503389185 ==> ok
test booleans->integer, expects 9 ==> ok
<srfi-98>----------------------------------------------------------------------
testing bindings in #<module srfi-98> ... ok
passed.
Testing object system =========================================================
<class definition>-------------------------------------------------------------
test define-class <x>, expects <x> ==> ok
test define-class <x>, expects 3 ==> ok
test define-class <x>, expects #<class <class>> ==> ok
test define-class <x>, expects (<x> <object> <top>) ==> ok
test define-class <y>, expects 5 ==> ok
test define-class <y>, expects #<class <class>> ==> ok
test define-class <y>, expects (<y> <x> <object> <top>) ==> ok
test define-class <z>, expects 0 ==> ok
test define-class <z>, expects #<class <class>> ==> ok
test define-class <z>, expects (<z> <object> <top>) ==> ok
test define-class <w>, expects 6 ==> ok
test define-class <w>, expects #<class <class>> ==> ok
test define-class <w>, expects (<w> <z> <y> <x> <object> <top>) ==> ok
test define-class <w2>, expects (<w2> <y> <x> <z> <object> <top>) ==> ok
<instancing>-------------------------------------------------------------------
test make <x>, expects #<class <x>> ==> ok
test make <x>, expects #<class <x>> ==> ok
test slot-ref, expects (4 5 6) ==> ok
test slot-ref, expects (7 8 9) ==> ok
test slot-ref-using-class, expects (4 5 6) ==> ok
test slot-ref-using-class, expects #<error> ==> ok
test slot-ref-using-accessor, expects (7 8 9) ==> ok
test slot-ref-using-accessor, expects #<error> ==> ok
test slot-set-using-class!, expects (-4 -5 -6) ==> ok
test slot-set-using-class!, expects #<error> ==> ok
test slot-set-using-accessor!, expects (-7 -8 -9) ==> ok
test slot-ref-using-accessor!, expects #<error> ==> ok
test slot-pop! (unbound error), expects #<error> ==> ok
test slot-pop! (unbound but fallback), expects ok ==> ok
test slot-push!, expects (1) ==> ok
test slot-push!, expects (2 1) ==> ok
test slot-pop!, expects 2 ==> ok
test slot-pop!, expects 1 ==> ok
test slot-pop!, expects empty ==> ok
test slot-push!, expects (1 . z) ==> ok
test slot-pop!, expects 1 ==> ok
test slot-pop!, expects #<error> ==> ok
test slot-pop!, expects empty ==> ok
<slot initialization>----------------------------------------------------------
test make <r>, expects (4 5) ==> ok
test make <r> :a, expects (9 5) ==> ok
test make <r> :a :b, expects (20 100) ==> ok
<slot allocations>-------------------------------------------------------------
test make <s>, expects (#\i #\c #\s (#\i . #\c)) ==> ok
test slot-set! :instance, expects ((#\I #\c #\s (#\I . #\c)) (#\i #\c #\s (#\i . #\c))) ==> ok
test slot-set! :class, expects ((#\I #\C #\s (#\I . #\C)) (#\i #\C #\s (#\i . #\C))) ==> ok
test slot-set! :each-subclass, expects ((#\I #\C #\S (#\I . #\C)) (#\i #\C #\S (#\i . #\C))) ==> ok
test slot-set! :virtual, expects ((i c #\S (i . c)) (#\i c #\S (#\i . c))) ==> ok
test make <ss>, expects (("i" "c" "s" ("i" . "c")) (i "c" #\S (i . "c"))) ==> ok
test slot-set! :class, expects (("i" "C" "s" ("i" . "C")) (i "C" #\S (i . "C"))) ==> ok
test slot-set! :each-subclass, expects (("i" "C" "s" ("i" . "C")) (i "C" "S" (i . "C"))) ==> ok
test slot-set! :each-subclass, expects (("i" "C" 5 ("i" . "C")) (i "C" "S" (i . "C"))) ==> ok
test make <ss> :v, expects ((1 0 5 (1 . 0)) ("i" 0 5 ("i" . 0))) ==> ok
test class-slot-ref, expects (0 "S" 0 5) ==> ok
test class-slot-set!, expects (100 99 100 5) ==> ok
test class-slot-set!, expects (101 99 101 55) ==> ok
test slot-bound? protocol, expects #f ==> ok
test slot-bound? protocol, expects (#t 8) ==> ok
<next method>------------------------------------------------------------------
test next method, expects (y-in (x-in fallback x-out) y-out) ==> ok
test next-method, expects (w-in (z-in (y-in (x-in fallback x-out) y-out) z-out) w-out) ==> ok
test next-method, expects (w2-in (y-in (x-in (z-in fallback z-out) x-out) y-out) w2-out) ==> ok
test next-method, expects (y1-in (y*-in t* y*-out) y1-out) ==> ok
test next-method, expects (y-in (y*-in (x-in (t*-in fallback t*-out) x-out) y*-out) y-out) ==> ok
<method sorting>---------------------------------------------------------------
test method sorting, expects 2 ==> ok
test method sorting, expects 1 ==> ok
<setter method definition>-----------------------------------------------------
test setter of s-get-i(<s>), expects ("i" "j") ==> ok
test setter of s-get-i(<ss>), expects ("i" ("j" . "j")) ==> ok
<method optional arguments>----------------------------------------------------
test method optarg (no optarg), expects x ==> ok
test method optarg (optarg), expects (0 1 2 ()) ==> ok
test method optarg (optarg), expects (a b 2 ()) ==> ok
test method optarg (optarg), expects (a b 4 (:z 4)) ==> ok
<module and accessor>----------------------------------------------------------
test module and accessor, expects a ==> ok
test module and accessor, expects ei ==> ok
<class redefinition (part 1)>--------------------------------------------------
test simple redefinition of <x>, expects #f ==> ok
test simple redefinition of <x>, expects (#t #f #t #f) ==> ok
test subclass redefinition <y> (links), expects (#f #f #f #f #f) ==> ok
test subclass redefinition <y> (slots), expects ((a b c) (a b c x) (c d e a b) (c d e a b x)) ==> ok
test subclass redefinition <w> (links), expects (#f #f #f #f #f) ==> ok
test subclass redefinition <w> (slots), expects ((e f c d a b) (e f c d a b x) (e f c d a b) (e f c d a b x)) ==> ok
test subclass redefinition (hierarchy), expects ((#0=#<class <x>> #1=#<class <object>> #2=#<class <top>>) (#3=#<class <y>> #0# #1# #2#) (#<class <w>> #4=#<class <z>> #3# #0# #1# #2#) (#<class <w2>> #3# #0# #4# #1# #2#)) ==> ok
test subclass redefinition (hierarchy, orig), expects ((#0=#<class <x> (redefined)> #1=#<class <object>> #2=#<class <top>>) (#3=#<class <y> (redefined)> #0# #1# #2#) (#<class <w> (redefined)> #4=#<class <z>> #3# #0# #1# #2#) (#<class <w2> (redefined)> #3# #0# #4# #1# #2#)) ==> ok
test method link fix, expects (#t #t #t #t #t #t #t) ==> ok
test instance update (x1), expects (#t -4 -5 -6 #f) ==> ok
test instance update (y1), expects (#f 0 1 2 3 4) ==> ok
test redefine <x> again, expects (a c x) ==> ok
test instance update (x1), expects (1 #f -6 3) ==> ok
test instance update (x2) - cascade, expects (#t -7 #f -9 3) ==> ok
test redefine <y>, expects (a e c x) ==> ok
test instance update (y2) - cascade, expects (5 7 9 3) ==> ok
test redefine <y> without inheriting <x>, expects (a e) ==> ok
test link consistency <y> vs <x>, expects (#f #f #f) ==> ok
test instance update (y1), expects (0 4) ==> ok
test subclass redefinition <w>, expects (e f a) ==> ok
test instance update (w1), expects (#f #t #t 100 104 105) ==> ok
test instance update (w2), expects (#f #t #t -30 #f #f) ==> ok
test method link fix, expects (#t #t #t #t #t #t #t) ==> ok
<object comparison protocol>---------------------------------------------------
test object-equal?, expects #t ==> ok
test object-equal?, expects #f ==> ok
test object-equal?, expects #t ==> ok
test object-equal?, expects #f ==> ok
test object-compare, expects -1 ==> ok
test object-compare, expects 0 ==> ok
test object-compare, expects 1 ==> ok
test object-compare, expects -1 ==> ok
test object-compare, expects 0 ==> ok
test object-compare, expects 1 ==> ok
test object-compare, expects -1 ==> ok
test object-compare, expects 0 ==> ok
test object-compare, expects 1 ==> ok
test object-compare, expects #<error> ==> ok
test object-compare, expects #<error> ==> ok
test object-compare, expects #<error> ==> ok
test object-compare, expects -1 ==> ok
test object-compare, expects 0 ==> ok
test object-compare, expects 1 ==> ok
<object hash protocol>---------------------------------------------------------
test object-hash, expects #<error> ==> ok
test object-hash, expects 1277979686 ==> ok
test object-hash, expects 1277979686 ==> ok
test object-hash, expects 584 ==> ok
test object-hash, expects 3106 ==> ok
test object-hash, expects #f ==> ok
test a => 8, expects 8 ==> ok
test b => non, expects #t ==> ok
test b => error, expects #<error> ==> ok
test b => "b", expects "b" ==> ok
test 2.0 => #C, expects #\C ==> ok
test 2.0 => #c, expects #\c ==> ok
test 87592876592374659237845692374523694756 => 0, expects 0 ==> ok
test 87592876592374659237845692374523694756 => -1, expects -1 ==> ok
test equal? test, expects 5 ==> ok
test equal? test, expects 6 ==> ok
test equal? test, expects 7 ==> ok
test hash-table-values, expects #t ==> ok
test delete!, expects #f ==> ok
<object-apply protocol>--------------------------------------------------------
test object-apply, expects #f ==> ok
test object-apply, expects a ==> ok
test object-apply, expects (d b c a q) ==> ok
test object-apply, expects ((d b c a q) #(d b c a q)) ==> ok
<metaclass>--------------------------------------------------------------------
test metaclass, expects (<yy> <xx>) ==> ok
test metaclass, expects (1 2 3) ==> ok
test metaclass, expects (1 2 3 4 5 6) ==> ok
test metaclass, expects (1 2 3) ==> ok
test metaclass, expects (<vv> <yy> <xx>) ==> ok
test metaclass, expects #t ==> ok
test metaclass, expects (1 2 3 4 5 6) ==> ok
test metaclass, expects (<ww> <vv> <yy> <xx>) ==> ok
<metaclass w/ slots>-----------------------------------------------------------
test class slot in meta, expects ("Doc doc" "sub") ==> ok
test class slot in meta (sub), expects (#f "sub" xtra) ==> ok
<metaclass redefintiion>-------------------------------------------------------
test redefinition of metaclass, expects ("Doc doc" "no doc" "no doc") ==> ok
test redefinition of metaclass (sub), expects (#f "no doc" xtra) ==> ok
test redefinition of metaclass and existing instance, expects (a B c) ==> ok
test redefinition of metaclass and existing instance, expects (A b C x Y z) ==> ok
<metaclass/singleton>----------------------------------------------------------
test singleton, expects #t ==> ok
test singleton, expects #t ==> ok
test singleton, expects 5 ==> ok
test singleton, expects #f ==> ok
<metaclass/validator>----------------------------------------------------------
test validator, expects "doo" ==> ok
test validator, expects "foo" ==> ok
test validator, expects "1234" ==> ok
test validator, expects 99 ==> ok
test validator, expects 55 ==> ok
test validator, expects #<error> ==> ok
test validator, expects #<error> ==> ok
test validator/slot-bound, expects #f ==> ok
test validator/slot-bound, expects foo ==> ok
test validator/slot-bound, expects #t ==> ok
test validator/slot-bound, expects "oops" ==> ok
<metaclass/propagate>----------------------------------------------------------
test propagate ref default, expects (0 0) ==> ok
test propagate ref init, expects (3 1) ==> ok
test propagate ref init2, expects (99 99) ==> ok
test propagate set, expects (888 888) ==> ok
test propagate set, expects (999 999) ==> ok
test propagate-validator, expects "999" ==> ok
<metaclass/instance-pool>------------------------------------------------------
test instance-pool (pool), expects #t ==> ok
test instance-pool-find, expects #<<pool-x> 0x92e0928> ==> ok
test instance-pool-find, expects #<<pool-z> 0x92e06c0> ==> ok
test instance-pool-find, expects #<<pool-y> 0x92e03a0> ==> ok
test instance-pool-find, expects #f ==> ok
test instance-pool-fold, expects (#<<pool-x> 0x92e0928> #<<pool-z> 0x92e06c0> #<<pool-x> 0x92e2d40> #<<pool-z> 0x92e2998>) ==> ok
test instance-pool-map, expects (#<<pool-x> 0x92e0928> #<<pool-z> 0x92e06c0> #<<pool-x> 0x92e2d40> #<<pool-z> 0x92e2998>) ==> ok
test instance-pool-for-each, expects (#<<pool-x> 0x92e0928> #<<pool-z> 0x92e06c0> #<<pool-x> 0x92e2d40> #<<pool-z> 0x92e2998>) ==> ok
test instance-pool-remove!, expects #f ==> ok
test instance-pool-remove!, expects #<<pool-z> 0x92e06c0> ==> ok
test instance-pool-remove!, expects #f ==> ok
<class redefinition (part 2)>--------------------------------------------------
test customizing change-class, expects ("Alan Pangborn" "Alan" "Pangborn" "County Sheriff" "member") ==> ok
test inserting parent class, expects ("Alan Pangborn" "Alan" "Pangborn" "County Sheriff" "member") ==> ok
test inserting parent class, expects ("Mike Noonan" "Mike" "Noonan" "Writer" "member") ==> ok
test changing parent's metaclass, expects ("Alan Pangborn" "Alan" "Pangborn" "County Sheriff" unknown) ==> ok
test changing parent's metaclass, expects (#f male) ==> ok
test reincarnating name slot, expects ("Alan Pangborn" "County Sheriff" unknown "alan") ==> ok
test reincarnating name slot, expects ("Mike Noonan" "Writer" male "member") ==> ok
test reorganizing structure, expects ("Alan Pangborn" "County Sheriff" unknown "alan") ==> ok
test reorganizing structure, expects ("Mike Noonan" "Writer" male "alan") ==> ok
test reorganizing structure, expects ("Ted Brautigan" "Breaker" unknown "alan") ==> ok
<method application customization>---------------------------------------------
test <wrapper-generic>, expects "aBciIiXyZ" ==> ok
test <coercer-generic>, expects 3 ==> ok
<apply special path>-----------------------------------------------------------
test apply special path (normal->apply), expects (z c b a) ==> ok
test apply special path (apply->normal), expects (z c b a) ==> ok
<applicable?>------------------------------------------------------------------
test applicable? cons(), expects #f ==> ok
test applicable? cons(<top>), expects #f ==> ok
test applicable? cons(<top> <top>), expects #t ==> ok
test applicable? cons(<top> <top> <top>), expects #f ==> ok
test applicable? list(), expects #t ==> ok
test applicable? list(<top>), expects #t ==> ok
test applicable? list(<top> <top>), expects #t ==> ok
test applicable? apply(), expects #f ==> ok
test applicable? apply(<top>), expects #f ==> ok
test applicable? apply(<top> <top>), expects #t ==> ok
test applicable? ref(), expects #f ==> ok
test applicable? ref(<boolean>), expects #f ==> ok
test applicable? ref(<boolean> <top>), expects #f ==> ok
test applicable? ref(<top>), expects #f ==> ok
test applicable? ref(<top> <symbol>), expects #t ==> ok
test applicable? ref(<top> <symbol> <top>), expects #t ==> ok
test applicable? ref(<vector>), expects #f ==> ok
test applicable? ref(<vector> <integer>), expects #t ==> ok
test applicable? ref(<vector> <integer> <integer>), expects #f ==> ok
test applicable? ref(<vector> <integer> <top>), expects #f ==> ok
test applicable? #/a/(), expects #f ==> ok
test applicable? #/a/(<string>), expects #t ==> ok
test applicable? #/a/(<integer>), expects #f ==> ok
passed.
Testing exceptions ============================================================
<bare constructors>------------------------------------------------------------
test make <error>, expects (#t #t #t #f) ==> ok
test make <message-condition>, expects "huge" ==> ok
test make <error>, expects "hoge" ==> ok
test make <system-error>, expects ("oops" 12) ==> ok
<srfi-35 constructors, predicates and accessors>-------------------------------
test make-condition <error>, expects (#t #t #f "moo") ==> ok
test make-condition <port-error>, expects (#t #t #t #f "moo" #<iport (standard input) 0x8e0bf50>) ==> ok
test make-compound-condition, expects (#t #t #t "sys" 12 #<iport (standard input) 0x8e0bf50>) ==> ok
test make-compound-condition, expects (#t #t #t "io" 12 #<iport (standard input) 0x8e0bf50>) ==> ok
test make-compound-condition, expects (#t #t #t "message" 12 #<iport (standard input) 0x8e0bf50>) ==> ok
test extract-condition, expects (("message") ("message" #<iport (standard input) 0x8e0bf50>) ("message" 12)) ==> ok
<srfi-35 style condition definitions>------------------------------------------
test v1, expects (#t #t #f "V1" "a1") ==> ok
test v2, expects (#t #f #t "V2" "b2") ==> ok
test v3, expects (#t #t #t "V3/1" "a3" "b3") ==> ok
test v4, expects (#t #t #t "V1" "a1" "b2") ==> ok
test v5, expects (#t #t #t "V2" "a3" "b2") ==> ok
test error (&c1), expects "ok" ==> ok
<guard>------------------------------------------------------------------------
test guard, expects (symbol . a) ==> ok
test guard, expects caught-error ==> ok
test guard, expects caught-error ==> ok
test guard (uncaught error), expects #<error> ==> ok
test guard (uncaught error), expects (else . 4) ==> ok
test guard (subtype), expects read-error ==> ok
test guard (nested), expects exn ==> ok
test guard (compound), expects read-error ==> ok
test guard w/dynamic-wind, expects ((b a) (b a)) ==> ok
<unwind-protect>---------------------------------------------------------------
test unwind-protect (success), expects (e d c z b a) ==> ok
test unwind-protect (raise), expects (boo e d b a) ==> ok
test unwind-protect (error), expects (boo e d b a) ==> ok
test unwind-protect (restart), expects (e d c a d z b a) ==> ok
<subtype>----------------------------------------------------------------------
test <my-error>, expects (#t "msg" "info") ==> ok
test catching <my-error>, expects (caught . "ok") ==> ok
test <my-exc>, expects (#t #f type) ==> ok
test catching <my-exc>, expects exception ==> ok
<combinations>-----------------------------------------------------------------
test guarding read-error, expects "Warning: read error:(input string port):1" ==> ok
test guarding read-error (2), expects "Warning: read error:(input string port):1" ==> ok
passed.
Testing lazy evaluation =======================================================
<lazy, delay & force>----------------------------------------------------------
test simple delay, expects 3 ==> ok
test delay w/state, expects 3 ==> ok
test delay recursive, expects 6 ==> ok
test delay compilation, expects 3 ==> ok
test memoize 1, expects 1 ==> ok
test memoize 2, expects 1 ==> ok
test memoize 3, expects 1 ==> ok
test memoize 4, expects 5 ==> ok
test reentrancy 1, expects second ==> ok
test reentrancy 2, expects (5 0 10) ==> ok
<lazy pairs>-------------------------------------------------------------------
test pair?, expects #t ==> ok
test car, expects 0 ==> ok
test cdr, expects () ==> ok
test lazyness, expects 0 ==> ok
test lazyness, expects 1 ==> ok
test lazyness, expects #<error> ==> ok
test lazyness string?, expects #f ==> ok
test lazyness pair?, expects #<error> ==> ok
test lazyness list?, expects #<error> ==> ok
test apply robustness, expects (0) ==> ok
test apply robustness, expects (0 1) ==> ok
test apply robustness, expects #<error> ==> ok
test object-apply robustness, expects #<error> ==> ok
test eq? doesn't force lazy pair, expects #f ==> ok
test eqv? doesn't force lazy pair, expects #f ==> ok
test forcing lazy pair doen't change the identity, expects #t ==> ok
test lazy pair and mutation, expects (1) ==> ok
test lazy pair and mutation, expects (0 . 1) ==> ok
test class-of, expects #<class <pair>> ==> ok
test is-a?, expects #f ==> ok
test is-a?, expects #t ==> ok
test memq, expects #t ==> ok
test memq (lazyness), expects #t ==> ok
test memq, expects #f ==> ok
test memv, expects #t ==> ok
test memv (lazyness), expects #t ==> ok
test memv, expects #f ==> ok
test assq, expects (c . 2) ==> ok
test assq (lazyness), expects (b . 1) ==> ok
test assq, expects #f ==> ok
test assv, expects (c . 2) ==> ok
test assv (lazyness), expects (b . 1) ==> ok
test assv, expects #f ==> ok
test reverse, expects (4 3 2 1 0) ==> ok
test append, expects (0 1 2 0 1 2 3 0 1 2 3 4) ==> ok
test APPEND instruction for quasiquoting, expects (0 1 2 0 1 2 3 0 1 2 3 4) ==> ok
test APP-VEC instruction for quasiquoting, expects #(0 1 2 0 1 2 3 0 1 2 3 4) ==> ok
test CONS instruction, expects (2 1 . 0) ==> ok
test CAR-PUSH instruction, expects 1 ==> ok
test CDR-PUSH instruction, expects #t ==> ok
test length, expects 10 ==> ok
test fold, expects 45 ==> ok
test equal?, expects #t ==> ok
test liota, expects (0 1 2 3 4) ==> ok
test liota, expects (0.0 1.0 2.0 3.0 4.0) ==> ok
test liota, expects (0 1 2 3 4) ==> ok
test liota, expects (1/2 7/6 11/6 5/2 19/6) ==> ok
test liota, expects (1.0 0.9 0.8 0.7 0.6) ==> ok
test lrange, expects (1 2 3 4 5) ==> ok
test lrange, expects (1 2 3 4 5) ==> ok
test lrange, expects (1 13/7 19/7 25/7 31/7 37/7) ==> ok
test lrange, expects (1.0 1.5 2.0 2.5) ==> ok
test interference with partcont, expects (z 0 a 1 b 2 c 3 d 4 e 5) ==> ok
test corecursion with lcons, expects (1 2 3 5 8 13 21 34 55 89 144 233 377 610 987) ==> ok
test corecursion with lcons, mixed, expects (1 2 3 5 8 13 21 34 55 89 144 233 377 610 987) ==> ok
test corecursion doesn't allow dotted list, expects (1 2 3 5 8 13 21 34 55 89) ==> ok
test make sure internal stuff won't leak out, expects (3) ==> ok
test catch recursive forcing a lazy-pair, expects #t ==> ok
test lcons*, expects 1 ==> ok
test lcons*, expects #<error> ==> ok
passed.
Testing regexp ================================================================
<regexp-parse>-----------------------------------------------------------------
test regexp-parse "a", expects (0 #f #\a) ==> ok
test regexp-parse "ab", expects (0 #f #\a #\b) ==> ok
test regexp-parse "(?:ab)", expects (0 #f (seq #\a #\b)) ==> ok
test regexp-parse "(a)", expects (0 #f (1 #f #\a)) ==> ok
test regexp-parse "a?", expects (0 #f (rep 0 1 #\a)) ==> ok
test regexp-parse "a*", expects (0 #f (rep 0 #f #\a)) ==> ok
test regexp-parse "a+", expects (0 #f (rep 1 #f #\a)) ==> ok
test regexp-parse "a{3,5}", expects (0 #f (rep 3 5 #\a)) ==> ok
test regexp-parse "a{3}", expects (0 #f (rep 3 3 #\a)) ==> ok
test regexp-parse "a|b", expects (0 #f (alt #\a #\b)) ==> ok
test regexp-parse "[ab]", expects (0 #f #[ab]) ==> ok
test regexp-parse "[^ab]", expects (0 #f (comp . #[ab])) ==> ok
test regexp-parse ".", expects (0 #f any) ==> ok
test regexp-parse "^", expects (0 #f bol) ==> ok
test regexp-parse "$", expects (0 #f eol) ==> ok
test regexp-parse "\b", expects (0 #f wb) ==> ok
test regexp-parse "\B", expects (0 #f nwb) ==> ok
test regexp-parse "(?>a)", expects (0 #f (once #\a)) ==> ok
test regexp-parse "a*+", expects (0 #f (once (rep 0 #f #\a))) ==> ok
test regexp-parse "a++", expects (0 #f (once (rep 1 #f #\a))) ==> ok
test regexp-parse "a?+", expects (0 #f (once (rep 0 1 #\a))) ==> ok
test regexp-parse "(?i:a)", expects (0 #f (seq-uncase #\a)) ==> ok
test regexp-parse "(?-i:a)", expects (0 #f (seq-case #\a)) ==> ok
test regexp-parse "(?=a)", expects (0 #f (assert #\a)) ==> ok
test regexp-parse "(?!a)", expects (0 #f (nassert #\a)) ==> ok
test regexp-parse "(?<=ab)", expects (0 #f (assert (lookbehind #\a #\b))) ==> ok
test regexp-parse "(?<!ab)", expects (0 #f (nassert (lookbehind #\a #\b))) ==> ok
test regexp-parse "(?<name>a)", expects (0 #f (1 name #\a)) ==> ok
test regexp-parse "(?(?=)y)", expects (0 #f (cpat (assert) (#\y) #f)) ==> ok
test regexp-parse "(?(?=)y|n)", expects (0 #f (cpat (assert) (#\y) (#\n))) ==> ok
test regexp-parse "(?(?<=)y)", expects (0 #f (cpat (assert (lookbehind)) (#\y) #f)) ==> ok
test regexp-parse "(?(?<=)y|n)", expects (0 #f (cpat (assert (lookbehind)) (#\y) (#\n))) ==> ok
test regexp-parse "()(?(1)y)", expects (0 #f (1 #f) (cpat 1 (#\y) #f)) ==> ok
test regexp-parse "()(?(1)y|n)", expects (0 #f (1 #f) (cpat 1 (#\y) (#\n))) ==> ok
test regexp-parse "()\1", expects (0 #f (1 #f) (backref . 1)) ==> ok
test regexp-parse "(?<name>)\k<name>", expects (0 #f (1 name) (backref . 1)) ==> ok
test regexp-parse "(?<name>)(?<name>)\k<name>", expects (0 #f (1 name) (2 name) (alt (backref . 2) (backref . 1))) ==> ok
<regexp-unparse>---------------------------------------------------------------
test regexp-unparse "", expects (0 #f) ==> ok
test regexp-unparse "a", expects (0 #f #\a) ==> ok
test regexp-unparse "ab", expects (0 #f #\a #\b) ==> ok
test regexp-unparse "a*", expects (0 #f (rep-while 0 #f #\a)) ==> ok
test regexp-unparse "a+", expects (0 #f (rep-while 1 #f #\a)) ==> ok
test regexp-unparse "a?", expects (0 #f (rep-while 0 1 #\a)) ==> ok
test regexp-unparse "ab*", expects (0 #f #\a (rep-while 0 #f #\b)) ==> ok
test regexp-unparse "ab+", expects (0 #f #\a (rep-while 1 #f #\b)) ==> ok
test regexp-unparse "ab?", expects (0 #f #\a (rep-while 0 1 #\b)) ==> ok
test regexp-unparse "a*b", expects (0 #f (rep-while 0 #f #\a) #\b) ==> ok
test regexp-unparse "a+b", expects (0 #f (rep-while 1 #f #\a) #\b) ==> ok
test regexp-unparse "a?b", expects (0 #f (rep-while 0 1 #\a) #\b) ==> ok
test regexp-unparse "a{3}", expects (0 #f (rep-while 3 3 #\a)) ==> ok
test regexp-unparse "a{2,4}", expects (0 #f (rep-while 2 4 #\a)) ==> ok
test regexp-unparse "a{3,}", expects (0 #f (rep-while 3 #f #\a)) ==> ok
test regexp-unparse "a|b", expects (0 #f (alt #\a #\b)) ==> ok
test regexp-unparse "a|b|c", expects (0 #f (alt #\a #\b #\c)) ==> ok
test regexp-unparse "^ab", expects (0 #f bol #\a #\b) ==> ok
test regexp-unparse "^a|b", expects (0 #f (alt (seq bol #\a) #\b)) ==> ok
test regexp-unparse "^a|b$", expects (0 #f (alt (seq bol #\a) (seq #\b eol))) ==> ok
test regexp-unparse ".", expects (0 #f any) ==> ok
test regexp-unparse "\\.", expects (0 #f #\.) ==> ok
test regexp-unparse "\\**", expects (0 #f (rep-while 0 #f #\*)) ==> ok
test regexp-unparse "\\(\\)\\{\\}\\[\\]", expects (0 #f #\( #\) #\{ #\} #\[ #\]) ==> ok
test regexp-unparse "\\bfoo\\B", expects (0 #f wb #\f #\o #\o nwb) ==> ok
test regexp-unparse "[a-z]", expects (0 #f #[a-z]) ==> ok
test regexp-unparse "[^a-z]", expects (0 #f (comp . #[a-z])) ==> ok
test regexp-unparse "[a-z]+", expects (0 #f (rep-while 1 #f #[a-z])) ==> ok
test regexp-unparse "[a^ef-]", expects (0 #f #[\-^aef]) ==> ok
test regexp-unparse "[a]", expects (0 #f #[a]) ==> ok
test regexp-unparse "[.]", expects (0 #f #[.]) ==> ok
test regexp-unparse "[\\[]", expects (0 #f #[\[]) ==> ok
test regexp-unparse "[\\^]", expects (0 #f #[\^]) ==> ok
test regexp-unparse "(a)(b)", expects (0 #f (1 #f #\a) (2 #f #\b)) ==> ok
test regexp-unparse "(a|b)c(d)", expects (0 #f (1 #f (alt #\a #\b)) #\c (2 #f #\d)) ==> ok
test regexp-unparse "(a(b(c|d)|e))f", expects (0 #f (1 #f #\a (2 #f (alt (seq #\b (3 #f (alt #\c #\d))) #\e))) #\f) ==> ok
test regexp-unparse "(?:abc)*", expects (0 #f (rep-while 0 #f #\a #\b #\c)) ==> ok
test regexp-unparse "(ab(?:cd)?e{3,4})", expects (0 #f (1 #f #\a #\b (rep 0 1 #\c #\d) (rep-while 3 4 #\e))) ==> ok
test regexp-unparse "(?i:ab(?-i:cd)ef)", expects (0 #f (seq-uncase #\a #\b (seq-case #\c #\d) #\e #\f)) ==> ok
test regexp-unparse "(a)bc\\1", expects (0 #f (1 #f #\a) #\b #\c (backref . 1)) ==> ok
test regexp-unparse "ab(?<foo>c)(d)\\k<foo>", expects (0 #f #\a #\b (1 foo #\c) (2 #f #\d) (backref . 1)) ==> ok
test regexp-unparse "(?>abc)", expects (0 #f (once #\a #\b #\c)) ==> ok
test regexp-unparse "(?=a*b*c)", expects (0 #f (assert (rep 0 #f #\a) (rep-while 0 #f #\b) #\c)) ==> ok
test regexp-unparse "(?!a*b*c)", expects (0 #f (nassert (rep 0 #f #\a) (rep-while 0 #f #\b) #\c)) ==> ok
test regexp-unparse "(?<=a[bc])", expects (0 #f (assert (lookbehind #\a #[bc]))) ==> ok
test regexp-unparse "(?<!a[bc])", expects (0 #f (nassert (lookbehind #\a #[bc]))) ==> ok
test regexp-unparse "(a)(?(1)b)", expects (0 #f (1 #f #\a) (cpat 1 (#\b) #f)) ==> ok
test regexp-unparse "(a)(?(1)b|c)", expects (0 #f (1 #f #\a) (cpat 1 (#\b) (#\c))) ==> ok
test regexp-unparse "(a)(?(1)|c)", expects (0 #f (1 #f #\a) (cpat 1 ((seq)) (#\c))) ==> ok
test regexp-unparse "(?(?=ab)cd|ef)", expects (0 #f (cpat (assert #\a #\b) ((seq #\c #\d)) ((seq #\e #\f)))) ==> ok
test regexp-unparse "(?(?!ab)cd|ef)", expects (0 #f (cpat (nassert #\a #\b) ((seq #\c #\d)) ((seq #\e #\f)))) ==> ok
test regexp-unparse "(?(?<=ab)cd|ef)", expects (0 #f (cpat (assert (lookbehind #\a #\b)) ((seq #\c #\d)) ((seq #\e #\f)))) ==> ok
test regexp-unparse "(?(?<!ab)cd|ef)", expects (0 #f (cpat (nassert (lookbehind #\a #\b)) ((seq #\c #\d)) ((seq #\e #\f)))) ==> ok
<compile>----------------------------------------------------------------------
test regexp-compile "a", expects #t ==> ok
test regexp-compile "ab", expects #t ==> ok
test regexp-compile "(?:ab)", expects #t ==> ok
test regexp-compile "(a)", expects #t ==> ok
test regexp-compile "a?", expects #t ==> ok
test regexp-compile "a*", expects #t ==> ok
test regexp-compile "a+", expects #t ==> ok
test regexp-compile "a{3,5}", expects #t ==> ok
test regexp-compile "a{3}", expects #t ==> ok
test regexp-compile "a|b", expects #t ==> ok
test regexp-compile "[ab]", expects #t ==> ok
test regexp-compile "[^ab]", expects #t ==> ok
test regexp-compile ".", expects #t ==> ok
test regexp-compile "^", expects #t ==> ok
test regexp-compile "$", expects #t ==> ok
test regexp-compile "\b", expects #t ==> ok
test regexp-compile "\B", expects #t ==> ok
test regexp-compile "(?>a)", expects #t ==> ok
test regexp-compile "a*+", expects #t ==> ok
test regexp-compile "a++", expects #t ==> ok
test regexp-compile "a?+", expects #t ==> ok
test regexp-compile "(?i:a)", expects #t ==> ok
test regexp-compile "(?-i:a)", expects #t ==> ok
test regexp-compile "(?=a)", expects #t ==> ok
test regexp-compile "(?!a)", expects #t ==> ok
test regexp-compile "(?<=ab)", expects #t ==> ok
test regexp-compile "(?<!ab)", expects #t ==> ok
test regexp-compile "(?<name>a)", expects #t ==> ok
test regexp-compile "(?(?=)y)", expects #t ==> ok
test regexp-compile "(?(?=)y|n)", expects #t ==> ok
test regexp-compile "(?(?<=)y)", expects #t ==> ok
test regexp-compile "(?(?<=)y|n)", expects #t ==> ok
test regexp-compile "()(?(1)y)", expects #t ==> ok
test regexp-compile "()(?(1)y|n)", expects #t ==> ok
test regexp-compile "()\1", expects #t ==> ok
test regexp-compile "(?<name>)\k<name>", expects #t ==> ok
test regexp-compile "(?<name>)(?<name>)\k<name>", expects #t ==> ok
test regexp-laset "abc", expects #[a] ==> ok
test regexp-laset "(abc)", expects #[a] ==> ok
test regexp-laset "a|b|c", expects #[a-c] ==> ok
test regexp-laset "(a|b)|c", expects #[a-c] ==> ok
test regexp-laset "a*b", expects #[ab] ==> ok
test regexp-laset "a+b", expects #[a] ==> ok
test regexp-laset "(abc)*(bcd)*ef", expects #[abe] ==> ok
test regexp-laset "([^"]|"")+", expects #[\u0000-\u007f\u0080-\U00ffffff] ==> ok
<boundary>---------------------------------------------------------------------
test submatch #f, expects #f ==> ok
test submatch #f, expects #f ==> ok
test submatch #f, expects #f ==> ok
test num-match #f, expects 0 ==> ok
<basics>-----------------------------------------------------------------------
test (#/a/ "a"), expects ("a") ==> ok
test (#/a/ "A"), expects #f ==> ok
test (#/a/ "ba"), expects ("a") ==> ok
test (#/a/ "bac"), expects ("a") ==> ok
test (#/a/ ""), expects #f ==> ok
test (#/a/ "\0ab"), expects ("a") ==> ok
test (#/abc/ "abc"), expects ("abc") ==> ok
test (#/abc/ "abbc"), expects #f ==> ok
test (#/abc/ "babcd"), expects ("abc") ==> ok
test (#/(?:abc|de)/ "dabce"), expects ("abc") ==> ok
test (#/(?:abc|de)/ "abdec"), expects ("de") ==> ok
test (#/(?:abc|de)/ "abe"), expects #f ==> ok
test (#/(?:a|b|c)/ "abc"), expects ("a") ==> ok
test (#/(?:a|b|c)/ "bac"), expects ("b") ==> ok
test (#/(?:a|b|c)/ "def"), expects #f ==> ok
test (#/(?:|abc)/ "abc"), expects ("") ==> ok
test (#/(?:abc|)/ "abc"), expects ("abc") ==> ok
test (#/(?:abc|)/ "abd"), expects ("") ==> ok
<parens>-----------------------------------------------------------------------
test (#/a(b)c/ "abc"), expects ("abc" "b") ==> ok
test (#/a((b)(c))/ "abc"), expects ("abc" "bc" "b" "c") ==> ok
test (#/a((((b))))c/ "abc"), expects ("abc" "b" "b" "b" "b") ==> ok
test (#/a((((b))))c/ "a(b)c"), expects #f ==> ok
test (#/a\(/ "a("), expects ("a(") ==> ok
test (#/a()b/ "ab"), expects ("ab" "") ==> ok
test (#/a()()b/ "ab"), expects ("ab" "" "") ==> ok
test (#/((?:we|wee|week|frob))((?:knights|night|day))/ "weeknights"), expects ("weeknights" "wee" "knights") ==> ok
test (#/(?:aa|(bb)|cc)/ "aabb"), expects ("aa" #f) ==> ok
test (#/(?:aa|(bb)|cc)/ "abbaa"), expects ("bb" "bb") ==> ok
test (#/(?:aa|(bb)|cc)/ "bccaa"), expects ("cc" #f) ==> ok
test (#/(?:aa|a(b)|cc)/ "abaab"), expects ("ab" "b") ==> ok
test (#/(?:aa|a(b))/ "abaab"), expects ("ab" "b") ==> ok
test (#/(?:aa|(a(b))|cc)/ "abaabcc"), expects ("ab" "ab" "b") ==> ok
test (#/(?:(ab)|ac)/ "aaaabcc"), expects ("ab" "ab") ==> ok
test (#/(?:(a(b))|ac)/ "abaabcc"), expects ("ab" "ab" "b") ==> ok
test (#/(?:ab|(ac))/ "aaaabcc"), expects ("ab" #f) ==> ok
test (#/(?:ab|(ac))/ "aaaacbc"), expects ("ac" "ac") ==> ok
test (#/(?:aa|((?:ab|(ac)))|ad)/ "cac"), expects ("ac" "ac" "ac") ==> ok
test (#/((?:aa|((?:a(b)|a(c)))|ad))/ "cac"), expects ("ac" "ac" "ac" #f "c") ==> ok
test (#/(.)*/ "abc"), expects ("abc" "c") ==> ok
test (#/(a([^a])*)*/ "abcaBC"), expects ("abcaBC" "aBC" "C") ==> ok
test (#/(?:b|()|a)/ "cac"), expects ("" "") ==> ok
<simple meta>------------------------------------------------------------------
test (#/a.c/ "abc"), expects ("abc") ==> ok
test (#/a../ "abc"), expects ("abc") ==> ok
test (#/a../ "ab"), expects #f ==> ok
test (#/.../ "ab"), expects #f ==> ok
test (#/./ "abc"), expects ("a") ==> ok
test (#/./ ""), expects #f ==> ok
<anchors>----------------------------------------------------------------------
test (#/^abc/ "abcd"), expects ("abc") ==> ok
test (#/^abc/ "aabcd"), expects #f ==> ok
test (#/^\^/ "^^abc"), expects ("^") ==> ok
test (#/^\^/ "a^^c"), expects #f ==> ok
test (#/(?:^abc|def)/ "abc"), expects ("abc") ==> ok
test (#/(?:^abc|def)/ "zabc"), expects #f ==> ok
test (#/(?:^abc|def)/ "zabcdef"), expects ("def") ==> ok
test (#/(?:abc|^def)/ "defabc"), expects ("def") ==> ok
test (#/(?:abc|^def)/ "abcdef"), expects ("abc") ==> ok
test (#/(?:abc|^def)/ "defabbc"), expects ("def") ==> ok
test (#/(?:abc|^def)/ "adefbc"), expects #f ==> ok
test (#/^((?:abc|def))/ "abc"), expects ("abc" "abc") ==> ok
test (#/^((?:abc|def))/ "aabc"), expects #f ==> ok
test (#/((?:^abc|def))/ "abcdef"), expects ("abc" "abc") ==> ok
test (#/((?:^abc|def))/ "^abcdef"), expects ("def" "def") ==> ok
test (#/a((?:\^bc|def))/ "a^bcdef"), expects ("a^bc" "^bc") ==> ok
test (#/a((?:\^bc|def))/ "abcdef"), expects #f ==> ok
test (#/^/ "hoge"), expects ("") ==> ok
test (#/$/ "hoge"), expects ("") ==> ok
test (#/abc$/ "bcabc"), expects ("abc") ==> ok
test (#/abc$/ "abcab"), expects #f ==> ok
test (#/^abc$/ "abc"), expects ("abc") ==> ok
test (#/abc$$/ "abc"), expects #f ==> ok
test (#/abc$$/ "abc$"), expects ("abc$") ==> ok
test (#/$$/ "abc$"), expects ("$") ==> ok
test (#/^$/ ""), expects ("") ==> ok
test (#/^$/ "a"), expects #f ==> ok
test (#/^\^$$/ "^$"), expects ("^$") ==> ok
test (#/(?:abc$|def)/ "abc"), expects ("abc") ==> ok
test (#/(?:abc$|def)/ "defabc"), expects ("def") ==> ok
test (#/(?:^abc|def$)/ "abcdef"), expects ("abc") ==> ok
test (#/(?:^abc|def$)/ "defabc"), expects #f ==> ok
test (#/(?:^abc|def$)/ "defabc"), expects #f ==> ok
test (#/((?:^abc|def$))/ "aaadef"), expects ("def" "def") ==> ok
test (#/((?:^abc|def$))$/ "aaadef"), expects #f ==> ok
test (#/((?:^abc|def$))$/ "aaadef$"), expects ("def$" "def$") ==> ok
test (#/((?:abc$|def))$/ "aaabc"), expects #f ==> ok
test (#/((?:abc$|def))$/ "aaabc$"), expects ("abc$" "abc$") ==> ok
test (#/a$b/ "aa$bb"), expects ("a$b") ==> ok
test (#/ab\$/ "ab$cd"), expects ("ab$") ==> ok
<backslash escape>-------------------------------------------------------------
test (#/a\*c/ "a*c"), expects ("a*c") ==> ok
test (#/a\.c/ "a.c"), expects ("a.c") ==> ok
test (#/a\.c/ "abc"), expects #f ==> ok
test (#/a\\b/ "a\\b"), expects ("a\\b") ==> ok
test (#/a\\\*b/ "a\\*b"), expects ("a\\*b") ==> ok
test (#/ajc/ "ajc"), expects ("ajc") ==> ok
test (#/a\\bc/ "a\\bc"), expects ("a\\bc") ==> ok
test (#/a\[b/ "a[b"), expects ("a[b") ==> ok
<word boundary>----------------------------------------------------------------
test (#/.z\b/ "bzbazoz ize"), expects ("oz") ==> ok
test (#/\b.z/ "brzbazoz ize"), expects ("iz") ==> ok
test (#/.z\B/ "bz baz oz ize"), expects ("iz") ==> ok
test (#/\B.z/ "bz baz oz ize"), expects ("az") ==> ok
<repetitions>------------------------------------------------------------------
test (#/ab*c/ "abc"), expects ("abc") ==> ok
test (#/ab*c/ "ac"), expects ("ac") ==> ok
test (#/ab*c/ "abbbc"), expects ("abbbc") ==> ok
test (#/ab*c/ "abbabaabbc"), expects ("abbc") ==> ok
test (#/ab+c/ "abc"), expects ("abc") ==> ok
test (#/ab+c/ "abbc"), expects ("abbc") ==> ok
test (#/ab+c/ "abbabaabbc"), expects ("abbc") ==> ok
test (#/ab?c/ "abc"), expects ("abc") ==> ok
test (#/ab?c/ "abbaac"), expects ("ac") ==> ok
test (#/a(?:.)*c/ "abc"), expects ("abc") ==> ok
test (#/a(?:.)*c/ "zaabcabcabcabcczab"), expects ("aabcabcabcabcc") ==> ok
test (#/a((?:b*|c))d/ "abbd"), expects ("abbd" "bb") ==> ok
test (#/a((?:b*|c))d/ "ad"), expects ("ad" "") ==> ok
test (#/a((?:b*|c))d/ "acd"), expects ("acd" "c") ==> ok
test (#/a((?:b*|c))d/ "abcd"), expects #f ==> ok
test (#/a(?:.)*c/ "bacbababbbbadbaba"), expects ("ac") ==> ok
test (#/a(?:.)*c/ "abaaaabababbadbabdba"), expects #f ==> ok
test (#/a+b+/ "aaaacccccccbaaabbccc"), expects ("aaabb") ==> ok
test (#/a*b+/ "aaaacccccccbaaabbccc"), expects ("b") ==> ok
test (#/a+@a+\.a+/ "aaaaaaaaaaa@aaaaaaaa@@a.aaaaa@aaaaa"), expects #f ==> ok
test (#/a+@a+\.a+/ "aaaaaaaaaaa@aaaaaaaa@@a.aaaaa@aaaaa.a"), expects ("aaaaa@aaaaa.a") ==> ok
<repetitions (non-greedy)>-----------------------------------------------------
test (#/ab*?./ "abc"), expects ("ab") ==> ok
test (#/ab*?./ "ac"), expects ("ac") ==> ok
test (#/a(?:.)*?c/ "abbbc"), expects ("abbbc") ==> ok
test (#/a(?:.)*?a/ "abbabaabbc"), expects ("abba") ==> ok
test (#/<(?:.)*?>/ "<tag1><tag2><tag3>"), expects ("<tag1>") ==> ok
test (#/ab+?./ "abc"), expects ("abc") ==> ok
test (#/ab+?./ "abbc"), expects ("abb") ==> ok
test (#/a(?:.)+?a/ "abbabaabbc"), expects ("abba") ==> ok
test (#/<(?:.)+?>/ " <><tag1><tag2>"), expects ("<><tag1>") ==> ok
test (#/ab??c/ "abc"), expects ("abc") ==> ok
test (#/ab??c/ "abbaac"), expects ("ac") ==> ok
test (#/ab??./ "abbaac"), expects ("ab") ==> ok
test (#/a(hoge)??hoge/ "ahogehoge"), expects ("ahoge" #f) ==> ok
test (#/(foo)??bar/ "foobar"), expects ("foobar" "foo") ==> ok
test (#/(foo)??bar/ "foofoobar"), expects ("foobar" "foo") ==> ok
test (#/(foo)*?bar/ "foofoobar"), expects ("foofoobar" "foo") ==> ok
<character class>--------------------------------------------------------------
test (#/a[bc]d/ "abd"), expects ("abd") ==> ok
test (#/a[bc]d/ "acd"), expects ("acd") ==> ok
test (#/a[bc]d/ "aed"), expects #f ==> ok
test (#/a[a-z]d/ "aed"), expects ("aed") ==> ok
test (#/a[a-z]d/ "aEd"), expects #f ==> ok
test (#/a[\]]d/ "a]d"), expects ("a]d") ==> ok
test (#/a[\-\]]d/ "a-d"), expects ("a-d") ==> ok
test (#/a[\]^]d/ "a-d"), expects #f ==> ok
test (#/a[\]^]d/ "a]d"), expects ("a]d") ==> ok
test (#/a[\-a-z]d/ "a-d"), expects ("a-d") ==> ok
test (#/a[\-a-z]d/ "afd"), expects ("afd") ==> ok
test (#/a[\-az]d/ "a-d"), expects ("a-d") ==> ok
test (#/a[\-a]d/ "a-d"), expects ("a-d") ==> ok
test (#/a[\-az]d/ "afd"), expects #f ==> ok
test (#/a[\-az]d/ "azd"), expects ("azd") ==> ok
test (#/a[^ab]c/ "abacc"), expects ("acc") ==> ok
test (#/a[^\]]c/ "abc"), expects ("abc") ==> ok
test (#/a[^\]]c/ "a]c"), expects #f ==> ok
test (#/a[^\^]c/ "abc"), expects ("abc") ==> ok
test (#/a[^\^]c/ "a^c"), expects #f ==> ok
test (#/a(?:[Bc])*d/ "aBccBd"), expects ("aBccBd") ==> ok
test (#/[a]b[c]/ "abc"), expects ("abc") ==> ok
test (#/[a-c]b[a-c]/ "abc"), expects ("abc") ==> ok
test (#/a[bc]d/ "xyzaaabcaababdacd"), expects ("abd") ==> ok
test (#/a[ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab][ab]((?:wee|week))((?:knights|night))/ "aaaaabaaaabaaaabaaaabweeknights"), expects ("aaaaabaaaabaaaabaaaabweeknights" "wee" "knights") ==> ok
test (#/[ab][cd][ef][gh][ij][kl][mn]/ "xacegikmoq"), expects ("acegikm") ==> ok
test (#/[ab][cd][ef][gh][ij][kl][mn][op]/ "xacegikmoq"), expects ("acegikmo") ==> ok
test (#/[ab][cd][ef][gh][ij][kl][mn][op][qr]/ "xacegikmoqy"), expects ("acegikmoq") ==> ok
test (#/[ab][cd][ef][gh][ij][kl][mn][op][q]/ "xacegikmoqy"), expects ("acegikmoq") ==> ok
test (#/(?:[^a])*./ "b"), expects ("b") ==> ok
test (#/[\u0009-\u000d ]/ "  "), expects (" ") ==> ok
test (#/[\u0009-\u000d ][\u0009-\u000d ]/ "  "), expects ("  ") ==> ok
test (#/[\u0009-\u000d ]/ "\t "), expects ("\t") ==> ok
test (#/[\u0009-\u000d ][\u0009-\u000d ]/ "\\s"), expects #f ==> ok
test (#/\\s[\u0009-\u000d ]/ "\\s "), expects ("\\s ") ==> ok
test (#/((?:[\u0009-\u000d ])*)((?:[^\u0009-\u000d ])+)((?:[\u0009-\u000d ])*)/ "\txyz   abc"), expects ("\txyz   " "\t" "xyz" "   ") ==> ok
test (#/((?:[0-9])+)((?:[^0-9])+)((?:[0-9])+)((?:[^0-9])+)((?:[0-9])+)/ " (1234) 5678-9012 "), expects ("1234) 5678-9012" "1234" ") " "5678" "-" "9012") ==> ok
test (#/((?:[0-9A-Z_a-z])+)((?:[^0-9A-Z_a-z])+)((?:[0-9A-Z_a-z])+)/ "three o'clock"), expects ("three o" "three" " " "o") ==> ok
test (#/(?:[\u0009-\u000d a-c])+/ "d ba e"), expects (" ba ") ==> ok
test (#/(?:[\u0009-\u000d a-c])+/ "d ba e"), expects (" ba ") ==> ok
test (#/(?:[\u0000-\u0009\u000e-\u001f!-\u007f\u0080-\U00ffffff])+/ "\tab cd"), expects ("\tab") ==> ok
test (#/(?:[\u0009-\u000d 0-9])+/ "a 1 2 3 b "), expects (" 1 2 3 ") ==> ok
test (#/(?:[\u0000-\/:-\u007f\u0080-\U00ffffff])+/ "a 1 2 3 b "), expects ("a ") ==> ok
test (#/^\[?((?:[^\]])*)\]?:((?:[0-9])+)$/ "127.0.0.1:80"), expects ("127.0.0.1:80" "127.0.0.1" "80") ==> ok
test (#/^\[?((?:[^\]])*)\]?:((?:[0-9])+)$/ "[127.0.0.1:80"), expects ("[127.0.0.1:80" "127.0.0.1" "80") ==> ok
test (#/^\[?((?:[^\]])*)\]?:((?:[0-9])+)$/ "[127.0.0.1]:80"), expects ("[127.0.0.1]:80" "127.0.0.1" "80") ==> ok
<{n,m}>------------------------------------------------------------------------
test (rxmatch-after (#/a{2}/ "abaaaabaa")), expects "aabaa" ==> ok
test (rxmatch-after (#/a{2,}/ "abaaaabaa")), expects "baa" ==> ok
test (rxmatch-after (#/a{1,2}/ "abaaaabaa")), expects "baaaabaa" ==> ok
test (rxmatch-after (#/a{2,3}/ "abaaaabaa")), expects "abaa" ==> ok
test (rxmatch-after (#/a\{b,c\}/ "za{b,c}def")), expects "def" ==> ok
test (rxmatch-after (#/a\{,2\}*/ "za{,2}}def")), expects "def" ==> ok
test (rxmatch-after (#/a{0,3}/ "aabaaaab")), expects "baaaab" ==> ok
test (rxmatch-after (#/(ab){2}/ "babbabababba")), expects "abba" ==> ok
test (rxmatch-after (#/(ab){2}/ "babbabababba")), expects "abba" ==> ok
test (rxmatch-after (#/(ab){2,}/ "babbabababba")), expects "ba" ==> ok
test (rxmatch-after (#/(ab){1,2}/ "babbabababba")), expects "babababba" ==> ok
test (rxmatch-after (#/(ab){2,3}/ "babbabababba")), expects "ba" ==> ok
test (rxmatch-after (#/(ab)\{b,c\}/ "zab{b,c}def")), expects "def" ==> ok
test (#/((?:[0-9]){2})((?:[0-9]){2})/ "a12345b"), expects ("1234" "12" "34") ==> ok
test (#/((?:[0-9]){2,})((?:[0-9]){2,})/ "a12345b"), expects ("12345" "123" "45") ==> ok
test (#/((?:[0-9]){2})((?:[0-9]){2,})/ "a12345b"), expects ("12345" "12" "345") ==> ok
test (#/((?:[0-9]){1,3})((?:[0-9]){2,})/ "a1234b"), expects ("1234" "12" "34") ==> ok
test (#/((?:[0-9]){1,3})((?:[0-9]){0,2})/ "a1234b"), expects ("1234" "123" "4") ==> ok
test (#/((?:[0-9]){2}){2}/ "a12345b"), expects ("1234" "34") ==> ok
test {2}, expects #<error> ==> ok
test {z}, expects #t ==> ok
test {-1}, expects #t ==> ok
test {300}, expects #<error> ==> ok
test {3,1}, expects #<error> ==> ok
<{n,m} (non-greedy)>-----------------------------------------------------------
test (rxmatch-after (#/a{2}?/ "abaaaabaa")), expects "aabaa" ==> ok
test (rxmatch-after (#/a{2,}?/ "abaaaabaa")), expects "aabaa" ==> ok
test (rxmatch-after (#/a{1,2}?/ "abaaaabaa")), expects "baaaabaa" ==> ok
test (rxmatch-after (#/a{2,3}?/ "abaaaabaa")), expects "aabaa" ==> ok
test (rxmatch-after (#/(ab){2}?/ "babbabababba")), expects "abba" ==> ok
test (rxmatch-after (#/(ab){2}?/ "babbabababba")), expects "abba" ==> ok
test (rxmatch-after (#/(ab){2,}?/ "babbabababba")), expects "abba" ==> ok
test (rxmatch-after (#/(ab){1,2}?/ "babbabababba")), expects "babababba" ==> ok
test (rxmatch-after (#/(ab){2,3}?/ "babbabababba")), expects "abba" ==> ok
test (#/((?:[0-9]){2,}?)((?:[0-9]){2,}?)/ "a12345b"), expects ("1234" "12" "34") ==> ok
test (#/((?:[0-9]){2,})((?:[0-9]){2,}?)/ "a12345b"), expects ("12345" "123" "45") ==> ok
test (#/((?:[0-9]){2,}?)((?:[0-9]){2,})/ "a12345b"), expects ("12345" "12" "345") ==> ok
test (#/((?:[0-9]){1,3}?)((?:[0-9]){2,}?)/ "a1234b"), expects ("123" "1" "23") ==> ok
test (#/((?:[0-9]){1,3}?)((?:[0-9]){0,2}?)/ "a1234b"), expects ("1" "1" "") ==> ok
<uncapturing group>------------------------------------------------------------
test (rxmatch-substring (#/ab*c(d)/ "abcdbcdefg")), expects "d" ==> ok
test (rxmatch-substring (#/a(?:bcd)*e(f)/ "abcdbcdefg")), expects "f" ==> ok
test (rxmatch-substring (#/a(?:bcd)*e(f)/ "aefg")), expects "f" ==> ok
test (rxmatch-substring (#/a(?:bcd)+e(f)/ "aefg")), expects #f ==> ok
test (rxmatch-substring (#/a(?:bc(de(?:fg)?hi)jk)?l/ "abcdefghijkl")), expects "defghi" ==> ok
test (rxmatch-substring (#/a(?:bc(de(?:fg)?hi)jk)?l/ "abcdehijkl")), expects "dehi" ==> ok
test (rxmatch-substring (#/a(?i:bc)d/ "!aBCd!")), expects "aBCd" ==> ok
test (rxmatch-substring (#/a(?i:bc)d/ "!aBCD!")), expects #f ==> ok
test (rxmatch-substring (#/a(?i:(?:[A-Za-z])+)d/ "!aBcd!")), expects "aBcd" ==> ok
test (rxmatch-substring (#/a(?i:(?:[A-Za-z])+)d/ "!ABcd!")), expects #f ==> ok
test (rxmatch-substring (#/A(?-i:Bc)D/ "!ABcD!")), expects "ABcD" ==> ok
test (rxmatch-substring (#/A(?-i:Bc)D/ "!ABcd!")), expects #f ==> ok
test (rxmatch-substring (#/A(?-i:(?:[A-Z])+)D/ "!ABCD!")), expects "ABCD" ==> ok
test (rxmatch-substring (#/A(?-i:(?:[A-Z])+)D/ "!abCD!")), expects #f ==> ok
test (rxmatch-substring (#/(?i:a(?-i:Bc)d)/ "!aBcd!")), expects "aBcd" ==> ok
test (rxmatch-substring (#/(?i:a(?-i:Bc)d)/ "!abCd!")), expects #f ==> ok
test (rxmatch-substring (#/(?i:a(?-i:(?:[A-Z])+)d)/ "!aBCd!")), expects "aBCd" ==> ok
test (rxmatch-substring (#/(?i:a(?-i:(?:[A-Z])+)d)/ "!abcd!")), expects #f ==> ok
test (rxmatch-substring (#/^(?i:a*).$/ "b")), expects "b" ==> ok
test (rxmatch-substring (#/^(?i:a*).$/ "a")), expects "a" ==> ok
test (rxmatch-substring (#/^(?i:a*).$/ "A")), expects "A" ==> ok
test (rxmatch-substring (#/^(?i:a*).$/ "Ab")), expects "Ab" ==> ok
<backreference>----------------------------------------------------------------
test (#/^(.)\1(?:)$/ "aa"), expects ("aa" "a") ==> ok
test (#/^(.)\1(?:)$/ "ab"), expects #f ==> ok
test (#/((?:.)+)\1(?:)/ "a123123j"), expects ("123123" "123") ==> ok
test (#/(?i:((?:.)+)\1(?:))/ "AbCaBC"), expects ("AbCaBC" "AbC") ==> ok
test (#/((?:.)+)\1(?:)/ "AbCAb1"), expects #f ==> ok
test ^\1(.)$, expects #<error> ==> ok
test ^(\1)$, expects #<error> ==> ok
<independent subexpression>----------------------------------------------------
test (#/(?>(?:.)*\/)foo/ "/this/is/a/long/line/"), expects #f ==> ok
test (#/(?>(?:.)*\/)foo/ "/this/is/a/long/line/foo"), expects ("/this/is/a/long/line/foo") ==> ok
test (#/(?>(\.[0-9][0-9](?:[1-9])?))(?:[0-9])+/ "1.230003938"), expects (".230003938" ".23") ==> ok
test (#/(?>(\.[0-9][0-9](?:[1-9])?))(?:[0-9])+/ "1.875000282"), expects (".875000282" ".875") ==> ok
test (#/(?>(\.[0-9][0-9](?:[1-9])?))(?:[0-9])+/ "1.235"), expects #f ==> ok
test (#/^((?:(?>(?:[0-9A-Z_a-z])+)|(?>(?:[\u0009-\u000d ])+)))*$/ "foo bar"), expects ("foo bar" "bar") ==> ok
test (#/(?>a*)a/ "aaa"), expects #f ==> ok
test (#/(?>a*)b/ "aab"), expects ("aab") ==> ok
test (#/(?>a+)a/ "aaa"), expects #f ==> ok
test (#/(?>a+)b/ "aab"), expects ("aab") ==> ok
test (#/(?>a?)a/ "a"), expects #f ==> ok
test (#/(?>a?)b/ "ab"), expects ("ab") ==> ok
<lookahead assertion>----------------------------------------------------------
test (#/^(?=ab(de))(abd)(e)/ "abde"), expects ("abde" "de" "abd" "e") ==> ok
test (#/^(?!(?:(ab)de|x))(abd)(f)/ "abdf"), expects ("abdf" #f "abd" "f") ==> ok
test (#/^(?=(ab(cd)))(ab)/ "abcd"), expects ("ab" "abcd" "cd" "ab") ==> ok
test (#/(?:[0-9A-Z_a-z])+(?=\u0009)/ "the quick brown\t fox"), expects ("brown") ==> ok
test (#/foo(?!bar)((?:.)*)/ "foobar is foolish see?"), expects ("foolish see?" "lish see?") ==> ok
test (#/(?:(?!foo)...|^(?:.){0,2})bar((?:.)*)/ "foobar crowbar etc"), expects ("rowbar etc" " etc") ==> ok
test (#/(?:(?!foo)...|^(?:.){0,2})bar((?:.)*)/ "barrel"), expects ("barrel" "rel") ==> ok
test (#/(?:(?!foo)...|^(?:.){0,2})bar((?:.)*)/ "2barrel"), expects ("2barrel" "rel") ==> ok
test (#/(?:(?!foo)...|^(?:.){0,2})bar((?:.)*)/ "A barrel"), expects ("A barrel" "rel") ==> ok
test (#/^((?:[^0-9])*)(?=[0-9])(?!123)/ "abc456"), expects ("abc" "abc") ==> ok
test (#/^((?:[^0-9])*)(?=[0-9])(?!123)/ "abc123"), expects #f ==> ok
test (#/(?!^)abc/ "the abc"), expects ("abc") ==> ok
test (#/(?!^)abc/ "abc"), expects #f ==> ok
test (#/(?!^\^).../ "^^abc"), expects ("^ab") ==> ok
test (#/(?!^\^).../ "^abc"), expects ("abc") ==> ok
test (#/(?=^)abc/ "abc"), expects ("abc") ==> ok
test (#/(?=^)abc/ "the abc"), expects #f ==> ok
test (#/(?=^\^).../ "^abc"), expects ("^ab") ==> ok
test (#/(?=^\^).../ "^^abc"), expects ("^^a") ==> ok
test (#/^(?=$)(?:.)*/ ""), expects ("") ==> ok
test (#/^(?!$)(?:.)*/ ""), expects #f ==> ok
test (#/^(?=$)(?:.)*/ "a"), expects #f ==> ok
test (#/^(?=$$)(?:.)*/ "$"), expects ("$") ==> ok
test (#/^(?!$)(?:.)*/ "a"), expects ("a") ==> ok
test (#/(\.[0-9][0-9]((?:(?=0)|[0-9](?=[0-9]))))/ "1.230003938"), expects (".23" ".23" "") ==> ok
test (#/(\.[0-9][0-9]((?:(?=0)|[0-9](?=[0-9]))))/ "1.875000282"), expects (".875" ".875" "5") ==> ok
test (#/(\.[0-9][0-9]((?:(?=0)|[0-9](?=[0-9]))))/ "1.235"), expects #f ==> ok
test (#/^(?:[^0-9])*(?!123)/ "ABC123"), expects ("AB") ==> ok
test (#/^((?:[^0-9])*)(?=[0-9])(?!123)/ "ABC445"), expects ("ABC" "ABC") ==> ok
test (#/^((?:[^0-9])*)(?=[0-9])(?!123)/ "ABC123"), expects #f ==> ok
test (#/a(?!b)./ "abad"), expects ("ad") ==> ok
test (#/a(?!^b)./ "a^bad"), expects ("a^") ==> ok
test (#/a(?!b)/ "abad"), expects ("a") ==> ok
test (#/a(?=d)./ "abad"), expects ("ad") ==> ok
test (#/a(?=^b)./ "a^bad"), expects #f ==> ok
test (#/a(?=(?:c|d))./ "abad"), expects ("ad") ==> ok
<lookbehind assertion>---------------------------------------------------------
test (#/(?<=a)b/ "b"), expects #f ==> ok
test (#/(?<=a)b/ "ab"), expects ("b") ==> ok
test (#/(?<=a+)b/ "aab"), expects ("b") ==> ok
test (#/(?<=x[yz])b/ "xzb"), expects ("b") ==> ok
test (#/(?<=zyx)b/ "xyzb"), expects #f ==> ok
test (#/(?<=(?:[ab])+)c/ "abc"), expects ("c") ==> ok
test (#/(?<!<(?:[^>])*)foo/ "<foo>"), expects #f ==> ok
test (#/(?<!<(?:[^>])*)foo/ "<bar>foo"), expects ("foo") ==> ok
test (#/(?<=^a)b/ "ab"), expects ("b") ==> ok
test (#/(?<=^)b/ "ab"), expects #f ==> ok
test (#/(?<=^)b/ "b"), expects ("b") ==> ok
test (#/.(?<=^)b/ "a^b"), expects #f ==> ok
test (#/(?<=^a$)/ "a"), expects ("") ==> ok
test (#/(?<=^a$)b/ "a$b"), expects #f ==> ok
test (#/(?<=(a))b/ "ab"), expects ("b" "a") ==> ok
test (#/(?<=(a)(b))c/ "abc"), expects ("c" "a" "b") ==> ok
test (#/(?<=(?:(a)|(b)))c/ "bc"), expects ("c" #f "b") ==> ok
test (#/(?<=(?<!foo)bar)baz/ "abarbaz"), expects ("baz") ==> ok
test (#/(?<=(?<!foo)bar)baz/ "foobarbaz"), expects #f ==> ok
test (#/(?<=(?:[0-9]){3})(?<!999)foo/ "865foo"), expects ("foo") ==> ok
test (#/(?<=(?:[0-9]){3})(?<!999)foo/ "999foo"), expects #f ==> ok
test (?<=(?>a*)), expects #<error> ==> ok
test (#/(abc)...(?<=\1(?:))/ "abcabc"), expects ("abcabc" "abc") ==> ok
test (#/(?i:(abc)...(?<=\1(?:)))/ "abCAbc"), expects ("abCAbc" "abC") ==> ok
<named group>------------------------------------------------------------------
test (#/(?<foo>a)/ "a"), expects ("a" "a") ==> ok
test (?<foo>a), expects "a" ==> ok
test (?<foo>a), expects #f ==> ok
test (?<foo>a)(?<bar>.*), expects ("a" "bcd") ==> ok
test (#/(?<foo>a)(?<bar>(?:.)*)/ "abcd"), expects ("abcd" "a" "bcd") ==> ok
test (?<foo>a), expects #<error> ==> ok
test (#/(?<foo>^a$)/ "a"), expects ("a" "a") ==> ok
test (#/(?<foo>^a$)/ "ab"), expects #f ==> ok
test (#/(?<name-with-hyphen>a)/ "a"), expects ("a" "a") ==> ok
test (?<host>d+.d+.d+.d+)|(?<host>[w.]+), expects ("127.0.0.1" "127.0.0.1" #f "127.0.0.1") ==> ok
test (?<host>d+.d+.d+.d+)|(?<host>[w.]+), expects ("foo.com" #f "foo.com" "foo.com") ==> ok
test (#/(?<foo>(?:.)+)\1(?:)/ "abcabc"), expects ("abcabc" "abc") ==> ok
test (#/(?<foo>(?:.)+)\1(?:)/ "abcdef"), expects #f ==> ok
test regexp-parse "\k<foo>", expects #<error> ==> ok
test (rxmatch-before (#/(?<foo>def)/ "abcdefghi")), expects "abc" ==> ok
test (rxmatch-after (#/(?<foo>def)/ "abcdefghi")), expects "ghi" ==> ok
test rxmatch-start, expects 3 ==> ok
test rxmatch-end, expects 6 ==> ok
<conditional subexpression>----------------------------------------------------
test (#/(a)(?(1)b)/ "ab"), expects ("ab" "a") ==> ok
test (#/(a)(?(1)b)/ "aa"), expects #f ==> ok
test (#/(a)(?(1)b)/ "ac"), expects #f ==> ok
test (#/(a)?(?(1)b|c)/ "xb"), expects #f ==> ok
test (#/(a)?(?(1)b|c)/ "xc"), expects ("c" #f) ==> ok
test (#/(?(?<=a)b)/ "ab"), expects ("b") ==> ok
test (#/(?(?<=a)b)/ "ac"), expects #f ==> ok
test (#/(?(?<=a)b)/ "xb"), expects #f ==> ok
test (#/(?(?<=a)b)/ "ab"), expects ("b") ==> ok
test (#/(?(?<=a)b)/ "ac"), expects #f ==> ok
test regexp-parse "(?(?a)b|c)", expects #<error> ==> ok
test (#/()(?(1))/ ""), expects ("" "") ==> ok
test regexp-parse "()(?(", expects #<error> ==> ok
test regexp-parse "()(?(1", expects #<error> ==> ok
test regexp-parse "()(?(1)b|c|d)", expects #<error> ==> ok
<regexp macros>----------------------------------------------------------------
test rxmatch-let, expects ("23:59:58" "23" "59" "58") ==> ok
test rxmatch-let, expects ("23" "59") ==> ok
test rxmatch-if, expects "time is 11:22" ==> ok
test rxmatch-if, expects "unknown time" ==> ok
test rxmatch-cond, expects (2001 2 3) ==> ok
test rxmatch-cond, expects (1999 12 25) ==> ok
test rxmatch-cond, expects #f ==> ok
test rxmatch-case, expects (2001 2 3) ==> ok
test rxmatch-case, expects (1999 12 25) ==> ok
test rxmatch-case, expects #f ==> ok
test rxmatch-case (else), expects "bogus: 100/2/3" ==> ok
test regexp-replace, expects "abc|def|ghi" ==> ok
test regexp-replace, expects "abc|\\0|ghi" ==> ok
test regexp-replace, expects "abc|def|ghi" ==> ok
test regexp-replace, expects #<error> ==> ok
test regexp-replace, expects "abraabra**brabra**brabrabracadabrabrabra" ==> ok
test regexp-replace-all, expects "abraabra**brabra**br**brabra**brabra" ==> ok
test regexp-replace-all, expects "abraabra**brabra**br**brabra**brabra" ==> ok
test regexp-replace, expects "abfedhi" ==> ok
test regexp-replace-all, expects "abraabra(bra^2)br(bra^2)brabra" ==> ok
test regexp-replace-all, expects #<error> ==> ok
test regexp-replace-all, expects #<error> ==> ok
test regexp-replace*, expects "cbazzbc" ==> ok
test regexp-replace-all*, expects "cbazzccbazz" ==> ok
<regexp cimatch>---------------------------------------------------------------
test regexp/ci, expects "BC" ==> ok
test regexp/ci, expects "bC" ==> ok
test regexp/ci, expects "bc" ==> ok
test regexp/ci, expects #f ==> ok
test regexp/ci, expects #f ==> ok
test regexp/ci, expects "PAD" ==> ok
test regexp/ci, expects "pad" ==> ok
test regexp/ci, expects "bad" ==> ok
test regexp/ci, expects #f ==> ok
test regexp/ci, expects #f ==> ok
test regexp/ci, expects #f ==> ok
test regexp/ci, expects "pad" ==> ok
test regexp/ci, expects #f ==> ok
<applicable regexp>------------------------------------------------------------
test object-apply regexp, expects #t ==> ok
test object-apply regmatch (index), expects ("3.14" "3" "14") ==> ok
test object-apply regmatch (symbol), expects ("..." ".14..." "pi=" "pi=3.") ==> ok
test object-apply regmatch (index), expects ("3.14" "3" "14" "3" "14") ==> ok
test object-apply regmatch (symbol), expects ("..." ".14..." ".14..." "pi=" "pi=3." "pi=3.") ==> ok
test object-apply regmatch (named submatch), expects ("..." ".14..." ".14..." "pi=" "pi=3." "pi=3.") ==> ok
<regexp quote>-----------------------------------------------------------------
test regexp-quote, expects #t ==> ok
<regexp comparison>------------------------------------------------------------
test equal #/abc/ #/abc/, expects #t ==> ok
test not equal #/abc/ #/a(bc)/, expects #f ==> ok
test not equal #/abc/ #/abc/i, expects #f ==> ok
test not equal #/abc/i #/abc/, expects #f ==> ok
test equal #/abc/i #/abc/i, expects #t ==> ok
<regexp printer>---------------------------------------------------------------
test #/abc/, expects "#/abc/" ==> ok
test #/a[0-9]/, expects "#/a[0-9]/" ==> ok
test #/a[a-z]/, expects "#/a[a-z]/" ==> ok
test #/a\/b/, expects "#/a\\/b/" ==> ok
test #/\\/, expects "#/\\\\/" ==> ok
test #/ /, expects "#/ /" ==> ok
test #/ /, expects "#/ /" ==> ok
test #/\//, expects "#/\\//" ==> ok
test #/\\\//, expects "#/\\\\\\//" ==> ok
test #/\\\//, expects "#/\\\\\\//" ==> ok
test #/(?i:abc)/, expects "#/(?i:abc)/" ==> ok
<regexp from AST>--------------------------------------------------------------
test empty alt, expects #f ==> ok
test empty alt unparse, expects "ab(?!)cd" ==> ok
test empty alt, expects "ab" ==> ok
passed.
Testing sort procedures =======================================================
<loading and binding>----------------------------------------------------------
test autoload, expects #t ==> ok
testing bindings in #<module gauche.sortutil> ... ok
<sort>-------------------------------------------------------------------------
test sort (base), expects () ==> ok
test sort (base), expects #() ==> ok
test sort - nocmp (list) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (vector) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (list) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (vector) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (list) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (vector) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (list) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (vector) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (list) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (vector) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (list) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (vector) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (list) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (vector) , expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (list) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test stable-sort - nocmp (vector) !, expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test sort - nocmp (list) , expects (-3/4 0.1 1/2) ==> ok
test sort - nocmp (vector) , expects (-3/4 0.1 1/2) ==> ok
test sort - nocmp (list) !, expects (-3/4 0.1 1/2) ==> ok
test sort - nocmp (vector) !, expects (-3/4 0.1 1/2) ==> ok
test stable-sort - nocmp (list) , expects (-3/4 0.1 1/2) ==> ok
test stable-sort - nocmp (vector) , expects (-3/4 0.1 1/2) ==> ok
test stable-sort - nocmp (list) !, expects (-3/4 0.1 1/2) ==> ok
test stable-sort - nocmp (vector) !, expects (-3/4 0.1 1/2) ==> ok
test sort - nocmp (list) , expects (0) ==> ok
test sort - nocmp (vector) , expects (0) ==> ok
test sort - nocmp (list) !, expects (0) ==> ok
test sort - nocmp (vector) !, expects (0) ==> ok
test stable-sort - nocmp (list) , expects (0) ==> ok
test stable-sort - nocmp (vector) , expects (0) ==> ok
test stable-sort - nocmp (list) !, expects (0) ==> ok
test stable-sort - nocmp (vector) !, expects (0) ==> ok
test sort - nocmp (list) , expects (#\a #\a #\h #\l #\o) ==> ok
test sort - nocmp (vector) , expects (#\a #\a #\h #\l #\o) ==> ok
test sort - nocmp (list) !, expects (#\a #\a #\h #\l #\o) ==> ok
test sort - nocmp (vector) !, expects (#\a #\a #\h #\l #\o) ==> ok
test stable-sort - nocmp (list) , expects (#\a #\a #\h #\l #\o) ==> ok
test stable-sort - nocmp (vector) , expects (#\a #\a #\h #\l #\o) ==> ok
test stable-sort - nocmp (list) !, expects (#\a #\a #\h #\l #\o) ==> ok
test stable-sort - nocmp (vector) !, expects (#\a #\a #\h #\l #\o) ==> ok
test sort - nocmp (list) , expects ("tac" "tic" "toe") ==> ok
test sort - nocmp (vector) , expects ("tac" "tic" "toe") ==> ok
test sort - nocmp (list) !, expects ("tac" "tic" "toe") ==> ok
test sort - nocmp (vector) !, expects ("tac" "tic" "toe") ==> ok
test stable-sort - nocmp (list) , expects ("tac" "tic" "toe") ==> ok
test stable-sort - nocmp (vector) , expects ("tac" "tic" "toe") ==> ok
test stable-sort - nocmp (list) !, expects ("tac" "tic" "toe") ==> ok
test stable-sort - nocmp (vector) !, expects ("tac" "tic" "toe") ==> ok
test sort - cmp (list) , expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test sort - cmp (vector) , expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test sort - cmp (list) !, expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test sort - cmp (vector) !, expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test stable-sort - cmp (list) , expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test stable-sort - cmp (vector) , expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test stable-sort - cmp (list) !, expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test stable-sort - cmp (vector) !, expects (-9 8 7 -6 5 -4 3 -2 -1 0) ==> ok
test sort - cmp (list) , expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test sort - cmp (vector) , expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test sort - cmp (list) !, expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test sort - cmp (vector) !, expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test stable-sort - cmp (list) , expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test stable-sort - cmp (vector) , expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test stable-sort - cmp (list) !, expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test stable-sort - cmp (vector) !, expects (-9 -8 -7 -6 -5 -4 -3 -2 -1 0) ==> ok
test sort - cmp (list) , expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test sort - cmp (vector) , expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test sort - cmp (list) !, expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test sort - cmp (vector) !, expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test stable-sort - cmp (list) , expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test stable-sort - cmp (vector) , expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test stable-sort - cmp (list) !, expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test stable-sort - cmp (vector) !, expects (9 8 7 6 5 4 3 2 1 0) ==> ok
test sort - cmp (list) , expects () ==> ok
test sort - cmp (vector) , expects () ==> ok
test sort - cmp (list) !, expects () ==> ok
test sort - cmp (vector) !, expects () ==> ok
test stable-sort - cmp (list) , expects () ==> ok
test stable-sort - cmp (vector) , expects () ==> ok
test stable-sort - cmp (list) !, expects () ==> ok
test stable-sort - cmp (vector) !, expects () ==> ok
test sort - cmp (list) , expects (0) ==> ok
test sort - cmp (vector) , expects (0) ==> ok
test sort - cmp (list) !, expects (0) ==> ok
test sort - cmp (vector) !, expects (0) ==> ok
test stable-sort - cmp (list) , expects (0) ==> ok
test stable-sort - cmp (vector) , expects (0) ==> ok
test stable-sort - cmp (list) !, expects (0) ==> ok
test stable-sort - cmp (vector) !, expects (0) ==> ok
test sort - cmp (list) , expects (-3/4 1/2 0.1) ==> ok
test sort - cmp (vector) , expects (-3/4 1/2 0.1) ==> ok
test sort - cmp (list) !, expects (-3/4 1/2 0.1) ==> ok
test sort - cmp (vector) !, expects (-3/4 1/2 0.1) ==> ok
test stable-sort - cmp (list) , expects (-3/4 1/2 0.1) ==> ok
test stable-sort - cmp (vector) , expects (-3/4 1/2 0.1) ==> ok
test stable-sort - cmp (list) !, expects (-3/4 1/2 0.1) ==> ok
test stable-sort - cmp (vector) !, expects (-3/4 1/2 0.1) ==> ok
test sort - cmp (list) , expects ("taC" "Tic" "tOe") ==> ok
test sort - cmp (vector) , expects ("taC" "Tic" "tOe") ==> ok
test sort - cmp (list) !, expects ("taC" "Tic" "tOe") ==> ok
test sort - cmp (vector) !, expects ("taC" "Tic" "tOe") ==> ok
test stable-sort - cmp (list) , expects ("taC" "Tic" "tOe") ==> ok
test stable-sort - cmp (vector) , expects ("taC" "Tic" "tOe") ==> ok
test stable-sort - cmp (list) !, expects ("taC" "Tic" "tOe") ==> ok
test stable-sort - cmp (vector) !, expects ("taC" "Tic" "tOe") ==> ok
test stable-sort stability (list) , expects ("AAA" "aaa" "bbb" "BBB" "CCC" "ccc") ==> ok
test stable-sort stability (vector) , expects ("AAA" "aaa" "bbb" "BBB" "CCC" "ccc") ==> ok
test stable-sort stability (list) !, expects ("AAA" "aaa" "bbb" "BBB" "CCC" "ccc") ==> ok
test stable-sort stability (vector) !, expects ("AAA" "aaa" "bbb" "BBB" "CCC" "ccc") ==> ok
test stable-sort stability (list) , expects ("CCC" "ccc" "bbb" "BBB" "AAA" "aaa") ==> ok
test stable-sort stability (vector) , expects ("CCC" "ccc" "bbb" "BBB" "AAA" "aaa") ==> ok
test stable-sort stability (list) !, expects ("CCC" "ccc" "bbb" "BBB" "AAA" "aaa") ==> ok
test stable-sort stability (vector) !, expects ("CCC" "ccc" "bbb" "BBB" "AAA" "aaa") ==> ok
<sort-by>----------------------------------------------------------------------
test sort-by - nocmp (list) , expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test sort-by - nocmp (vector) , expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test sort-by - nocmp (list) !, expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test sort-by - nocmp (vector) !, expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test stable-sort-by - nocmp (list) , expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test stable-sort-by - nocmp (vector) , expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test stable-sort-by - nocmp (list) !, expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test stable-sort-by - nocmp (vector) !, expects ((2 . 8) (3 . 1) (4 . 7) (5 . 9) (6 . 0)) ==> ok
test sort-by - nocmp (list) , expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test sort-by - nocmp (vector) , expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test sort-by - nocmp (list) !, expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test sort-by - nocmp (vector) !, expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test stable-sort-by - nocmp (list) , expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test stable-sort-by - nocmp (vector) , expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test stable-sort-by - nocmp (list) !, expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test stable-sort-by - nocmp (vector) !, expects ((6 . 0) (3 . 1) (4 . 7) (2 . 8) (5 . 9)) ==> ok
test sort-by - cmp (list) , expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
test sort-by - cmp (vector) , expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
test sort-by - cmp (list) !, expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
test sort-by - cmp (vector) !, expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
test stable-sort-by - cmp (list) , expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
test stable-sort-by - cmp (vector) , expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
test stable-sort-by - cmp (list) !, expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
test stable-sort-by - cmp (vector) !, expects ((#\T . #\B) (#\k . #\d) (#\a . #\q) (#\s . #\S)) ==> ok
passed.
Testing multibyte (utf-8) =====================================================
<string builtins>--------------------------------------------------------------
test string, expects "いろhにほへt" ==> ok
test list->string, expects "いろhにほへt" ==> ok
test make-string, expects "へへへへへ" ==> ok
test make-string, expects "" ==> ok
test string->list, expects (#\い #\ろ #\h #\に #\ほ #\へ #\t) ==> ok
test string->list, expects (#\ろ #\h #\に #\ほ #\へ #\t) ==> ok
test string->list, expects (#\ろ #\h #\に) ==> ok
test string-copy, expects ("ぁゃνぃ" #f) ==> ok
test string-copy, expects "ゃνぃ" ==> ok
test string-copy, expects "ゃν" ==> ok
test string-ref, expects #\ろ ==> ok
test string-set!, expects "いろZにほ" ==> ok
test string-fill!, expects "のののののの" ==> ok
test string-fill!, expects "000ののの" ==> ok
test string-fill!, expects "000のの0" ==> ok
test string-join, expects "ふぅ ばぁ ばず" ==> ok
test string-join, expects "ふぅ！ばぁ！ばず" ==> ok
test string-join, expects "ふぅ→←ばぁ→←ばず" ==> ok
test string-join, expects "" ==> ok
test string-join, expects "ふぅ！ばぁ！ばず！" ==> ok
test string-join, expects "！ふぅ！ばぁ！ばず" ==> ok
test string-join, expects "ふぅ！ばぁ！ばず" ==> ok
test string-scan, expects 7 ==> ok
test string-scan-right, expects 20 ==> ok
test string-scan, expects "あえいうえおあ" ==> ok
test string-scan-right, expects "あえいうえおあおあいうえおあえいうえおあ" ==> ok
test string-scan, expects "うえおあえいうえおあおあいうえお" ==> ok
test string-scan-right, expects "うえお" ==> ok
test string-scan, expects ("あえいうえおあ" "おあいうえおあえいうえおあおあいうえお") ==> ok
test string-scan-right, expects ("あえいうえおあおあいうえおあえいうえおあ" "おあいうえお") ==> ok
test string-scan, expects ("あえいうえおあおあい" "うえおあえいうえおあおあいうえお") ==> ok
test string-scan-right, expects ("あえいうえおあおあいうえおあえいうえおあおあい" "うえお") ==> ok
test string-scan, expects ("あえいうえおあ" "うえおあえいうえおあおあいうえお") ==> ok
test string-scan-right, expects ("あえいうえおあおあいうえおあえいうえおあ" "うえお") ==> ok
test string-scan, expects #f ==> ok
test string-scan-right, expects #f ==> ok
<string-pointer>---------------------------------------------------------------
test make-string-pointer, expects #t ==> ok
test string-pointer-next!, expects #\い ==> ok
test string-pointer-next!, expects #\ろ ==> ok
test string-pointer-prev!, expects #\ろ ==> ok
test string-pointer-prev!, expects #\い ==> ok
test string-pointer-prev!, expects #t ==> ok
test string-pointer-index, expects 0 ==> ok
test string-pointer-index, expects 8 ==> ok
test string-pointer-substring, expects ("いろはにhoへと" "") ==> ok
test string-pointer-substring, expects ("いろはにh" "oへと") ==> ok
test string-pointer-substring, expects ("" "いろはにhoへと") ==> ok
<incomplete strings>-----------------------------------------------------------
test string-length, expects 9 ==> ok
test string-complete->incomplete, expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86" ==> ok
test string-complete->incomplete, expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86" ==> ok
test string-incomplete->complete, expects "あいう" ==> ok
test string-incomplete->complete, expects "あいう" ==> ok
test string-incomplete->complete (reject), expects #f ==> ok
test string-incomplete->complete (omit), expects "あいう" ==> ok
test string-incomplete->complete (omit), expects "あいう" ==> ok
test string-incomplete->complete (omit), expects "あいう" ==> ok
test string-incomplete->complete (omit), expects "あいう" ==> ok
test string-incomplete->complete (omit), expects "あいう" ==> ok
test string-incomplete->complete (omit), expects "あいう" ==> ok
test string-incomplete->complete (replace), expects "あいふう" ==> ok
test string-incomplete->complete (replace), expects "ふあいう" ==> ok
test string-incomplete->complete (replace), expects "ふふあいう" ==> ok
test string-incomplete->complete (replace), expects "あいうふ" ==> ok
test string-incomplete->complete (replace), expects "あいうふふ" ==> ok
test string-incomplete->complete (replace), expects "あいうふふ" ==> ok
test string=?, expects #t ==> ok
test string-byte-ref, expects 129 ==> ok
test string-append, expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a" ==> ok
test string-append, expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a" ==> ok
test string-append, expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a" ==> ok
test string-append, expects 15 ==> ok
test string-incomplete->complete, expects "あ" ==> ok
<format>-----------------------------------------------------------------------
test format, expects "あぶら" ==> ok
test format, expects "abら" ==> ok
test format, expects "あぶらかだぶら" ==> ok
test format, expects "あぶらか" ==> ok
test format, expects "あぶら ..." ==> ok
<string-library>---------------------------------------------------------------
test string-every, expects #t ==> ok
test string-every, expects #t ==> ok
test string-every, expects #f ==> ok
test string-every, expects #t ==> ok
test string-every, expects #f ==> ok
test string-every, expects #t ==> ok
test string-every, expects #t ==> ok
test string-every, expects #f ==> ok
test string-any, expects #t ==> ok
test string-any, expects #f ==> ok
test string-any, expects #f ==> ok
test string-any, expects #t ==> ok
test string-any, expects #f ==> ok
test string-any, expects #f ==> ok
test string-any, expects #t ==> ok
test string-any, expects #f ==> ok
test string-tabulate, expects "アィイゥウ" ==> ok
test reverse-list->string, expects "んをわ" ==> ok
test string-copy!, expects "abうえおfg" ==> ok
test string-take, expects "あいうえ" ==> ok
test string-drop, expects "おか" ==> ok
test string-take-right, expects "うえおか" ==> ok
test string-drop-right, expects "あい" ==> ok
test string-pad, expects "■■パッド" ==> ok
test string-pad, expects "パディング" ==> ok
test string-pad, expects "ディングス" ==> ok
test string-pad-right, expects "パッド■■" ==> ok
test string-pad, expects "パディング" ==> ok
<char set>---------------------------------------------------------------------
test char-set, expects #t ==> ok
test char-set, expects #t ==> ok
test char-set, expects #t ==> ok
test char-set, expects #t ==> ok
<ports>------------------------------------------------------------------------
test read-char, expects #\イ ==> ok
test read-byte, expects 227 ==> ok
test read-byte (using scratch), expects 173 ==> ok
test read-char (using scratch), expects #\ハ ==> ok
test read-block (using scratch), expects #*"\xe3\x83\x8b" ==> ok
test read-block (using scratch), expects #*"\xe3" ==> ok
test read-block (using scratch), expects #*"\x83\x9b\xe3\x83\x98\xe3\x83\x88" ==> ok
test peek-byte, expects 227 ==> ok
test peek-char, expects #\イ ==> ok
test read-byte, expects 227 ==> ok
test peek-byte, expects 130 ==> ok
test peek-char, expects #\ロ ==> ok
test read-byte, expects #\ロ ==> ok
test peek-byte, expects 131 ==> ok
test read-block, expects #*"\x83\x8f\xe3\x83\x8b\xe3\x83\x9b\xe3\x83\x98\xe3\x83" ==> ok
test peek-byte, expects 136 ==> ok
test peek-byte, expects #t ==> ok
test read-line (LF), expects "なむ" ==> ok
test read-line (CR), expects "なむ" ==> ok
test read-line (CRLF), expects "なむ" ==> ok
test read-line (using ungotten), expects "なむ" ==> ok
test read-line (using ungotten), expects "なむ" ==> ok
<buffered ports>---------------------------------------------------------------
test buffered port (getc, bufsiz=256), expects (#\あ #\い #\う #\え #\お #\か #\き #\く #\け #\こ) ==> ok
test buffered port (getc, bufsiz=7), expects (#\あ #\い #\う #\え #\お #\か #\き #\く #\け #\こ) ==> ok
test buffered port (getc, bufsiz=3), expects (#\あ #\い #\う #\え #\お #\か #\き #\く #\け #\こ) ==> ok
test buffered port (getc, bufsiz=2), expects (#\あ #\い #\う #\え #\お #\か #\き #\く #\け #\こ) ==> ok
test buffered port (getc, bufsiz=1), expects (#\あ #\い #\う #\え #\お #\か #\き #\く #\け #\こ) ==> ok
test buffered port (getb, bufsiz=256), expects (227 129 130 227 129 132 227 129 134 227 129 136 227 129 138 227 129 139 227 129 141 227 129 143 227 129 145 227 129 147) ==> ok
test buffered port (getb, bufsiz=20), expects (227 129 130 227 129 132 227 129 134 227 129 136 227 129 138 227 129 139 227 129 141 227 129 143 227 129 145 227 129 147) ==> ok
test buffered port (getb, bufsiz=19), expects (227 129 130 227 129 132 227 129 134 227 129 136 227 129 138 227 129 139 227 129 141 227 129 143 227 129 145 227 129 147) ==> ok
test buffered port (getb, bufsiz=2), expects (227 129 130 227 129 132 227 129 134 227 129 136 227 129 138 227 129 139 227 129 141 227 129 143 227 129 145 227 129 147) ==> ok
test buffered port (getb, bufsiz=1), expects (227 129 130 227 129 132 227 129 134 227 129 136 227 129 138 227 129 139 227 129 141 227 129 143 227 129 145 227 129 147) ==> ok
test buffered port (getz, siz=20,5), expects (#*"\xe3\x81\x82\xe3\x81" #*"\x84\xe3\x81\x86\xe3" #*"\x81\x88\xe3\x81\x8a" #*"\xe3\x81\x8b\xe3\x81" #*"\x8d\xe3\x81\x8f\xe3" #*"\x81\x91\xe3\x81\x93") ==> ok
test buffered port (getz, siz=20,20), expects (#*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81" #*"\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93") ==> ok
test buffered port (getz, siz=9,20), expects (#*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81" #*"\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93") ==> ok
test buffered port (getz, siz=9,7), expects (#*"\xe3\x81\x82\xe3\x81\x84\xe3" #*"\x81\x86\xe3\x81\x88\xe3\x81" #*"\x8a\xe3\x81\x8b\xe3\x81\x8d" #*"\xe3\x81\x8f\xe3\x81\x91\xe3" #*"\x81\x93") ==> ok
test buffered port (getz, siz=3,50), expects (#*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93") ==> ok
test buffered port (getz, siz=2,7), expects (#*"\xe3\x81\x82\xe3\x81\x84\xe3" #*"\x81\x86\xe3\x81\x88\xe3\x81" #*"\x8a\xe3\x81\x8b\xe3\x81\x8d" #*"\xe3\x81\x8f\xe3\x81\x91\xe3" #*"\x81\x93") ==> ok
test buffered port (getz, siz=1,7), expects (#*"\xe3\x81\x82\xe3\x81\x84\xe3" #*"\x81\x86\xe3\x81\x88\xe3\x81" #*"\x8a\xe3\x81\x8b\xe3\x81\x8d" #*"\xe3\x81\x8f\xe3\x81\x91\xe3" #*"\x81\x93") ==> ok
test buffered port (putb, bufsiz=7), expects #*"@ABCDEFGHIJKLMNOPQRSTUVWXYZ" ==> ok
test buffered port (putb, bufsiz=30), expects #*"@ABCDEFGHIJKLMNOPQRSTUVWXYZ" ==> ok
test buffered port (putc, bufsiz=7), expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93\xe3\x81\x95\xe3\x81\x97\xe3\x81\x99\xe3\x81\x9b\xe3\x81\x9d" ==> ok
test buffered port (putc, bufsiz=30), expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93\xe3\x81\x95\xe3\x81\x97\xe3\x81\x99\xe3\x81\x9b\xe3\x81\x9d" ==> ok
test buffered port (puts, bufsiz=6), expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93\xe3\x81\x95\xe3\x81\x97\xe3\x81\x99\xe3\x81\x9b\xe3\x81\x9d" ==> ok
test buffered port (puts, bufsiz=7), expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93\xe3\x81\x95\xe3\x81\x97\xe3\x81\x99\xe3\x81\x9b\xe3\x81\x9d" ==> ok
test buffered port (puts, bufsiz=7), expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93\xe3\x81\x95\xe3\x81\x97\xe3\x81\x99\xe3\x81\x9b\xe3\x81\x9d" ==> ok
test buffered port (puts, bufsiz=3), expects #*"\xe3\x81\x82\xe3\x81\x84\xe3\x81\x86\xe3\x81\x88\xe3\x81\x8a\xe3\x81\x8b\xe3\x81\x8d\xe3\x81\x8f\xe3\x81\x91\xe3\x81\x93\xe3\x81\x95\xe3\x81\x97\xe3\x81\x99\xe3\x81\x9b\xe3\x81\x9d" ==> ok
<regexp>-----------------------------------------------------------------------
test regexp, expects "いaろbはc" ==> ok
test regexp, expects "いaろBはC" ==> ok
test regexp, expects #f ==> ok
test regexp, expects "あいa" ==> ok
test regexp, expects #f ==> ok
test regexp, expects "あいう" ==> ok
test regexp, expects "あいa" ==> ok
test regexp, expects #f ==> ok
test regexp, expects "あい" ==> ok
test regexp, expects "う" ==> ok
test regexp, expects #f ==> ok
test regexp, expects "う" ==> ok
test regexp, expects "う" ==> ok
test regexp, expects #f ==> ok
test regexp (full coverage - start), expects ("あa" "あaいiうu") ==> ok
test regexp (full coverage - length), expects ("いiう" "aいiうuえeお") ==> ok
test regexp (full coverage - after), expects ("おo" "iうuえeおo") ==> ok
test regexp (full coverage - memoized length/after), expects ("えeお" "o") ==> ok
test regexp (full coverage - memoized start/after), expects ("あ" "おo") ==> ok
test regexp (full coverage - memoized start/length), expects ("あa" "いi") ==> ok
test regexp/unicode-ci (aa), expects "λ" ==> ok
test regexp/unicode-ci (aA), expects "Λ" ==> ok
test regexp/unicode-ci (Aa), expects "λ" ==> ok
test regexp/unicode-ci (AA), expects "Λ" ==> ok
test regexp/unicode-ci (uncase + backref, aa), expects "λλ" ==> ok
test regexp/unicode-ci (uncase + backref, aA), expects "λΛ" ==> ok
test regexp/unicode-ci (uncase + backref, Aa), expects "Λλ" ==> ok
test regexp/unicode-ci (uncase + backref, AA), expects "ΛΛ" ==> ok
test regexp/unicode-ci (charset, aa), expects "λ" ==> ok
test regexp/unicode-ci (charset, aA), expects "Λ" ==> ok
test regexp/unicode-ci (charset, Aa), expects "λ" ==> ok
test regexp/unicode-ci (charset, AA), expects "Λ" ==> ok
test regexp/unicode-ci, expects "ΒΓ" ==> ok
test regexp/unicode-ci, expects "βΓ" ==> ok
test regexp/unicode-ci, expects "βγ" ==> ok
test regexp/unicode-ci, expects #f ==> ok
test regexp/unicode-ci, expects #f ==> ok
test regexp/unicode-ci, expects "ОНА" ==> ok
test regexp/unicode-ci, expects "она" ==> ok
test regexp/unicode-ci, expects "они" ==> ok
test regexp/unicode-ci, expects #f ==> ok
test regexp/unicode-ci, expects #f ==> ok
test regexp/unicode-ci, expects #f ==> ok
test regexp/unicode-ci, expects "она" ==> ok
test regexp/unicode-ci, expects #f ==> ok
passed.
Testing system ================================================================
<system>-----------------------------------------------------------------------
test system, expects #t ==> ok
test system, expects #t ==> ok
<environment>------------------------------------------------------------------
test getenv, expects "/usr/lib/lightdm/lightdm:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/home/shuji/gauche/command" ==> ok
test getcwd, expects "/home/shuji/gauche-dev/Gauche/src" ==> ok
test sys-environ->alist, expects (("A" . "B") ("A" . "") ("" . "B") ("A" . "B=C")) ==> ok
test sys-environ (HOME), expects #t ==> ok
test sys-environ (USER), expects #t ==> ok
test sys-environ (LANG), expects #t ==> ok
test sys-environ (PWD), expects #t ==> ok
test sys-environ (TERM), expects #t ==> ok
test sys-environ (SHELL), expects #t ==> ok
<pathnames>--------------------------------------------------------------------
test basename, expects "ghi.jkl" ==> ok
test dirname, expects "/abc/def" ==> ok
test basename, expects "ghi.jkl" ==> ok
test dirname, expects "/abc/def" ==> ok
test basename, expects "ghi.jkl" ==> ok
test dirname, expects "/abc//def" ==> ok
test basename, expects "ghi.jkl" ==> ok
test dirname, expects "." ==> ok
test basename, expects "" ==> ok
test dirname, expects "." ==> ok
test basename, expects "" ==> ok
test dirname, expects "/" ==> ok
test basename, expects "" ==> ok
test dirname, expects "/" ==> ok
test basename, expects "abc" ==> ok
test dirname, expects "/" ==> ok
test basename, expects "abc" ==> ok
test dirname, expects "/" ==> ok
test basename, expects ".." ==> ok
test dirname, expects "." ==> ok
test basename, expects ".." ==> ok
test dirname, expects ".." ==> ok
test normalize, expects "/home/shuji/gauche-dev/Gauche/src/." ==> ok
test normalize, expects "/home/shuji/gauche-dev/Gauche/src/" ==> ok
test normalize, expects "/home/shuji/abc" ==> ok
test normalize, expects "/a/b/c/d/e" ==> ok
test normalize, expects "/a/b/c/d/e/" ==> ok
test normalize, expects "/a/b/c/d/e/" ==> ok
test normalize, expects "/a/b/" ==> ok
test normalize, expects "/c/d/" ==> ok
test normalize, expects "/e/f/" ==> ok
test normalize, expects "" ==> ok
test normalize, expects "../.." ==> ok
test normalize, expects "../../x/y" ==> ok
<filesystem>-------------------------------------------------------------------
test access, expects (#f #f #f #f) ==> ok
test unlink, expects #f ==> ok
test mkdir, expects #/drw[sx]r-[sx]---/ ==> ok
test chmod, expects #/drw[sx]r-[sx]r-x/ ==> ok
test fchmod, expects #/drw[sx]r-[sx]---/ ==> ok
test rename, expects (#f #t) ==> ok
test readdir, expects ("." ".." "zzZzz") ==> ok
test link, expects ("." ".." "xyzzy" "zzZzz") ==> ok
test unlink, expects ("." ".." "xyzzy") ==> ok
test rename, expects ("." ".." "zzZzz") ==> ok
test truncate, expects "abcdefghijklmno" ==> ok
test ftruncate, expects "abcde" ==> ok
test rmdir, expects #f ==> ok
test sys-realpath (/), expects "/" ==> ok
test sys-realpath (.), expects "/home/shuji/gauche-dev/Gauche/src" ==> ok
test sys-realpath (symlink), expects "/home/shuji/gauche-dev/Gauche/src/test1.o" ==> ok
test sys-realpath (symlink), expects "/home/shuji/gauche-dev/Gauche/src/test1.o" ==> ok
test sys-realpath (symlink), expects "/home/shuji/gauche-dev/Gauche/src/test1.o" ==> ok
test sys-realpath (dangling), expects #<error> ==> ok
test sys-realpath (symlink to dir), expects "/home/shuji/gauche-dev/Gauche/src/test1.o/test.o" ==> ok
test sys-realpath (NOENT), expects #<<system-error>> ==> ok
<time>-------------------------------------------------------------------------
test srfi time, expects #t ==> ok
test srfi time time->seconds, expects #t ==> ok
test srfi time seconds->time, expects (98765432109876 500000000) ==> ok
test srfi time setter, expects #<time-utc -98765432109875.999999996> ==> ok
<stat>-------------------------------------------------------------------------
test stat, expects (428 regular 5) ==> ok
test fstat, expects (428 regular 5) ==> ok
test stat, expects (448 directory) ==> ok
test fstat, expects (448 directory) ==> ok
<pipe>-------------------------------------------------------------------------
test pipe, expects "abc" ==> ok
test pipe and char-ready? (none), expects (#f #t #f) ==> ok
test pipe and char-ready? (line), expects (#f #t #t) ==> ok
test pipe and char-ready? (full), expects (#f #f #t) ==> ok
test pipe and read-block(none), expects 2 ==> ok
test pipe and read-block(line), expects 2 ==> ok
<fork&exec>--------------------------------------------------------------------
test fork & wait, expects #t ==> ok
test fork & waitpid, expects #t ==> ok
test fork, wait & kill, expects #t ==> ok
test fork, wait, kill & sleep, expects #t ==> ok
test fork & pipe, expects 70000 ==> ok
test fork, exec and signal mask, expects #t ==> ok
test fork, exec and detached process (not detached), expects (parent 31953 pgrp 30077) ==> ok
test fork, exec and detached process (detached), expects (parent 1 pgrp #t) ==> ok
<select>-----------------------------------------------------------------------
test fdset, expects (3 #t #f #t #t #f) ==> ok
test fdset, expects (-1 7 7 4 10 10 -1) ==> ok
test sys-fdset, expects (0 9 10) ==> ok
test list->sys-fdset, expects (1 3 5 7 9) ==> ok
test sys-fdset-copy!, expects (2 4 5) ==> ok
test sys-fdset-clear!, expects () ==> ok
test select, expects (0 #f #f #f #f 1 #t #f #f #t #\x) ==> ok
<signal handling>--------------------------------------------------------------
test sigalrm1, expects 14 ==> ok
test sigalrm2, expects 0 ==> ok
test sigalrm3, expects #<error> ==> ok
test sigalrm4 (interrupting syscall), expects 14 ==> ok
test sigalrm5 (interrupting syscall - restart), expects (a) ==> ok
test sigalrm6 (interrupting syscall - restart), expects (#t 0) ==> ok
test fork & sigint, expects #t ==> ok
test sigchld, expects 17 ==> ok
test sigmask, expects hup ==> ok
test sigmask during interrupt handler (default), expects #t ==> ok
test sigmask during interrupt handler (explicit), expects #t ==> ok
test sigmask during interrupt handler (multi/default), expects #t ==> ok
test sigmask during interrupt handler (multi/explicit), expects #t ==> ok
test sigmask during interrupt handler (reentrance), expects boo ==> ok
test sigmask during interrupt handler (multi/reentrance), expects boo ==> ok
passed.
Testing autoload and autoprovide ==============================================
<autoload and implicit generic definition>-------------------------------------
test autoload triggered by implicit generic definition, expects foo1-list ==> ok
test autoload triggered by implicit generic definition, expects foo2-list ==> ok
<autoload and class redefinition check>----------------------------------------
test autoload triggered by class redefinition check, expects y ==> ok
<circular autoload>------------------------------------------------------------
test circular-autoload, expects #<error> ==> ok
<autoprovide feature>----------------------------------------------------------
test autoprovide - basic, expects #t ==> ok
test autoprovide - providing different feature, expects (#f #t #t) ==> ok
test autoprovide - disabling autoprovide, expects #f ==> ok
test autoprovide - cascading require, expects (#f #t) ==> ok
<relative load path>-----------------------------------------------------------
test relative load path, expects "ok!" ==> ok
passed.
Testing rfc ===================================================================
<rfc.822>----------------------------------------------------------------------
testing bindings in #<module rfc.822> ... ok
test rfc822-read-headers, expects #t ==> ok
test rfc822-field->tokens (basic), expects (("aa") ("bb") ("cc") ("dd") ("ee") (" a\"aa\\aa (a)")) ==> ok
test rfc822-field->tokens, expects ("from" "aaaaa.aaa.org" "by" "ggg.gggg.net" "with" "ESMTP" "id" "24D50175C8") ==> ok
test rfc822-parse-date, expects (2003 3 4 12 34 56 -3600 2) ==> ok
test rfc822-parse-date, expects (2003 3 4 12 34 56 0 2) ==> ok
test rfc822-parse-date (no weekday), expects (2003 3 4 12 34 56 -3600 #f) ==> ok
test rfc822-parse-date (no timezone), expects (2003 3 4 12 34 56 #f #f) ==> ok
test rfc822-parse-date (old tz), expects (2003 3 4 12 34 56 #f #f) ==> ok
test rfc822-parse-date (no seconds), expects (2003 3 4 12 34 #f 900 #f) ==> ok
test rfc822-parse-date (no seconds), expects (2003 3 4 12 34 #f 900 2) ==> ok
test rfc822-parse-date (2digit year), expects (2003 3 4 12 34 56 -3600 2) ==> ok
test rfc822-parse-date (2digit year), expects (1987 3 4 12 34 56 -3600 2) ==> ok
test rfc822-parse-date (Weekday, exhausive), expects (0 1 2 3 4 5 6 #f) ==> ok
test rfc822-parse-date (Months, exhausive), expects (1 2 3 4 5 6 7 8 9 10 11 12 #f) ==> ok
test rfc822-parse-date (invalid), expects (#f #f #f #f #f #f #f #f) ==> ok
test date->rfc822-date, expects "Sun, 29 Nov 2009 01:23:45 +0000" ==> ok
test date->rfc822-date, expects "Sun, 29 Nov 2009 01:23:45 +0900" ==> ok
test date->rfc822-date, expects "Sun, 29 Nov 2009 01:23:45 -0830" ==> ok
test date->rfc822-date, expects "Sun, 29 Nov 2009 01:23:45 +0030" ==> ok
test rfc822-invalid-header-field, expects #f ==> ok
test rfc822-invalid-header-field, expects incomplete-string ==> ok
test rfc822-invalid-header-field, expects bad-character ==> ok
test rfc822-invalid-header-field, expects bad-character ==> ok
test rfc822-invalid-header-field, expects line-too-long ==> ok
test rfc822-invalid-header-field, expects line-too-long ==> ok
test rfc822-invalid-header-field, expects stray-crlf ==> ok
test rfc822-invalid-header-field, expects stray-crlf ==> ok
test rfc822-invalid-header-field, expects stray-crlf ==> ok
test rfc822-write-headers, expects "name: Shiro Kawai\r\naddress: 1234 Lambda St.\r\n Higher Order Functions, HI, 99899\r\nregistration-date: 2007-12-10\r\n\r\n" ==> ok
test rfc822-write-headers (ignore error), expects (#0="name: Shiro\0Kawai\r\n\r\n" #0#) ==> ok
test rfc822-write-headers (continue), expects "x: A\r\nx: B\r\nx: C\r\n\r\n" ==> ok
test rfc822-write-headers error (bad-character), expects "bad-character" ==> ok
test rfc822-write-headers handle (bad-character), expects "x-name: bad-character\r\n\r\n" ==> ok
test rfc822-write-headers error (incomplete-string), expects "incomplete-string" ==> ok
test rfc822-write-headers handle (incomplete-string), expects "x-name: incomplete-string\r\n\r\n" ==> ok
test rfc822-write-headers error (stray-crlf), expects "stray-crlf" ==> ok
test rfc822-write-headers handle (stray-crlf), expects "x-name: stray-crlf\r\n\r\n" ==> ok
test rfc822-write-headers error (line-too-long), expects "line-too-long" ==> ok
test rfc822-write-headers handle (line-too-long), expects "x-name: line-too-long\r\n\r\n" ==> ok
<rfc.base64>-------------------------------------------------------------------
testing bindings in #<module rfc.base64> ... ok
test encode, expects "" ==> ok
test encode, expects "YQ==" ==> ok
test encode, expects "MA==" ==> ok
test encode, expects "Cg==" ==> ok
test encode, expects "YTA=" ==> ok
test encode, expects "YTAK" ==> ok
test encode, expects "PQk0" ==> ok
test encode, expects "eTQ5YQ==" ==> ok
test encode, expects "RWdqYWk=" ==> ok
test encode, expects "OTNiamFl" ==> ok
test encode, expects "QkFSMGVyOQ==" ==> ok
test encode w/ line width (default), expects "MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2\n" ==> ok
test encode w/ line width 10, e1, expects "MDEyMzQ1Ng\n==" ==> ok
test encode w/ line width 11, e1, expects "MDEyMzQ1Ng=\n=" ==> ok
test encode w/ line width 12, e1, expects "MDEyMzQ1Ng==\n" ==> ok
test encode w/ line width 11, e2, expects "MDEyMzQ1Njc\n=" ==> ok
test encode w/ line width 12, e2, expects "MDEyMzQ1Njc=\n" ==> ok
test encode w/ line width 4, expects "MDEy\nMzQ=\n" ==> ok
test encode w/ line width 3, expects "MDE\nyMz\nQ=" ==> ok
test encode w/ line width 2, expects "MD\nEy\nMz\nQ=\n" ==> ok
test encode w/ line width 1, expects "M\nD\nE\ny\nM\nz\nQ\n=\n" ==> ok
test encode w/ line width 0, expects "MDEyMzQ=" ==> ok
test decode, expects "" ==> ok
test decode, expects "a" ==> ok
test decode, expects "a" ==> ok
test decode, expects "a" ==> ok
test decode, expects "a0" ==> ok
test decode, expects "a0" ==> ok
test decode, expects "a0\n" ==> ok
test decode, expects "y49a" ==> ok
test decode, expects "Egjai" ==> ok
test decode, expects "93bjae" ==> ok
test decode, expects "BAR0er9" ==> ok
test decode, expects "BAR0er9" ==> ok
<rfc.quoted-printable>---------------------------------------------------------
testing bindings in #<module rfc.quoted-printable> ... ok
test encode, expects "abcd=0Cefg" ==> ok
test encode, expects "abcd\r\nefg" ==> ok
test encode (tab/space at eol), expects "abcd=09\r\nefg=20\r\n" ==> ok
test encode (soft line break), expects "0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abc=\r\ndefghij0123456789abcdefghij" ==> ok
test encode (soft line break w/line-width), expects "0123456789abcdefg=\r\nhij0123456789abcd=\r\nefghij" ==> ok
test encode (soft line break w/line-width), expects "0123456789abcdef=3D=\r\nghij0123456789a=3D=\r\n=3Dbcdefghij" ==> ok
test encode (soft line break w/line-width lower bound), expects "a=\r\n=3F=\r\nb" ==> ok
test encode (no line break), expects "0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij0123456789abcdefghij" ==> ok
test encode (hard line break), expects "a\r\nb\r\nc\r\n" ==> ok
test encode (binary), expects "a=0Db=0Ac=0D=0A" ==> ok
test decode, expects "\x01\x08abcde=\r\n" ==> ok
test decode (soft line break), expects "Now's the time for all folk to come to the aid of their country." ==> ok
test decode (robustness), expects "foo=1qr =  j\r\n" ==> ok
<rfc.cookie>-------------------------------------------------------------------
testing bindings in #<module rfc.cookie> ... ok
test parse, old, expects (("foo" "bar") ("aaa" "bbb" :path "/a/b" :domain "a.b.com") ("x12" "Yy \"yY\" ;; Zz" :port "100, 200, 300") ("zzz" #f) ("_n_" "") ("mmm" "ppp")) ==> ok
test parse, new, expects (("$Version" "1") ("foo" "bar") ("aaa" "bbb" :path "/a/b" :domain "a.b.com") ("x12" "Yy \"yY\" ;; Zz" :port "100, 200, 300") ("zzz" #f) ("_n_" "") ("mmm" "ppp")) ==> ok
test parse, new, expects (("foo" "bar") ("aaa" "bbb" :path "/a/b" :domain "a.b.com") ("x12" "Yy \"yY\" ;; Zz" :port "100, 200, 300") ("zzz" #f) ("_n_" "") ("mmm" "ppp")) ==> ok
test cookie, old, expects ("guest-id=foo123;Domain=foo.com;Path=/abc;Expires=Sun, 09-Sep-2001 01:46:40 GMT" "guest-account=87975348;Domain=zzz.com;Path=/zzz;Secure") ==> ok
test cookie, new, expects ("guest-id=foo123;Domain=foo.com;Path=/abc;Max-Age=864000;Discard;Comment=hogehoge;CommentURL=\"http://foo.com/hogehoge\";Port=\"80, 8080\";Version=1" "guest-account=87975348;Domain=zzz.com;Path=/zzz;Secure;Comment=\"ZzzZzz, OooOoo\";CommentURL=\"http://foo.com/hogehoge\"") ==> ok
test cookie, old, srfi-19 date, expects ("foo=bar;Expires=Sun, 09-Sep-2001 01:46:40 GMT" "foo=baz;Expires=Sun, 09-Sep-2001 01:46:40 GMT") ==> ok
<rfc.ftp>----------------------------------------------------------------------
testing bindings in #<module rfc.ftp> ... ok
<rfc.icmp>---------------------------------------------------------------------
testing bindings in #<module rfc.icmp> ... ok
<rfc.ip>-----------------------------------------------------------------------
testing bindings in #<module rfc.ip> ... ok
test ip-version, expects 4 ==> ok
test ip-version, expects 6 ==> ok
test ip-protocol, expects 1 ==> ok
test ip-protocol, expects 17 ==> ok
test ip-protocol, expects 17 ==> ok
<rfc.mime>---------------------------------------------------------------------
testing bindings in #<module rfc.mime> ... ok
test mime-parse-version, expects ((1 0) (1 0) (1 0) (1 0) #f) ==> ok
test mime-parse-content-type, expects ("text" "plain") ==> ok
test mime-parse-content-type, expects ("text" "plain" ("charset" . "us-ascii")) ==> ok
test mime-parse-content-type, expects ("text" "plain" ("charset" . "us-ascii")) ==> ok
test mime-parse-content-type, expects ("text" "plain" ("charset" . "iso-2022-jp")) ==> ok
test mime-parse-content-type, expects ("text" "plain" ("zzz" . "yyy") ("xxx" . "www")) ==> ok
test mime-parse-content-type, expects ("multipart" "alternative" ("boundary" . "=_alternative 006EBAA488256DF0_=")) ==> ok
test mime-compose-parameters (simple), expects "; ab=cd; ef=gh" ==> ok
test mime-compose-parameters (quote), expects "; ab=\"c d\"; ef=\"\\\"\\\\\"" ==> ok
test mime-compose-parameters (long), expects "; ab=cd;\r\n foo=012345678901234567890123456789012345679012345678901234567890123456789" ==> ok
test mime-encode-text (pass-through), expects "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\r\n tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim\r\n veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea\r\n commodo consequat. Duis aute irure dolor in reprehenderit in voluptate\r\n velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat\r\n cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id\r\n est laborum." ==> ok
test mime-encode-text (pass-through, nonbreak), expects "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum." ==> ok
test mime-encode-text (pass-through, forced line break), expects "Loremipsumdolorsitamet,consecteturadipisicingelit,seddoeiusmodtemporincididu\r\n ntutlaboreetdoloremagnaaliqua." ==> ok
test mime-encode-text, expects "=?utf-8?B?zrvjga7lroflrpnjgbjjgojjgYbjgZPjgZ0=?=\r\n =?utf-8?B?44CCV2VsY29tZSB0byDOuy1zcGFjZQ==?=" ==> ok
test mime-encode-text (nobreak), expects "=?utf-8?B?zrvjga7lroflrpnjgbjjgojjgYbjgZPjgZ3jgIJXZWxjb21lIHRvIM67LXNwYWNl?=" ==> ok
test mime-decode-word, expects "this is some text" ==> ok
test mime-decode-text, expects "this is some text" ==> ok
test mime-decode-text, expects "this is some text" ==> ok
test mime-encode-word, expects "=?iso-8859-1?Q?this=20is=20some=20text?=" ==> ok
test mime-encode-text, expects "=?iso-8859-1?B?VGhlIHF1aWNr?=\r\n =?iso-8859-1?B?IGJyb3duIGZv?=\r\n =?iso-8859-1?B?eCBqdW1wcyBv?=\r\n =?iso-8859-1?B?dmVyIHRoZSBs?=\r\n =?iso-8859-1?B?YXp5IGRvZw==?=" ==> ok
test mime-encode-text, expects "\r\n =?iso-8859-1?B?VGhlIHF1aWNrIGJyb3du?=\r\n =?iso-8859-1?B?IGZveCBqdW1wcyBvdmVy?=\r\n =?iso-8859-1?B?IHRoZSBsYXp5IGRvZw==?=" ==> ok
test mime-decode-word, expects "Keith_Moore" ==> ok
test mime-decode-word, expects "Keith_Moore" ==> ok
test mime-decode-text, expects "Keith/Moore" ==> ok
test mime-encode-text, expects "=?us-ascii?B?VGhlIHF1aWNr?=\r\n =?us-ascii?B?IGJyb3duIGZv?=\r\n =?us-ascii?B?eCBqdW1wcyBv?=\r\n =?us-ascii?B?dmVyIHRoZSBs?=\r\n =?us-ascii?B?YXp5IGRvZw==?=" ==> ok
test mime-decode-word, expects "川合 史朗" ==> ok
test mime-decode-text, expects "(川合 史朗)" ==> ok
test mime-encode-word, expects "=?iso-2022-jp?B?GyRCQG45ZxsoQiAbJEI7S08vGyhC?=" ==> ok
test mime-decode-word, expects "=?ISO-2022-JP?B?GyRCJDkbKBsoQg==?=" ==> ok
test mime-decode-text, expects "(=?ISO-2022-JP?B?GyRCJDkbKBsoQg==?=)" ==> ok
test mime-parse-message (0 - # simple multipart test), expects ("multipart/mixed" 0 ("text/plain" 0 "This is implicitly typed plain US-ASCII text.\nIt does NOT end with a linebreak.") ("text/plain" 1 "This is explicitly typed plain US-ASCII text.\nIt DOES end with a linebreak.\n")) ==> ok
test mime-parse-message (1 - # multipart/alternative test), expects ("multipart/alternative" 0 ("text/plain" 0 "  ... plain text version of message goes here ...\n") ("text/enriched" 1 "  ... RFC 1896 text/enriched version of same message\n      goes here ...\n") ("application/x-whatever" 2 "  ... fanciest version of same message goes here ...\n")) ==> ok
test mime-parse-message (2 - # multipart/digest test), expects ("multipart/mixed" 0 ("text/plain" 0 "  ...Introductory text or table of contents...\n") ("multipart/digest" 1 ("message/rfc822" 0 ("text/plain" 0 "  ...body goes here ...\n")) ("message/rfc822" 1 ("text/plain" 0 "  ... another body goes here ...\n")))) ==> ok
test mime-parse-message (3 - # complex multipart test), expects ("multipart/mixed" 0 ("text/plain" 0 "  ... Some text appears here ...\n\n[Note that the blank between the boundary and the start\n of the text in this part means no header fields were\n given and this is text in the US-ASCII character set.\n It could have been done with explicit typing as in the\n next part.]\n") ("text/plain" 1 "This could have been part of the previous part, but\nillustrates explicit versus implicit typing of body\nparts.\n") ("multipart/parallel" 2 ("audio/basic" 0 "  ... base64-encoded 8000 Hz single-channel\n      mu-law-format audio data goes here ...\n") ("image/jpeg" 1 "  ... base64-encoded image data goes here ...\n")) ("text/enriched" 3 "This is <bold><italic>enriched.</italic></bold>\n<smaller>as defined in RFC 1896</smaller>\n\nIsn't it\n<bigger><bigger>cool?</bigger></bigger>\n") ("message/rfc822" 4 ("text/plain" 0 "  ... Additional text in ISO-8859-1 goes here ...\n"))) ==> ok
test mime-parse-message (4 - # unclosed multipart body), expects ("multipart/mixed" 0 ("text/plain" 0 "  ...Introductory text or table of contents...\n") ("multipart/digest" 1 ("message/rfc822" 0 ("text/plain" 0 "  ...body goes here ...\n")) ("message/rfc822" 1 ("text/plain" 0 ""))) ("text/plain" 2 "The previous part has been chopped.")) ==> ok
test mime-parse-message (5 - # unclosed multipart body), expects ("multipart/mixed" 0 ("text/plain" 0 "  ...Introductory text or table of contents...\n") ("multipart/digest" 1 ("message/rfc822" 0 ("text/plain" 0 "  ...body goes here ...\n")) ("message/rfc822" 1 ("text/plain" 0 "  ... another body goes here ...\n")))) ==> ok
test mime-parse-message (6 - # multipart/form-data), expects ("multipart/form-data" 0 ("text/plain" 0 "up") ("application/octet-stream" 1 "") ("text/plain" 2 "Submit")) ==> ok
test mime-parse-message (7 - # binary body), expects ("multipart/mixed" 0 ("application/binary" 0 "\0\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\0\r") ("application/binary" 1 "\r") ("application/binary" 2 "--") ("application/binary" 3 "--bb-")) ==> ok
test mime-compose-message (simple), expects "\r\n--boundary-1cl1i6m3lvlppm476t4134\r\nContent-type: text/plain\r\nContent-transfer-encoding: 7bit\r\n\r\nThis is a pen.\r\n--boundary-1cl1i6m3lvlppm476t4134\r\nContent-type: text/html; charset=us-ascii\r\n\r\n<html><head></head><body></body></html>\r\n--boundary-1cl1i6m3lvlppm476t4134\r\nContent-type: application/octet-stream\r\nContent-transfer-encoding: base64\r\n\r\nYWJjZGVmZw==\r\n--boundary-1cl1i6m3lvlppm476t4134--\r\n" ==> ok
test mime-roundtrip (0), expects ("multipart/mixed" 0 ("multipart/mixed" 0 ("text/plain" 0 "This is implicitly typed plain US-ASCII text.\nIt does NOT end with a linebreak.") ("text/plain" 1 "This is explicitly typed plain US-ASCII text.\nIt DOES end with a linebreak.\n"))) ==> ok
test mime-roundtrip (1), expects ("multipart/mixed" 0 ("multipart/alternative" 0 ("text/plain" 0 "  ... plain text version of message goes here ...\n") ("text/enriched" 1 "  ... RFC 1896 text/enriched version of same message\n      goes here ...\n") ("application/x-whatever" 2 "  ... fanciest version of same message goes here ...\n"))) ==> ok
test mime-roundtrip (2), expects ("multipart/mixed" 0 ("multipart/mixed" 0 ("text/plain" 0 "  ...Introductory text or table of contents...\n") ("multipart/digest" 1 ("message/rfc822" 0 ("text/plain" 0 "  ...body goes here ...\n")) ("message/rfc822" 1 ("text/plain" 0 "  ... another body goes here ...\n"))))) ==> ok
test mime-roundtrip (3), expects ("multipart/mixed" 0 ("multipart/mixed" 0 ("text/plain" 0 "  ... Some text appears here ...\n\n[Note that the blank between the boundary and the start\n of the text in this part means no header fields were\n given and this is text in the US-ASCII character set.\n It could have been done with explicit typing as in the\n next part.]\n") ("text/plain" 1 "This could have been part of the previous part, but\nillustrates explicit versus implicit typing of body\nparts.\n") ("multipart/parallel" 2 ("audio/basic" 0 "  ... base64-encoded 8000 Hz single-channel\n      mu-law-format audio data goes here ...\n") ("image/jpeg" 1 "  ... base64-encoded image data goes here ...\n")) ("text/enriched" 3 "This is <bold><italic>enriched.</italic></bold>\n<smaller>as defined in RFC 1896</smaller>\n\nIsn't it\n<bigger><bigger>cool?</bigger></bigger>\n") ("message/rfc822" 4 ("text/plain" 0 "  ... Additional text in ISO-8859-1 goes here ...\n")))) ==> ok
test mime-roundtrip (4), expects ("multipart/mixed" 0 ("multipart/mixed" 0 ("text/plain" 0 "  ...Introductory text or table of contents...\n") ("multipart/digest" 1 ("message/rfc822" 0 ("text/plain" 0 "  ...body goes here ...\n")) ("message/rfc822" 1 ("text/plain" 0 ""))) ("text/plain" 2 "The previous part has been chopped."))) ==> ok
test mime-roundtrip (5), expects ("multipart/mixed" 0 ("multipart/mixed" 0 ("text/plain" 0 "  ...Introductory text or table of contents...\n") ("multipart/digest" 1 ("message/rfc822" 0 ("text/plain" 0 "  ...body goes here ...\n")) ("message/rfc822" 1 ("text/plain" 0 "  ... another body goes here ...\n"))))) ==> ok
test mime-roundtrip (6), expects ("multipart/mixed" 0 ("multipart/form-data" 0 ("text/plain" 0 "up") ("application/octet-stream" 1 "") ("text/plain" 2 "Submit"))) ==> ok
test mime-roundtrip (7), expects ("multipart/mixed" 0 ("multipart/mixed" 0 ("application/binary" 0 "\0\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\f\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\0\r") ("application/binary" 1 "\r") ("application/binary" 2 "--") ("application/binary" 3 "--bb-"))) ==> ok
<rfc.uri>----------------------------------------------------------------------
testing bindings in #<module rfc.uri> ... ok
test encode, expects "abc%3c%20%3e%20%22%20%23%25%7b%7c%7d%5c%5e" ==> ok
test encode (noescape), expects ".a%21%2ap" ==> ok
test decode, expects "abc< > \" #%?{|}\\^" ==> ok
test decode, expects "abc<+>+\"+#%?{|}\\^" ==> ok
test decode, expects "abc< > \" #%?{|}\\^" ==> ok
test decode, expects "%" ==> ok
test decode, expects "a%" ==> ok
test decode, expects "a%y" ==> ok
test decode, expects "a%ay" ==> ok
test decode, expects "" ==> ok
test uri-scheme&specific, expects ("http" "//practical-scheme.net/gauche/") ==> ok
test uri-scheme&specific, expects (#f "/dev/tty") ==> ok
test uri-decompose-hierarchical, expects ("www.example.com:8080" "/about/company" "abc=def&ghi%20" "zzz") ==> ok
test uri-decompose-hierarchical, expects ("www.example.com:8080" "/about/company" #f "zzz") ==> ok
test uri-decompose-hierarchical, expects ("www.example.com:8080" "/" "abc" #f) ==> ok
test uri-decompose-hierarchical, expects ("www.example.com:8080" #f #f #f) ==> ok
test uri-decompose-hierarchical, expects ((#f #f #f #f) ("" #f #f #f) (#f "/" #f #f) ("" "/" #f #f)) ==> ok
test uri-decompose-authority, expects (#f "www.example.com" #f) ==> ok
test uri-decompose-authority, expects (#f "www.example.com" "8080") ==> ok
test uri-decompose-authority, expects ("foo:bar" "www.example.com" #f) ==> ok
test uri-parse, expects ("https" "shiro" "www.example.com" 443 "/login" "abc" "def") ==> ok
test uri-parse, expects ("ftp" "anonymous:anonymous" "ftp.example.com" #f "/pub/foo" #f #f) ==> ok
test uri-parse, expects ("file" #f #f #f "/usr/local/lib/abc" #f #f) ==> ok
test uri-parse, expects (#f #f #f #f "/usr/local/lib" #f #f) ==> ok
test uri-parse, expects ("mailto" #f #f #f "shiro@example.com" #f #f) ==> ok
test merging "g:h" onto "http://a/b/c/d;p?q", expects "g:h" ==> ok
test merging "g" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g" ==> ok
test merging "./g" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g" ==> ok
test merging "g/" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g/" ==> ok
test merging "/g" onto "http://a/b/c/d;p?q", expects "http://a/g" ==> ok
test merging "//g" onto "http://a/b/c/d;p?q", expects "http://g" ==> ok
test merging "?y" onto "http://a/b/c/d;p?q", expects "http://a/b/c/d;p?y" ==> ok
test merging "g?y" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g?y" ==> ok
test merging "#s" onto "http://a/b/c/d;p?q", expects "http://a/b/c/d;p?q#s" ==> ok
test merging "g#s" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g#s" ==> ok
test merging "g?y#s" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g?y#s" ==> ok
test merging ";x" onto "http://a/b/c/d;p?q", expects "http://a/b/c/;x" ==> ok
test merging "g;x" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g;x" ==> ok
test merging "g;x?y#s" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g;x?y#s" ==> ok
test merging "" onto "http://a/b/c/d;p?q", expects "http://a/b/c/d;p?q" ==> ok
test merging "." onto "http://a/b/c/d;p?q", expects "http://a/b/c/" ==> ok
test merging "./" onto "http://a/b/c/d;p?q", expects "http://a/b/c/" ==> ok
test merging ".." onto "http://a/b/c/d;p?q", expects "http://a/b/" ==> ok
test merging "../" onto "http://a/b/c/d;p?q", expects "http://a/b/" ==> ok
test merging "../g" onto "http://a/b/c/d;p?q", expects "http://a/b/g" ==> ok
test merging "../.." onto "http://a/b/c/d;p?q", expects "http://a/" ==> ok
test merging "../../" onto "http://a/b/c/d;p?q", expects "http://a/" ==> ok
test merging "../../g" onto "http://a/b/c/d;p?q", expects "http://a/g" ==> ok
test merging "../../../g" onto "http://a/b/c/d;p?q", expects "http://a/g" ==> ok
test merging "../../../../g" onto "http://a/b/c/d;p?q", expects "http://a/g" ==> ok
test merging "/./g" onto "http://a/b/c/d;p?q", expects "http://a/g" ==> ok
test merging "/../g" onto "http://a/b/c/d;p?q", expects "http://a/g" ==> ok
test merging "g." onto "http://a/b/c/d;p?q", expects "http://a/b/c/g." ==> ok
test merging ".g" onto "http://a/b/c/d;p?q", expects "http://a/b/c/.g" ==> ok
test merging "g.." onto "http://a/b/c/d;p?q", expects "http://a/b/c/g.." ==> ok
test merging "..g" onto "http://a/b/c/d;p?q", expects "http://a/b/c/..g" ==> ok
test merging "./../g" onto "http://a/b/c/d;p?q", expects "http://a/b/g" ==> ok
test merging "./g/." onto "http://a/b/c/d;p?q", expects "http://a/b/c/g/" ==> ok
test merging "g/./h" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g/h" ==> ok
test merging "g/../h" onto "http://a/b/c/d;p?q", expects "http://a/b/c/h" ==> ok
test merging "g;x=1/./y" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g;x=1/y" ==> ok
test merging "g;x=1/../y" onto "http://a/b/c/d;p?q", expects "http://a/b/c/y" ==> ok
test merging "g?y/./x" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g?y/./x" ==> ok
test merging "g?y/../x" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g?y/../x" ==> ok
test merging "g#s/./x" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g#s/./x" ==> ok
test merging "g#s/../x" onto "http://a/b/c/d;p?q", expects "http://a/b/c/g#s/../x" ==> ok
test merging "http:g" onto "http://a/b/c/d;p?q", expects "http:g" ==> ok
test merging "./" onto "http://example.com/foo/..", expects "http://example.com/" ==> ok
test merging "./foo/bar/.." onto "http://example.com/", expects "http://example.com/foo/" ==> ok
test merging "foo" onto "http://example.com", expects "http://example.com/foo" ==> ok
test merging "./foo" onto "http://example.com", expects "http://example.com/foo" ==> ok
test merging "../foo" onto "http://example.com", expects "http://example.com/foo" ==> ok
<rfc.http>---------------------------------------------------------------------
testing bindings in #<module rfc.http> ... ok
test http-user-agent, expects "gauche.http/0.9.3.3" ==> ok
test http-compose-query, expects "/search?q=foo%20bar&n=20" ==> ok
test http-get, default string receiver, expects (("method" "GET") ("request-uri" "/get") ("request-body" "") ("host" "localhost:6726") ("user-agent" "gauche.http/0.9.3.3") ("my-header" "foo")) ==> ok
test http-get, custom receiver, expects (("method" "GET") ("request-uri" "/get") ("request-body" "") ("host" "localhost:6726") ("user-agent" "gauche.http/0.9.3.3") ("my-header" "foo")) ==> ok
test http-get, file receiver, expects (("method" "GET") ("request-uri" "/get") ("request-body" "") ("host" "localhost:6726") ("user-agent" "gauche.http/0.9.3.3") ("my-header" "foo")) ==> ok
test http-get, file receiver (tmp), expects (("method" "GET") ("request-uri" "/get") ("request-body" "") ("host" "localhost:6726") ("user-agent" "gauche.http/0.9.3.3") ("my-header" "foo")) ==> ok
test http-get, cond-receiver, expects (("method" "GET") ("request-uri" "/get") ("request-body" "") ("host" "localhost:6726") ("user-agent" "gauche.http/0.9.3.3") ("my-header" "foo")) ==> ok
test http-get, cond-receiver, expects 404 ==> ok
test http-get (redirect), expects "/redirect02" ==> ok
test http-get (redirect), expects "/redirect12" ==> ok
test http-get (no redirect), expects "/redirect12" ==> ok
test http-get (custom redirect), expects "/foofoo" ==> ok
test http-get (custom redirect to HEAD), expects #f ==> ok
test http-get (loop), expects #<<http-error>> ==> ok
test http-get (chunked body), expects "OK" ==> ok
test http-head, expects #t ==> ok
test http-post (new API), expects (("method" "POST") ("request-uri" "/post") ("content-length" "4") ("host" "localhost:6726") ("user-agent" "gauche.http/0.9.3.3") ("request-body" "data")) ==> ok
test http-post (old API), expects (("method" "POST") ("request-uri" "/post") ("content-length" "4") ("host" "localhost:6726") ("user-agent" "gauche.http/0.9.3.3") ("request-body" "data")) ==> ok
test http-post (multipart/form-data) (new API), expects (("a" "b") ("c" "d")) ==> ok
test http-post (multipart/form-data) (old API), expects (("a" "b") ("c" "d")) ==> ok
test <http-error>, expects #t ==> ok
passed.
Testing parseopt ==============================================================
testing bindings in #<module gauche.parseopt> ... ok
test help, expects ("Help message") ==> ok
test help, expects ("Help message") ==> ok
test help, expects ("Help message" "x" "y") ==> ok
test -a, expects ("a," "x" "y") ==> ok
test --a, expects ("" "x" "-a" "y") ==> ok
test -bb, expects ("bb=x," "y") ==> ok
test --bb, expects ("bb=x," "y") ==> ok
test -bb, expects ("bb=x," "y") ==> ok
test -bb, expects ("bb=x," "y") ==> ok
test -a -bb, expects ("a,bb=x," "y") ==> ok
test -bb -a, expects ("bb=x,a," "y") ==> ok
test -bb -a, expects ("bb=-a," "x" "y") ==> ok
test -cc, expects ("bb=x,cc=(y z),") ==> ok
test -cc, expects ("cc=(y -bb)," "x" "z") ==> ok
test -cc, expects ("cc=(y -bb)," "x" "z") ==> ok
test -ddd, expects ("ddd=(x y z),") ==> ok
test -ddd, expects ("ddd=(x y z),") ==> ok
test -eee, expects ("eee=23," "x") ==> ok
test -eee, expects ("eee=23," "x") ==> ok
test -eee, expects ("eee=-23," "x") ==> ok
test -eee, expects ("eee=23," "x") ==> ok
test -eee, expects ("eee=23," "x") ==> ok
test -eee, expects ("eee=23," "x") ==> ok
test -ffff, expects ("ffff=(-a -3),") ==> ok
test -ffff, expects ("ffff=(-a -3),") ==> ok
test -ffff, expects ("ffff=(-03 -3),") ==> ok
test -ggggg, expects ("ggggg=(1.0 2.0 3.0),") ==> ok
test -h, expects ("h*,") ==> ok
test -hh, expects ("h*,") ==> ok
test -hhh, expects ("h*,") ==> ok
test -j, expects ("j=jj,a,") ==> ok
test -j, expects ("j=#f,a,") ==> ok
test -j, expects ("j=#f,") ==> ok
test -k, expects ("k=(1 2 3),a,") ==> ok
test -k, expects ("k=(#f #f #f),a,") ==> ok
test --, expects ("bb=x," "-a" "-cc") ==> ok
test --, expects ("" "-bb" "x" "--" "-a" "-cc") ==> ok
test else, expects ("bb=x,?=what," "x" "y") ==> ok
test else, expects ("bb=x,?=what,eee=3," "x" "y") ==> ok
test else, expects ("bb=x,?=what," "q" "-eee" "3" "x" "y") ==> ok
test let-args (foo), expects 9 ==> ok
test let-args (foo), expects #f ==> ok
test let-args (foo), expects 3 ==> ok
test let-args (foo), expects #<<parseopt-error>> ==> ok
test let-args (foo), expects 3 ==> ok
test let-args (bar), expects #t ==> ok
test let-args (bar), expects #t ==> ok
test let-args (bar), expects #f ==> ok
test let-args (baz), expects ("4" 2) ==> ok
test let-args (baz), expects #<<parseopt-error>> ==> ok
test let-args (baz), expects #f ==> ok
test let-args (rest), expects ("bunga" "bonga") ==> ok
test let-args (rest), expects ("bunga" "bonga") ==> ok
test let-args (rest), expects () ==> ok
test let-args (else), expects ("foo" ("5")) ==> ok
test let-args (else), expects 5 ==> ok
test let-args (callback), expects 25 ==> ok
test let-args (callback), expects #f ==> ok
test let-args (callback), expects 8 ==> ok
test let-args (side-effect), expects 5 ==> ok
test let-args (side-effect), expects 0 ==> ok
test let-args (scope), expects 7 ==> ok
test let-args (scope), expects 8 ==> ok
test let-args (scope), expects 9 ==> ok
passed.
Testing logger ================================================================
testing bindings in #<module gauche.logger> ... ok
<log-open>---------------------------------------------------------------------
test log-open, expects ("real testing..." "real testing 2..." "output string" "containing newline" "characters" "real testing again...") ==> ok
<customized formatter>---------------------------------------------------------
test customized formatter, expects ("zeepa:booba bunba bomba") ==> ok
test customized formatter, expects ("poopa:booba bunba bomba") ==> ok
passed.
Testing text utilities ========================================================
<csv>--------------------------------------------------------------------------
testing bindings in #<module text.csv> ... ok
test csv-reader, expects ("abc" "def" "" "ghi") ==> ok
test csv-reader, expects ("abc" "def" "" ", ghi") ==> ok
test csv-reader, expects ("abc" "def" "ghi") ==> ok
test csv-reader, expects ("abc" " de,f " "gh\ni" "jkl") ==> ok
test csv-reader, expects ("ab\nc" "de \n\n \nf " "" "" "gh\"\n\"i") ==> ok
test csv-reader, expects #<error> ==> ok
test csv-reader, expects #t ==> ok
test csv-writer, expects "abc,def,123,\"what's up?\",\"he said, \"\"nothing new.\"\"\"\n" ==> ok
test csv-writer, expects "abc,def,123,\"what's up?\",\"he said, \"\"nothing new.\"\"\"\r\n" ==> ok
test csv-writer, expects "\n" ==> ok
<diff>-------------------------------------------------------------------------
testing bindings in #<module text.diff> ... ok
test diff-report, expects "  foo\n  bar\n- bar\n  baz\n- baz\n+ fuga\n  hoge\n+ fuga\n" ==> ok
<html-lite>--------------------------------------------------------------------
testing bindings in #<module text.html-lite> ... ok
test html-escape-string, expects "&lt;a href=&quot;http://abc/def?ghi&amp;jkl&quot;&gt;" ==> ok
test html-escape-string, expects "&lt;class&gt;" ==> ok
test html-doctype, expects ("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\"" "\"http://www.w3.org/TR/html4/strict.dtd\">" "") ==> ok
test html-doctype, expects ("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"" "\"http://www.w3.org/TR/html4/loose.dtd\">" "") ==> ok
test html-doctype, expects ("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Frameset//EN\"" "\"http://www.w3.org/TR/html4/frameset.dtd\">" "") ==> ok
test html-doctype, expects ("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"" "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" "") ==> ok
test html, head, body, expects "<html><head><title>foo</title></head><body>foo</body></html>" ==> ok
test attributes, expects "<a href=\"http://foo/bar?a&amp;b\" id=\"aabb\">zzdd</a>" ==> ok
test empty element, expects "<img src=\"foo\" alt=\"bar baz\" />" ==> ok
<parse>------------------------------------------------------------------------
testing bindings in #<module text.parse> ... ok
test find-string-from-port?, expects (7 #\d) ==> ok
test find-string-from-port?, expects (7 #\d) ==> ok
test find-string-from-port?, expects (#f eof) ==> ok
test find-string-from-port?, expects (#f eof) ==> ok
test find-string-from-port?, expects (#f #\a) ==> ok
test find-string-from-port?, expects (8 eof) ==> ok
test find-string-from-port?, expects (8 eof) ==> ok
test find-string-from-port?, expects (8 eof) ==> ok
test find-string-from-port?, expects (#f eof) ==> ok
test assert-curr-char, expects (#\space #\a) ==> ok
test assert-curr-char, expects (#\space #\a) ==> ok
test assert-curr-char, expects (#\space #\a) ==> ok
test assert-curr-char, expects (#\space #\a) ==> ok
test assert-curr-char, expects (#\a #\space) ==> ok
test assert-curr-char, expects (#\a #\space) ==> ok
test assert-curr-char, expects #<error> ==> ok
test assert-curr-char, expects #<error> ==> ok
test assert-curr-char, expects (eof eof) ==> ok
test skip-until number, expects (#f #\a) ==> ok
test skip-until number, expects #<error> ==> ok
test skip-until number, expects (#f eof) ==> ok
test skip-until cset, expects (#\space #\a) ==> ok
test skip-until cset, expects (#\space #\a) ==> ok
test skip-until cset, expects (#\c #\space) ==> ok
test skip-until cset, expects (#\c eof) ==> ok
test skip-until cset, expects #<error> ==> ok
test skip-until cset, expects (eof eof) ==> ok
test skip-until cset, expects (#\c eof) ==> ok
test skip-until proc, expects (#\c #\space) ==> ok
test skip-until proc, expects (eof eof) ==> ok
test skip-until proc, expects #<error> ==> ok
test skip-while, expects (#\d #\d) ==> ok
test skip-while, expects (#\d #\d) ==> ok
test skip-while, expects (#\y #\y) ==> ok
test skip-while, expects (eof eof) ==> ok
test skip-while, expects (#\d #\d) ==> ok
test skip-while, expects (#\y #\y) ==> ok
test skip-while, expects (eof eof) ==> ok
test next-token, expects ("" #\d) ==> ok
test next-token, expects ("bc" #\d) ==> ok
test next-token, expects ("aeio" #\tab) ==> ok
test next-token, expects #<error> ==> ok
test next-token, expects ("aeio" eof) ==> ok
test next-token, expects ("aeio" #\tab) ==> ok
test next-token-of, expects ("" #\x) ==> ok
test next-token-of, expects ("" #\x) ==> ok
test next-token-of, expects ("xxx" #\d) ==> ok
test next-token-of, expects ("anmb" #\-) ==> ok
test next-token-of, expects ("rnge!rg0#$@" #\space) ==> ok
test next-token-of, expects ("xxx" #\d) ==> ok
test next-token-of, expects ("xxxx" eof) ==> ok
test read-string, expects ("aaaa" #\a) ==> ok
test read-string, expects ("aaaaa" eof) ==> ok
test read-string, expects ("aaaaa" eof) ==> ok
test read-string, expects ("" #\a) ==> ok
test read-string, expects ("" #\a) ==> ok
test read-string, expects ("" eof) ==> ok
<progress>---------------------------------------------------------------------
testing bindings in #<module text.progress> ... ok
<sql>--------------------------------------------------------------------------
testing bindings in #<module text.sql> ... ok
test sql-tokenize, expects ("select" "tab" #\. "x" #\, "tab" #\. "y" "as" "foo" "from" "tab" "where" "tab" #\. "z" < (number "30")) ==> ok
test sql-tokenize (literal numberes), expects ((number "0") (number "-12") (number "+12") (number ".123") (number "123.") (number "123.45") (number "-.123") (number "-123.") (number "-123.45") (number "+.123") (number "+123.") (number "+123.45") (number "0E0") (number "-1E3") (number "-1.E3") (number "-.1E3") (number "-1.2E3") (number "1E-3") (number "1.E-3") (number ".1E-3") - #\. "E" (number "-3") (number "1.2") (number ".3")) ==> ok
test sql-tokenize (literal strings), expects ((string "abc") (string "ab'c") (string "'abc") (string "abc'") (string "") (string "'") (string "a'b'c'")) ==> ok
test sql-tokenize (unterminated literal), expects #<<sql-parse-error>> ==> ok
test sql-tokenize (unterminated literal), expects #<<sql-parse-error>> ==> ok
test sql-tokenize (other stuff), expects ((bitstring "0") (bitstring "010101") (hexstring "0") (hexstring "1aBc9") (delimited "run \"run\" run")) ==> ok
test sql-tokenize (parameters), expects ((parameter 0) #\, (parameter 1) #\, (parameter "foo") #\, (parameter "bar") #\, (parameter 2)) ==> ok
<tree>-------------------------------------------------------------------------
testing bindings in #<module text.tree> ... ok
test tree->string, expects "" ==> ok
test tree->string, expects "" ==> ok
test tree->string, expects "ab" ==> ok
test tree->string, expects "ab" ==> ok
test tree->string, expects "ab" ==> ok
test tree->string, expects "ab" ==> ok
test tree->string, expects "Ab" ==> ok
test tree->string, expects "ab" ==> ok
passed.
Testing util ==================================================================
<util.combinations>------------------------------------------------------------
testing bindings in #<module util.combinations> ... ok
test permutations (boundary), expects (()) ==> ok
test permutations (boundary), expects ((a)) ==> ok
test permutations, expects ((a b) (b a)) ==> ok
test permutations, expects ((a a) (a a)) ==> ok
test permutations, expects ((a b c) (a c b) (b a c) (b c a) (c a b) (c b a)) ==> ok
test permutations, expects ((a b c d) (a b d c) (a c b d) (a c d b) (a d b c) (a d c b) (b a c d) (b a d c) (b c a d) (b c d a) (b d a c) (b d c a) (c a b d) (c a d b) (c b a d) (c b d a) (c d a b) (c d b a) (d a b c) (d a c b) (d b a c) (d b c a) (d c a b) (d c b a)) ==> ok
test permutations* (boundary), expects (()) ==> ok
test permutations* (boundary), expects ((a)) ==> ok
test permutations*, expects ((a b) (b a)) ==> ok
test permutations*, expects ((a a)) ==> ok
test permutations*, expects ((a b c) (a c b) (b a c) (b c a) (c a b) (c b a)) ==> ok
test permutations*, expects ((a a b) (a b a) (b a a)) ==> ok
test permutations*, expects ((a b a) (a a b) (b a a)) ==> ok
test permutations*, expects ((b a a) (a b a) (a a b)) ==> ok
test permutations*, expects ((a a a)) ==> ok
test permutations*, expects ((a b c d) (a b d c) (a c b d) (a c d b) (a d b c) (a d c b) (b a c d) (b a d c) (b c a d) (b c d a) (b d a c) (b d c a) (c a b d) (c a d b) (c b a d) (c b d a) (c d a b) (c d b a) (d a b c) (d a c b) (d b a c) (d b c a) (d c a b) (d c b a)) ==> ok
test permutations*, expects ((a a b c) (a a c b) (a b a c) (a b c a) (a c a b) (a c b a) (b a a c) (b a c a) (b c a a) (c a a b) (c a b a) (c b a a)) ==> ok
test permutations*, expects ((a b a c) (a b c a) (a a b c) (a a c b) (a c b a) (a c a b) (b a a c) (b a c a) (b c a a) (c a b a) (c a a b) (c b a a)) ==> ok
test permutations*, expects ((a b c a) (a b a c) (a c b a) (a c a b) (a a b c) (a a c b) (b a c a) (b a a c) (b c a a) (c a b a) (c a a b) (c b a a)) ==> ok
test permutations*, expects ((a b a b) (a b b a) (a a b b) (b a a b) (b a b a) (b b a a)) ==> ok
test permutations*, expects ((a a a b) (a a b a) (a b a a) (b a a a)) ==> ok
test permutations*, expects ((a b a a) (a a b a) (a a a b) (b a a a)) ==> ok
test permutations*, expects ((a a a a)) ==> ok
test permutations*, expects (("a" "b" "b" "a") ("a" "b" "a" "b") ("a" "a" "b" "b") ("b" "a" "b" "a") ("b" "a" "a" "b") ("b" "b" "a" "a")) ==> ok
test permutations-for-each, expects () ==> ok
test permutations-for-each, expects ((a)) ==> ok
test permutations-for-each, expects ((a b c) (a c b) (b a c) (b c a) (c a b) (c b a)) ==> ok
test permutations*-for-each, expects () ==> ok
test permutations*-for-each, expects ((a)) ==> ok
test permutations*-for-each, expects ((a b c) (a c b) (b a c) (b c a) (c a b) (c b a)) ==> ok
test permutations*-for-each, expects ((a a b) (a b a) (b a a)) ==> ok
test permutations*-for-each, expects ((a a a)) ==> ok
test permutations*-for-each, expects (("a" "a" "b") ("a" "b" "a") ("b" "a" "a")) ==> ok
test combinations, expects (()) ==> ok
test combinations, expects ((a)) ==> ok
test combinations, expects ((a) (b) (c) (d)) ==> ok
test combinations, expects ((a b) (a c) (b c)) ==> ok
test combinations, expects ((a b c)) ==> ok
test combinations, expects ((a b c) (a b d) (a c d) (b c d)) ==> ok
test combinations*, expects (()) ==> ok
test combinations*, expects ((a)) ==> ok
test combinations*, expects ((a) (b) (c) (d)) ==> ok
test combinations*, expects ((a b) (a c) (b c)) ==> ok
test combinations*, expects ((a b c)) ==> ok
test combinations*, expects ((a b c) (a b d) (a c d) (b c d)) ==> ok
test combinations*, expects ((a) (b)) ==> ok
test combinations*, expects ((a a) (a b)) ==> ok
test combinations*, expects ((a a b)) ==> ok
test combinations*, expects ((a b) (a a)) ==> ok
test combinations*, expects ((a b a) (a a a)) ==> ok
test combinations*, expects ((a b b) (a b a)) ==> ok
test combinations*, expects (("a" "b" "b") ("a" "b" "a")) ==> ok
test combinations-for-each, expects (()) ==> ok
test combinations-for-each, expects ((a)) ==> ok
test combinations-for-each, expects ((a) (b) (c) (d)) ==> ok
test combinations-for-each, expects ((a b) (a c) (b c)) ==> ok
test combinations-for-each, expects ((a b c)) ==> ok
test combinations-for-each, expects ((a b c) (a b d) (a c d) (b c d)) ==> ok
test combinations*-for-each, expects (()) ==> ok
test combinations*-for-each, expects ((a)) ==> ok
test combinations*-for-each, expects ((a) (b) (c) (d)) ==> ok
test combinations*-for-each, expects ((a b) (a c) (b c)) ==> ok
test combinations*-for-each, expects ((a b c)) ==> ok
test combinations*-for-each, expects ((a b c) (a b d) (a c d) (b c d)) ==> ok
test combinations*-for-each, expects ((a) (b)) ==> ok
test combinations*-for-each, expects ((a a) (a b)) ==> ok
test combinations*-for-each, expects ((a a b)) ==> ok
test combinations*-for-each, expects ((a b) (a a)) ==> ok
test combinations*-for-each, expects ((a b a) (a a a)) ==> ok
test combinations*-for-each, expects ((a b b) (a b a)) ==> ok
test combinations*-for-each, expects (("a" "b" "b") ("a" "b" "a")) ==> ok
test power-set-binary, expects (()) ==> ok
test power-set-binary, expects (() (a)) ==> ok
test power-set-binary, expects (() (c) (b) (b c) (a) (a c) (a b) (a b c)) ==> ok
test power-set, expects (()) ==> ok
test power-set, expects (() (a)) ==> ok
test power-set, expects (() (a) (b) (c) (a b) (a c) (b c) (a b c)) ==> ok
test power-set*, expects (()) ==> ok
test power-set*, expects (() (a)) ==> ok
test power-set*, expects (() (a) (b) (a a) (a b) (a a b)) ==> ok
test power-set*, expects (() ("a") ("b") ("a" "a") ("a" "b") ("a" "a" "b")) ==> ok
test power-set-for-each, expects (()) ==> ok
test power-set-for-each, expects (() (a)) ==> ok
test power-set-for-each, expects (() (a) (b) (c) (a b) (a c) (b c) (a b c)) ==> ok
test power-set*-for-each, expects (()) ==> ok
test power-set*-for-each, expects (() (a)) ==> ok
test power-set*-for-each, expects (() (a) (b) (a a) (a b) (a a b)) ==> ok
test power-set*-for-each, expects (() ("a") ("b") ("a" "a") ("a" "b") ("a" "a" "b")) ==> ok
test cartesian-product, expects ((a 0) (a 1) (b 0) (b 1) (c 0) (c 1)) ==> ok
test cartesian-product, expects ((a 0 0) (a 0 1) (a 1 0) (a 1 1) (b 0 0) (b 0 1) (b 1 0) (b 1 1)) ==> ok
test cartesian-product-right, expects ((a 0) (b 0) (c 0) (a 1) (b 1) (c 1)) ==> ok
<util.isomorph>----------------------------------------------------------------
testing bindings in #<module util.isomorph> ... ok
test isomorphic?, expects #t ==> ok
test isomorphic?, expects #f ==> ok
<util.lcs>---------------------------------------------------------------------
testing bindings in #<module util.lcs> ... ok
test lcs skip, expects (a c) ==> ok
test lcs head, expects (a b) ==> ok
test lcs tail, expects (b c) ==> ok
test lcs same, expects (a b c) ==> ok
test lcs no common, expects () ==> ok
test lcs empty, expects () ==> ok
test lcs mislead, expects (a x b y c z) ==> ok
test lcs mislead count, expects (6 ((a 0 0) (x 1 4) (b 2 5) (y 3 6) (c 4 7) (z 5 8))) ==> ok
test lcs (long, same), expects #t ==> ok
test lcs (long, none), expects (199) ==> ok
test lcs (long), expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test lcs (long), expects (0 1 2 3 4 5 6 7 8 9) ==> ok
test lcs edit-list, expects (((- 0 a)) ((+ 2 d)) ((- 4 h) (+ 4 f)) ((+ 6 k)) ((- 8 n) (- 9 p) (+ 9 r) (+ 10 s) (+ 11 t))) ==> ok
test lcs edit-list, expects (((- 0 a) (- 1 b) (- 2 c) (- 3 d) (+ 0 e) (+ 1 f) (+ 2 g) (+ 3 h))) ==> ok
test lcs edit-list, expects () ==> ok
test lcs edit-list, expects (((- 0 a) (- 1 b) (- 2 c) (- 3 d))) ==> ok
test lcs edit-list, expects (((+ 0 a) (+ 1 b) (+ 2 c) (+ 3 d))) ==> ok
test lcs edit-list, expects (((+ 0 b)) ((- 1 b))) ==> ok
test lcs edit-list, expects (((- 1 b))) ==> ok
test lcs edit-list, expects (((+ 1 b))) ==> ok
<util.rbtree>------------------------------------------------------------------
testing bindings in #<module util.rbtree> ... ok
test make-rbtree, expects #t ==> ok
test rbtree-get, expects #<error> ==> ok
test rbtree-get, expects not-found ==> ok
test rbtree-get, expects #<error> ==> ok
test rbtree-put!, expects #<error> ==> ok
test rbtree-put!, expects "0" ==> ok
test rbtree-put!, expects ("0" "1") ==> ok
test rbtree-put!, expects bar ==> ok
test rbtree-check, expects #t ==> ok
test rbtree-fold, expects (2 bar 1 "1" 0 "0") ==> ok
test rbtree-fold-right, expects (0 "0" 1 "1" 2 bar) ==> ok
test rbtree-delete! (exiting key), expects (#t not-found) ==> ok
test rbtree-delete! (non-existing key), expects #f ==> ok
test rbtree-delete!, expects no-error ==> ok
test rbtree->alist, expects () ==> ok
test rbtree->alist, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test alist->rbtree, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test rbtree-empty?, expects #f ==> ok
test rbtree-empty?, expects #t ==> ok
test rbtree-empty?, expects #<error> ==> ok
test rbtree-exists?, expects (#t #f) ==> ok
test rbtree-num-entries, expects (0 1 0) ==> ok
test rbtree-push!, expects (bar foo) ==> ok
test rbtree-pop!, expects (foo bar) ==> ok
test rbtree-update!, expects 2 ==> ok
test rbtree-min, expects (0 . "0") ==> ok
test rbtree-max, expects (2 . "2") ==> ok
test rbtree-min, expects #<error> ==> ok
test rbtree-min, expects #<error> ==> ok
test rbtree-min, expects default ==> ok
test rbtree-max, expects default ==> ok
test rbtree-keys, expects (0 1 2) ==> ok
test rbtree-values, expects ("0" "1" "2") ==> ok
test rbtree-copy, expects #t ==> ok
test for-each, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test map, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test fold, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test fold-right, expects ((0 . "0") (1 . "1") (2 . "2")) ==> ok
test ref, expects ("0" "1" "2") ==> ok
test rbtree-extract-min!, expects ((0 . "0") (1 . "1")) ==> ok
test rbtree-extract-max!, expects ((2 . "2") (1 . "1")) ==> ok
test map, expects (("0" . 0) ("1" . 1) ("2" . 1)) ==> ok
test call-with-builder, expects (("0" . 0) ("1" . 1) ("2" . 1)) ==> ok
test random insertion/deletion, expects done ==> ok
<util.record>------------------------------------------------------------------
testing bindings in #<module util.record> ... ok
test make-record-type, expects #t ==> ok
test make-record-type (error), expects #<error> ==> ok
test make-record-type (error), expects #<error> ==> ok
test record-constructor, expects #t ==> ok
test record-constructor, expects (7 8 9) ==> ok
test record-predicate, expects #t ==> ok
test record-predicate, expects #f ==> ok
test record-accessor, expects 1 ==> ok
test record-modifier, expects 2 ==> ok
<util.relation>----------------------------------------------------------------
testing bindings in #<module util.relation> ... ok
test simple-relation, expects <simple-relation> ==> ok
test simple-relation (relation-ref), expects (0 5 10 15) ==> ok
test simple-relation (relation-accessor), expects (1 6 11 16) ==> ok
test simple-relation (relation-column-getter), expects (2 7 12 17) ==> ok
test simple-relation (relation-set!), expects (100 105 110 115) ==> ok
test simple-relation (relation-modifier), expects (201 206 211 216) ==> ok
test simple-relation (relation-column-setter), expects (304 309 314 319) ==> ok
test simple-relation (relation-fold), expects 1264 ==> ok
test object-set-relation, expects <object-set-relation> ==> ok
test object-set-relation (relation-ref), expects (0 3 6 9) ==> ok
test object-set-relation (relation-accessor), expects (1 4 7 10) ==> ok
test object-set-relation (relation-column-getter), expects (2 5 8 11) ==> ok
test object-set-relation (relation-set!), expects (100 103 106 109) ==> ok
test object-set-relation (relation-modifier), expects (201 204 207 210) ==> ok
test object-set-relation (relation-column-setter), expects (302 305 308 311) ==> ok
test simple-relation (relation-fold), expects 1644 ==> ok
<util.stream>------------------------------------------------------------------
testing bindings in #<module util.stream> ... ok
test stream?, expects #t ==> ok
test stream-cons/car/cdr, expects (1 1 1) ==> ok
test stream-delay, expects #t ==> ok
test stream-unfoldn, expects ((0 2 4 6) (1 3 5 7)) ==> ok
test stream-map/stream-ref, expects (2 4 6 8) ==> ok
test stream-for-each/stream-iota, expects (1 3 5 7) ==> ok
test stream-filter/take/drop, expects (12 15 18 21) ==> ok
test stream-remove, expects (0 2 4 6) ==> ok
test stream-count, expects 4 ==> ok
test stream-any, expects #f ==> ok
test stream-any, expects #f ==> ok
test stream-any, expects #t ==> ok
test stream-any, expects 1 ==> ok
test stream-any, expects 1 ==> ok
test stream-any, expects 1 ==> ok
test stream-any, expects 1 ==> ok
test stream-any, expects #f ==> ok
test stream-every, expects #t ==> ok
test stream-every, expects #t ==> ok
test stream-every, expects #f ==> ok
test stream-every, expects #f ==> ok
test stream-every, expects 2 ==> ok
test stream-every, expects 2 ==> ok
test stream-every, expects 1 ==> ok
test stream-every, expects #t ==> ok
<util.toposort>----------------------------------------------------------------
testing bindings in #<module util.toposort> ... ok
test topological-sort, default, expects (socks undershorts watch shirt tie pants belt jacket shoes) ==> ok
test topological-sort, eq?, expects (socks undershorts watch shirt tie pants belt jacket shoes) ==> ok
test topological-sort, string=?, expects ("socks" "undershorts" "watch" "shirt" "tie" "pants" "belt" "jacket" "shoes") ==> ok
<util.trie>--------------------------------------------------------------------
testing bindings in #<module util.trie> ... ok
test trie: constructor, expects (#t 0) ==> ok
test trie: exists?, expects #f ==> ok
test trie: put!, expects 1 ==> ok
test trie: get, expects 4 ==> ok
test trie: get (error), expects #<error> ==> ok
test trie: get (fallback), expects foo ==> ok
test trie: put! more, expects 19 ==> ok
test trie: get more, expects #t ==> ok
test trie: exists? more, expects #t ==> ok
test trie: common-prefix, expects (19 12 8 4 4 3) ==> ok
test trie: common-prefix, expects (("kua" . 3) ("kua`aina" . 8) ("kua`ana" . 7)) ==> ok
test trie: common-prefix-keys, expects ("kua" "kua`aina" "kua`ana") ==> ok
test trie: common-prefix-values, expects (3 8 7) ==> ok
test trie: common-prefix-fold, expects 18 ==> ok
test trie: common-prefix-map, expects ("KUA" "KUA`AINA" "KUA`ANA") ==> ok
test trie: common-prefix-for-each, expects ("KUA" "KUA`AINA" "KUA`ANA") ==> ok
test trie: trie-fold, expects 118 ==> ok
test trie: trie-map, expects 118 ==> ok
test trie: trie-for-each, expects 118 ==> ok
test trie: trie->list, expects (("kana" . 4) ("kanaono" . 7) ("kanawai" . 7) ("kanawai koa" . 11) ("kanawai mele" . 12) ("kane" . 4) ("Kane" . 4) ("kane make" . 9) ("kane makua" . 10) ("ku" . 2) ("kua" . 3) ("kua`aina" . 8) ("kua`ana" . 7) ("liliko`i" . 8) ("lilinoe" . 7) ("lili`u" . 6) ("lilo" . 4) ("maoli" . 5) ("" . 0)) ==> ok
test trie: trie-keys, expects ("kana" "kanaono" "kanawai" "kanawai koa" "kanawai mele" "kane" "Kane" "kane make" "kane makua" "ku" "kua" "kua`aina" "kua`ana" "liliko`i" "lilinoe" "lili`u" "lilo" "maoli" "") ==> ok
test trie: trie-values, expects (4 7 7 11 12 4 4 9 10 2 3 8 7 8 7 6 4 5 0) ==> ok
test trie: trie-update!, expects 16 ==> ok
test trie: trie-update! (nonexistent), expects #<error> ==> ok
test trie: trie-update! (nonexistent), expects 16 ==> ok
test trie: delete!, expects (19 #f) ==> ok
test trie: delete! (nonexistent), expects (19 #f) ==> ok
test trie: delete! (everything), expects 0 ==> ok
test trie: trie, expects (("foo" . 0) ("foof" . 1) ("far" . 2)) ==> ok
test trie: trie-with-keys, expects (("foo" . "foo") ("foof" . "foof") ("far" . "far")) ==> ok
test trie(hetero): put!, expects 76 ==> ok
test trie(hetero): get, expects #<class <vector>> ==> ok
test trie(hetero): get, expects #<class <u8vector>> ==> ok
test trie(hetero): get, expects #<class <pair>> ==> ok
test trie(hetero): delete!, expects #<class <string>> ==> ok
test trie(hetero): delete!, expects 57 ==> ok
test trie(custom): put!, expects 18 ==> ok
test trie(custom): get, expects 99 ==> ok
test trie(collection): builder, expects 19 ==> ok
test trie(collection): iterator, expects ("kana" "kanaono" "kanawai" "kanawai koa" "kanawai mele" "kane" "Kane" "kane make" "kane makua" "ku" "kua" "kua`aina" "kua`ana" "liliko`i" "lilinoe" "lili`u" "lilo" "maoli" "") ==> ok
test trie(collection): coerce to list, expects (("kana" . #t) ("kanaono" . #t) ("kanawai" . #t) ("kanawai koa" . #t) ("kanawai mele" . #t) ("kane" . #t) ("Kane" . #t) ("kane make" . #t) ("kane makua" . #t) ("ku" . #t) ("kua" . #t) ("kua`aina" . #t) ("kua`ana" . #t) ("liliko`i" . #t) ("lilinoe" . #t) ("lili`u" . #t) ("lilo" . #t) ("maoli" . #t) ("" . #t)) ==> ok
test trie(collection): coerce to vector, expects (("kana" . #t) ("kanaono" . #t) ("kanawai" . #t) ("kanawai koa" . #t) ("kanawai mele" . #t) ("kane" . #t) ("Kane" . #t) ("kane make" . #t) ("kane makua" . #t) ("ku" . #t) ("kua" . #t) ("kua`aina" . #t) ("kua`ana" . #t) ("liliko`i" . #t) ("lilinoe" . #t) ("lili`u" . #t) ("lilo" . #t) ("maoli" . #t) ("" . #t)) ==> ok
test trie(collection): coerce to hashtable, expects #t ==> ok
passed.
Testing advanced read/write features ==========================================
<hash-bang>--------------------------------------------------------------------
test script hash-bang, expects 3 ==> ok
test script hash-bang, expects 5 ==> ok
test script hash-bang, expects #<eof> ==> ok
test #!fold-case, expects (hello world) ==> ok
test #!fold-case, expects (Hello world) ==> ok
test #!no-fold-case, expects (hello World) ==> ok
test customized hash-bang, expects 0.0-1.0i ==> ok
test customized hash-bang, expects (#t #f) ==> ok
<srfi-10 reader constructor>---------------------------------------------------
test read ctor 1a, expects (1 2 #f "4 5") ==> ok
test read ctor 1b, expects 3 ==> ok
test read ctor 2a, expects #(my-vector (my-vector 1 2)) ==> ok
test read ctor 2b, expects #(my-vector #(my-vector 1 2)) ==> ok
<write/ss basic>---------------------------------------------------------------
test pair, expects "(#0=(a b) #0#)" ==> ok
test pair, expects "(#0=(a b) . #0#)" ==> ok
test pair, expects "(#0=(a b) #1=(a b) #0# . #1#)" ==> ok
test pair (circular), expects "#0=(a . #0#)" ==> ok
test pair (circular), expects "#0=(#0# b)" ==> ok
test pair (circular), expects "#0=(#0# . #0#)" ==> ok
test pair (circular), expects "#0=(a (b . #0#))" ==> ok
test pair (circular), expects "#0=(a #1=(b . #0#) . #1#)" ==> ok
test vector, expects "(#0=#(a b) . #0#)" ==> ok
test vector, expects "(#() . #())" ==> ok
test vector, expects "#(#0=(a b) #0# #0#)" ==> ok
test vector (circular), expects "#0=#(#0#)" ==> ok
test string, expects "(#0=\"ab\" . #0#)" ==> ok
test string, expects "(\"\" . \"\")" ==> ok
test more than 10 substructures, expects "(#0=(a) #1=(b) #2=(c) #3=(d) #4=(e) #5=(f) #6=(g) #7=(h) #8=(i) #9=(j) #10=(k) #10# #9# #8# #7# #6# #5# #4# #3# #2# #1# #0#)" ==> ok
test circular list involving abbrev syntax, expects "#0=((quote . #0#))" ==> ok
test user defined, expects "#,(foo #0=(a b) #0#)" ==> ok
test user defined, expects "#0=#,(foo #0# #0#)" ==> ok
test user defined, expects "#0=#,(foo foo #,(foo bar #0#))" ==> ok
test user defined, expects "(#0=#,(foo foo #1=#,(foo bar #0#)) #1#)" ==> ok
test user defined, expects "#0=(#1=#,(foo #2=#,(foo bar #1#) #0#) #2#)" ==> ok
test user defined, expects "#,(bar #0=(a b) #0#)" ==> ok
<format/ss>--------------------------------------------------------------------
test format/ss, expects "The answer is #0=(\"a\" . #0#)" ==> ok
test format/ss, expects "The answer is #0=(a . #0#)" ==> ok
test format/ss, expects "The answer is #0=(a . #0#) #0=(a . #0#)" ==> ok
<read/ss basic>----------------------------------------------------------------
test scalar (harmless), expects 0 ==> ok
test scalar (harmless), expects 1 ==> ok
test scalar (harmless), expects 2 ==> ok
test scalar (harmless), expects #f ==> ok
test scalar (harmless), expects "aaa" ==> ok
test bad syntax, expects #<error> ==> ok
test bad syntax, expects #<error> ==> ok
test bad syntax, expects #<error> ==> ok
test bad syntax, expects #<error> ==> ok
test pair 1, expects #0=(1 2 . #0#) ==> ok
test pair 2, expects #0=(#0#) ==> ok
test pair 3, expects (#0=(a b) #0# #0#) ==> ok
test vector, expects #0=#(#1=#(a #2=#(c #1#)) #2# #1# #2# #0#) ==> ok
test string, expects (#0="aa" #1="aa" #0# #1#) ==> ok
<whitespaces>------------------------------------------------------------------
test skipws, expects a ==> ok
<combine srfi-10 and srfi-38>--------------------------------------------------
test user-defined, expects #0='(a #0#) ==> ok
passed.
Testing gauche.process ========================================================
testing bindings in #<module gauche.process> ... ok
<process object>---------------------------------------------------------------
test run-process (old), expects 0 ==> ok
test run-process, expects 0 ==> ok
test run-process (old), expects 0 ==> ok
test run-process, expects 0 ==> ok
test run-process (old), expects 1 ==> ok
test run-process, expects 1 ==> ok
test run-process (output pipe), expects (0 #t) ==> ok
test run-process (output pipe - new format), expects (0 #t) ==> ok
test run-process (input pipe), expects (0 #t) ==> ok
test run-process (input pipe - new format), expects (0 #t) ==> ok
test run-process (input pipe - new format 2), expects (0 #t) ==> ok
test run-process (input pipe - new format 3), expects (0 #t) ==> ok
test run-process (error pipe), expects #t ==> ok
test process-kill, expects 9 ==> ok
test non-blocking wait, expects (#f #t #f) ==> ok
test wait with signalling error, expects (#t 9) ==> ok
test process-list, expects () ==> ok
<process ports>----------------------------------------------------------------
test open-input-process-port, expects #t ==> ok
test open-input-process-port (redirect), expects #t ==> ok
test open-input-process-port (redirect/error), expects #t ==> ok
test call-with-input-process, expects #t ==> ok
test call-with-input-process (redirect), expects #t ==> ok
test call-with-input-process (redirect/error - ignore), expects #t ==> ok
test call-with-input-process (redirect/error - error), expects #<<process-abnormal-exit>> ==> ok
test call-with-input-process (redirect/error - handle), expects #<test-one-of: any one of (1 2)> ==> ok
test with-input-from-process, expects #t ==> ok
test with-input-from-process, expects #t ==> ok
test with-input-from-process (redirect), expects #t ==> ok
test open-output-process-port, expects #t ==> ok
test open-output-process-port (redirect), expects #t ==> ok
test open-output-process-port (redirect/error), expects #t ==> ok
test call-with-output-process, expects (#t 1 2) ==> ok
test call-with-output-process (redirect), expects (#t 1 2) ==> ok
test call-with-output-process (redirect/error - ignore), expects #t ==> ok
test call-with-output-process (redirect/error - raise), expects #t ==> ok
test call-with-output-process (redirect/error - handle), expects #<test-one-of: any one of (1 2)> ==> ok
test with-output-to-process, expects (#t 1 2) ==> ok
test with-output-to-process (redirect), expects (#t 1 2) ==> ok
test call-with-process-io, expects "test.o\n" ==> ok
test call-with-process-io (redirect/error), expects #t ==> ok
test process-output->string, expects #t ==> ok
test process-output->string (error - ignore), expects "" ==> ok
test process-output->string (error - raise), expects #<<process-abnormal-exit>> ==> ok
test process-output->string-list, expects #t ==> ok
test shell-escape-string, expects "''" ==> ok
test shell-escape-string, expects "abc" ==> ok
test shell-escape-string, expects "'a b c'" ==> ok
test shell-escape-string, expects "'$abc'" ==> ok
test shell-escape-string, expects "'[abc]'" ==> ok
test shell-escape-string, expects "'\\abc'" ==> ok
test shell-escape-string, expects "'>abc'" ==> ok
test shell-escape-string, expects "'<abc'" ==> ok
test shell-escape-string, expects "'a\"b\"c'" ==> ok
test shell-escape-string, expects "'a(b)c'" ==> ok
test shell-escape-string, expects "'a{b}c'" ==> ok
test shell-escape-string, expects "'a'\"'\"'c'" ==> ok
passed.
Testing gauche.version ========================================================
testing bindings in #<module gauche.version> ... ok
test relnum-compare, expects (-1 0 1) ==> ok
test relnum-compare, expects (-1 0 1) ==> ok
test relnum-compare, expects (-1 0 1) ==> ok
test version-compare 1 1, expects (0 0) ==> ok
test version-compare 2.3 2.3, expects (0 0) ==> ok
test version-compare 2.34.5b-patch3 2.34.5b-patch3, expects (0 0) ==> ok
test version-compare 20020202-1 20020202-1, expects (0 0) ==> ok
test version-compare 1 1.0, expects (-1 1) ==> ok
test version-compare 1.0 1.1, expects (-1 1) ==> ok
test version-compare 1.1 1.1.1, expects (-1 1) ==> ok
test version-compare 1.1 1.1.1.1, expects (-1 1) ==> ok
test version-compare 1.0.1 1.1, expects (-1 1) ==> ok
test version-compare 1.1.1 1.1.2, expects (-1 1) ==> ok
test version-compare 1.1.2 1.2, expects (-1 1) ==> ok
test version-compare 1.2 1.11, expects (-1 1) ==> ok
test version-compare 1.2.3 1.2.3-1, expects (-1 1) ==> ok
test version-compare 1.2.3-1 1.2.3-10, expects (-1 1) ==> ok
test version-compare 1.2.3-1 1.2.4, expects (-1 1) ==> ok
test version-compare 1.2.3 1.2.3a, expects (-1 1) ==> ok
test version-compare 1.2.3a 1.2.3b, expects (-1 1) ==> ok
test version-compare 1.2.3a 1.2.12, expects (-1 1) ==> ok
test version-compare 1.2_rc0 1.2_rc1, expects (-1 1) ==> ok
test version-compare 1.2_rc1 1.2, expects (-1 1) ==> ok
test version-compare 1.2 1.2-patch1, expects (-1 1) ==> ok
test version-compare 1.2-patch1 1.2-patch2, expects (-1 1) ==> ok
test version-compare 1.2_pre0 1.2-patch1, expects (-1 1) ==> ok
test version-compare 1.1-patch112 1.2_alpha, expects (-1 1) ==> ok
test version-compare 19990312 20000801, expects (-1 1) ==> ok
test version-compare 20010101-4 20010101-13, expects (-1 1) ==> ok
test version-compare 20011125-2.1 20011213-2.1, expects (-1 1) ==> ok
test version-compare 20011213-1.4 20011213-1.12, expects (-1 1) ==> ok
test version-compare 20011213-1.12 20011213-3.1, expects (-1 1) ==> ok
test version-compare 20011213-1.12_alpha0 20011213-1.12, expects (-1 1) ==> ok
test version-compare 20011213-1.12_alpha0 20011213-1.12.1, expects (-1 1) ==> ok
test version=?, expects #t ==> ok
test version=?, expects #f ==> ok
test version<?, expects #t ==> ok
test version<?, expects #f ==> ok
test version<?, expects #f ==> ok
test version<=?, expects #t ==> ok
test version<=?, expects #t ==> ok
test version<=?, expects #f ==> ok
test version>?, expects #f ==> ok
test version>?, expects #f ==> ok
test version>?, expects #t ==> ok
test version>=?, expects #f ==> ok
test version>=?, expects #t ==> ok
test version>=?, expects #t ==> ok
passed.
Testing file utilities ========================================================
<built-in gauche.fileutil>-----------------------------------------------------
testing bindings in #<module gauche.fileutil> ... ok
test file-exists? (tmp1.o), expects #f ==> ok
test file-is-regular? (tmp1.o), expects #f ==> ok
test file-is-directory? (tmp1.o), expects #f ==> ok
test file-exists? (tmp1.o), expects #t ==> ok
test file-is-regular? (tmp1.o), expects #t ==> ok
test file-is-directory? (tmp1.o), expects #f ==> ok
test file-exists? (tmp1.o), expects #t ==> ok
test file-is-regular? (tmp1.o), expects #f ==> ok
test file-is-directory? (tmp1.o), expects #t ==> ok
test glob a.a, expects ("tmp1.o/a.a") ==> ok
test glob z, expects () ==> ok
test glob *, expects ("tmp1.o/a" "tmp1.o/aa" "tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob a.*, expects ("tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob .*, expects ("tmp1.o/.a" "tmp1.o/." "tmp1.o/..") ==> ok
test glob ?, expects ("tmp1.o/a") ==> ok
test glob *?, expects ("tmp1.o/a" "tmp1.o/aa" "tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob ??, expects ("tmp1.o/aa") ==> ok
test glob *.*, expects ("tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob */*, expects ("tmp1.o/a/b" "tmp1.o/a/cc" "tmp1.o/aa/b") ==> ok
test glob */?, expects ("tmp1.o/a/b" "tmp1.o/aa/b") ==> ok
test glob *  (chdir), expects ("a" "aa" "a.a" "a.b" "a.a.a") ==> ok
test glob */, expects ("tmp1.o/a/" "tmp1.o/aa/") ==> ok
test glob tmp1.o/**/?, expects ("tmp1.o/a" "tmp1.o/a/b" "tmp1.o/a/cc/a" "tmp1.o/aa/b") ==> ok
test glob * .* (multi), expects ("tmp1.o/." "tmp1.o/.." "tmp1.o/.a" "tmp1.o/a" "tmp1.o/aa" "tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob {a,aa}/{b,cc}, expects ("tmp1.o/a/b" "tmp1.o/a/cc" "tmp1.o/aa/b") ==> ok
test glob {a{,a,.{a,b}}}, expects ("tmp1.o/a" "tmp1.o/aa" "tmp1.o/a.a" "tmp1.o/a.b") ==> ok
test glob {a/*,aa/*}, expects ("tmp1.o/a/b" "tmp1.o/a/cc" "tmp1.o/aa/b") ==> ok
test glob {,?/}*, expects ("tmp1.o/a/b" "tmp1.o/a/cc" "tmp1.o/a" "tmp1.o/aa" "tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob {,.}*, expects ("tmp1.o/a" "tmp1.o/aa" "tmp1.o/.a" "tmp1.o/." "tmp1.o/.." "tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob a.[ab], expects ("tmp1.o/a.a" "tmp1.o/a.b") ==> ok
test glob a.[[:alpha:]], expects ("tmp1.o/a.a" "tmp1.o/a.b") ==> ok
test glob *.[[:alpha:]], expects ("tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob *.[![:alpha:]], expects () ==> ok
test glob *.[^[:alpha:]], expects () ==> ok
test glob *.[^A-Z], expects ("tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob w/alt root dir, expects ("tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
test glob w/alt current dir, expects ("tmp1.o/a.a" "tmp1.o/a.b" "tmp1.o/a.a.a") ==> ok
<file.filter>------------------------------------------------------------------
testing bindings in #<module file.filter> ... ok
test file.filter tmp1.o -> string, expects "AAA BBB CCC DDDEEE FFF GGG HHH" ==> ok
test file.filter string -> tmp2.o, expects "AAA BBB CCC DDDEEE FFF GGG HHH" ==> ok
test file.filter cleanup, expects #f ==> ok
test file.filter cleanup, expects #t ==> ok
test file.filter temporary, expects (#f "AAA BBB CCC DDDEEE FFF GGG HHH") ==> ok
passed.
Testing selector ==============================================================
testing bindings in #<module gauche.selector> ... ok
test make, expects #t ==> ok
test selector-add!, expects #f ==> ok
test selector-select, expects (foo) ==> ok
test selector-add!, expects #f ==> ok
test selector-select, expects (bar baz) ==> ok
test selector-delete! (by port), expects (foo) ==> ok
test selector-delete! (by proc), expects (bar baz) ==> ok
test selector-select (flags), expects (((zzz) (yyy)) ((xxx) (yyy))) ==> ok
test selector-delete! (flags), expects ((xxx) (yyy)) ==> ok
passed.
Testing listener ==============================================================
testing bindings in #<module gauche.listener> ... ok
<complete-sexp?>---------------------------------------------------------------
test complete-sexp? , expects #t ==> ok
test complete-sexp? a, expects #t ==> ok
test complete-sexp? abc, expects #t ==> ok
test complete-sexp? 123, expects #t ==> ok
test complete-sexp?   3/4  , expects #t ==> ok
test complete-sexp?   3/4, expects #t ==> ok
test complete-sexp? (), expects #t ==> ok
test complete-sexp? (abc), expects #t ==> ok
test complete-sexp?  ( a ) , expects #t ==> ok
test complete-sexp?  (a) , expects #t ==> ok
test complete-sexp? (a . b), expects #t ==> ok
test complete-sexp?  ((((a)))) , expects #t ==> ok
test complete-sexp?  ((((a))) , expects #f ==> ok
test complete-sexp?  (((( a ))) , expects #f ==> ok
test complete-sexp? (ab cd ef (guhr janr) ((airugn jenr) ..., expects #t ==> ok
test complete-sexp? (ab cd ef [guhr janr] {[airugn jenr] ..., expects #t ==> ok
test complete-sexp? (ab cd ef [guhr janr] {[airugn jenr} ..., expects #f ==> ok
test complete-sexp?  "rugier", expects #t ==> ok
test complete-sexp?  "rugi \"er\" unga", expects #t ==> ok
test complete-sexp?  "\"\"", expects #t ==> ok
test complete-sexp?  "\"er\", expects #f ==> ok
test complete-sexp?  "\"er", expects #t ==> ok
test complete-sexp?  "\"(", expects #t ==> ok
test complete-sexp? #\a, expects #t ==> ok
test complete-sexp? #\, expects #f ==> ok
test complete-sexp? #\abunaga, expects #t ==> ok
test complete-sexp? #\abunaga'(boogaz), expects #t ==> ok
test complete-sexp? #\abunaga'(boogaz, expects #f ==> ok
test complete-sexp? #\(, expects #t ==> ok
test complete-sexp? (#\( ), expects #t ==> ok
test complete-sexp? (#\(gunar), expects #t ==> ok
test complete-sexp? (#\(gunar), expects #t ==> ok
test complete-sexp? #(bunga bunga), expects #t ==> ok
test complete-sexp? [#(bunga bunga)], expects #t ==> ok
test complete-sexp? #x#d3242(bunar), expects #t ==> ok
test complete-sexp? |buna(-|, expects #t ==> ok
test complete-sexp? |buna(-, expects #f ==> ok
test complete-sexp? |buna(-\|zuppe|, expects #t ==> ok
test complete-sexp? |buna(-\|zu[p"e|, expects #t ==> ok
test complete-sexp? (|buna(-| . a), expects #t ==> ok
test complete-sexp? #,(bunga bunga bunga), expects #t ==> ok
test complete-sexp? #,(), expects #t ==> ok
test complete-sexp? #,(yop, expects #f ==> ok
test complete-sexp? (#,( () ) . a), expects #t ==> ok
test complete-sexp? #[a-z], expects #t ==> ok
test complete-sexp? #[[:alpha:]], expects #t ==> ok
test complete-sexp? #[\]], expects #t ==> ok
test complete-sexp? #[1234, expects #f ==> ok
test complete-sexp? (#[1234 . ), expects #f ==> ok
test complete-sexp? (#[1234] . a), expects #t ==> ok
test complete-sexp? [#[1234] . a], expects #t ==> ok
test complete-sexp? #/reg(exp)fofofo[\s\d]/, expects #t ==> ok
test complete-sexp? #/(/, expects #t ==> ok
test complete-sexp? #/\(/, expects #t ==> ok
test complete-sexp? #/\/usr\/bin/, expects #t ==> ok
test complete-sexp? #/\/usr\/bin  , expects #f ==> ok
test complete-sexp? (#/(/ . a), expects #t ==> ok
test complete-sexp? (ibanr #<booba> ), expects #<error> ==> ok
<listener>---------------------------------------------------------------------
test prompter, expects "<<<" ==> ok
test listener, expects ("3") ==> ok
test listener, expects ("1" "2" "3") ==> ok
test listener, expects (("1") ("2")) ==> ok
test listener, expects ("3") ==> ok
test listener, expects (("#\\a") ("3")) ==> ok
test listener (fatal error), expects #<class <unhandled-signal-error>> ==> ok
passed.
Testing dictionary framework ==================================================
testing bindings in #<module gauche.dictionary> ... ok
<hash-table as dictionary>-----------------------------------------------------
test put/get, expects 1 ==> ok
test put/get, expects 2 ==> ok
test get nonexistent, expects #<error> ==> ok
test get default, expects 3 ==> ok
test fold, expects ((a . 1) (b . 2)) ==> ok
test exists?, expects #f ==> ok
test exists?, expects #t ==> ok
test delete!, expects #f ==> ok
<tree-map as dictionary>-------------------------------------------------------
test put/get, expects 1 ==> ok
test put/get, expects 2 ==> ok
test get nonexistent, expects #<error> ==> ok
test get default, expects 3 ==> ok
test fold, expects ((a . 1) (b . 2)) ==> ok
test exists?, expects #f ==> ok
test exists?, expects #t ==> ok
test delete!, expects #f ==> ok
<bimap>------------------------------------------------------------------------
test put/get, expects 1 ==> ok
test put/get, expects 2 ==> ok
test get nonexistent, expects #<error> ==> ok
test get default, expects 3 ==> ok
test fold, expects ((a . 1) (b . 2)) ==> ok
test exists?, expects #f ==> ok
test exists?, expects #t ==> ok
test delete!, expects #f ==> ok
test right lookup, expects (a b) ==> ok
test left lookup, expects (3 1) ==> ok
test override by reverse insertion, expects #f ==> ok
test collection protocol, expects ((b . 2) (c . 3) (d . 1)) ==> ok
passed.
Testing dbi/dbd ===============================================================
testing bindings in #<module dbi> ... ok
<testing with dbd-null>--------------------------------------------------------
test dbi-connect, expects <null-connection> ==> ok
test dbi-close (<dbi-connection>), expects #f ==> ok
test dbi-connect w/options, expects ("testdata;host=foo.biz;port=8088;noretry" (("testdata" . #t) ("host" . "foo.biz") ("port" . "8088") ("noretry" . #t)) (:username "anonymous" :password "sesame")) ==> ok
test dbi-prepare, expects <dbi-query> ==> ok
test execute query, expects ("select * from foo where x = 'z'") ==> ok
test execute query, expects ("select * from foo where x = 333") ==> ok
test execute query, expects ("select * from foo where x = ''''") ==> ok
test dbi-do, expects ("insert into foo values(2,3)") ==> ok
test dbi-do, expects ("insert into foo values('don''t know',NULL)") ==> ok
test <dbi-parameter-error>, expects #<<dbi-parameter-error>> ==> ok
test <dbi-parameter-error>, expects #<<dbi-parameter-error>> ==> ok
test <dbi-parameter-error>, expects #<<dbi-parameter-error>> ==> ok
<testing conditions>-----------------------------------------------------------
test <dbi-nonexistent-driver-error>, expects "nosuchdriver" ==> ok
passed.
Testing www.* modules =========================================================
<www.cgi>----------------------------------------------------------------------
testing bindings in #<module www.cgi> ... ok
test cgi-parse-parameters, expects (("boo" "baz=doo") ("z=z" "!&") ("a" "foo bar" "  ") ("#" "#") ("z" "z=8") ("r" #t "2")) ==> ok
test cgi-parse-parameters, expects (("boo" "baz=doo") ("z=z" "!&") ("a" "foo bar" "  ") ("#" "#") ("z" "z=8") ("r" #t "2")) ==> ok
test cgi-parse-parameters (multipart), expects (("aaa" "111") ("bbb" "abc\ndef\nghi\n") ("ccc" #f) ("ddd" "This is a test sentence.")) ==> ok
test cgi-parse-parameters (multipart, custom handler), expects (("aaa" "111") ("bbb" "x.txt") ("ccc" #f) ("ddd" "ttt\\bbb")) ==> ok
test cgi-parse-parameters (multipart, custom handler 2), expects "abc\ndef\nghi\n" ==> ok
test cgi-parse-parameters (multipart, custom handler 3), expects "abc\ndef\nghi\n" ==> ok
test cgi-parse-parameters (multipart), expects (("aaa" "111") ("bbb" "abc\ndef\nghi\n") ("ccc" #f) ("ddd" "This is a test sentence.")) ==> ok
test cgi-parse-parameters (multipart, custom handler), expects (("aaa" "111") ("bbb" "x.txt") ("ccc" #f) ("ddd" "ttt\\bbb")) ==> ok
test cgi-parse-parameters (multipart, custom handler 2), expects "abc\ndef\nghi\n" ==> ok
test cgi-parse-parameters (multipart, custom handler 3), expects "abc\ndef\nghi\n" ==> ok
test cgi-get-parameter, expects "foo bar" ==> ok
test cgi-get-parameter, expects ("foo bar" "  ") ==> ok
test cgi-get-parameter, expects #t ==> ok
test cgi-get-parameter, expects (#t "2") ==> ok
test cgi-get-parameter, expects ("baz=doo") ==> ok
test cgi-get-parameter, expects none ==> ok
test cgi-get-parameter, expects #f ==> ok
test cgi-get-parameter, expects () ==> ok
test cgi-get-parameter, expects (0 2) ==> ok
test cgi-get-query (GET), expects (("boo" "baz=doo") ("z=z" "!&") ("a" "foo bar" "  ") ("#" "#") ("z" "z=8") ("r" #t "2")) ==> ok
test cgi-get-query (HEAD), expects (("boo" "baz=doo") ("z=z" "!&") ("a" "foo bar" "  ") ("#" "#") ("z" "z=8") ("r" #t "2")) ==> ok
test cgi-get-query (POST), expects (("zz" "aa") ("aa" "zz")) ==> ok
test cgi-get-query (POST), expects (("zz" "aa") ("aa" "zz")) ==> ok
test cgi-get-query (POST), expects (("zz" "aa")) ==> ok
test cgi-header, expects "Content-type: text/html\r\n\r\n" ==> ok
test cgi-header, expects "Location: http://foo.bar/\r\n\r\n" ==> ok
test cgi-header, expects "Content-type: hoge\r\nLocation: http://foo.bar/\r\n\r\n" ==> ok
test cgi-header, expects "Content-type: text/plain; charset=utf-8\r\n\r\n" ==> ok
test cgi-header, expects "Content-type: text/html\r\nSet-cookie: hoge\r\nSet-cookie: poge\r\n\r\n" ==> ok
test cgi-header, expects "Content-type: text/html\r\nSet-cookie: hoge\r\nSet-cookie: poge\r\nx-foo: foo\r\n\r\n" ==> ok
test cgi-main, expects "Content-type: text/plain\r\n\r\na=foo bar" ==> ok
test cgi-output-character-encoding, expects #*"\xe3\x81\x82" ==> ok
<www.cgi.test>-----------------------------------------------------------------
testing bindings in #<module www.cgi.test> ... ok
test cgi-test-environment-ref, expects "remote" ==> ok
test cgi-test-environment-ref, expects "zzz" ==> ok
test cgi-test-environment-set!, expects "foo.com" ==> ok
test call-with-cgi-script, expects (("content-type" "text/plain")) ==> ok
test run-cgi-script->string-list, expects ((("content-type" "text/plain")) ("SERVER_NAME = localhost" "REMOTE_HOST = foo.com" "REQUEST_METHOD = GET" "CONTENT_TYPE = " "QUERY_STRING = ")) ==> ok
test run-cgi-script->string-list (using parameters/GET), expects ("SERVER_NAME = localhost" "REMOTE_HOST = foo.com" "REQUEST_METHOD = GET" "CONTENT_TYPE = " "QUERY_STRING = a=b&%26%26%24%26=%21%40%21%40") ==> ok
test run-cgi-script->string-list (using parameters/HEAD), expects ("SERVER_NAME = localhost" "REMOTE_HOST = foo.com" "REQUEST_METHOD = HEAD" "CONTENT_TYPE = " "QUERY_STRING = a=b&%26%26%24%26=%21%40%21%40") ==> ok
test run-cgi-script->string-list (using parameters), expects ("REQUEST_METHOD = POST" "CONTENT_TYPE = application/x-www-form-urlencoded" "CONTENT_LENGTH = 29" "QUERY_STRING = " "a=b&%26%26%24%26=%21%40%21%40") ==> ok
passed.
Testing gauche.cgen.* =========================================================
<gauche.cgen.unit>-------------------------------------------------------------
testing bindings in #<module gauche.cgen.unit> ... ok
test cgen.unit basic stuff, expects "/* Generated by gauche.cgen */\nstatic void foo(void);\nstatic void foo() { ... }\nvoid Scm__Init_tmp_2eo(void)\n{\nfoo();\n#if ((defined FOO))||((defined BAR))\ninit_foo_bar();\n#endif /* ((defined FOO))||((defined BAR)) */\n#if ((>= BAR_VERSION 3))&&((== FOO_VERSION 2))\n#if ((defined FOO))||((defined BAR))\nsome_trick();\n#endif /* ((defined FOO))||((defined BAR)) */\n#endif /* ((>= BAR_VERSION 3))&&((== FOO_VERSION 2)) */\n}\n" ==> ok
<gauche.cgen.literal>----------------------------------------------------------
testing bindings in #<module gauche.cgen.literal> ... ok
<gauche.cgen.type>-------------------------------------------------------------
testing bindings in #<module gauche.cgen.type> ... ok
<gauche.cgen.cise>-------------------------------------------------------------
testing bindings in #<module gauche.cgen.cise> ... ok
test canonicalize-vardecl (a b c), expects ((a :: ScmObj) (b :: ScmObj) (c :: ScmObj)) ==> ok
test canonicalize-vardecl ((a) (b) (c)), expects ((a) (b) (c)) ==> ok
test canonicalize-vardecl (a::x b::y (c::z)), expects ((a :: x) (b :: y) (c :: z)) ==> ok
test canonicalize-vardecl (a :: x b :: y (c :: z)), expects ((a :: x) (b :: y) (c :: z)) ==> ok
test canonicalize-vardecl (a:: x b ::y (c:: z)), expects ((a :: x) (b :: y) (c :: z)) ==> ok
test canonicalize-vardecl (a:: (x y z) b::p), expects ((a :: (x y z)) (b :: p)) ==> ok
test canonicalize-vardecl ((a::x init) (b:: (x) init) (c :: x init)), expects ((a :: x init) (b :: (x) init) (c :: x init)) ==> ok
test canonicalize-vardecl ((a init) (b init) (c init)), expects ((a init) (b init) (c init)) ==> ok
<gauche.cgen.stub>-------------------------------------------------------------
testing bindings in #<module gauche.cgen.stub> ... ok
<gauche.cgen.precomp>----------------------------------------------------------
testing bindings in #<module gauche.cgen.precomp> ... ok
<gauche.cgen>------------------------------------------------------------------
testing bindings in #<module gauche.cgen> ... ok
passed.
Testing gauche.package.* ======================================================
<gauche.package.util>----------------------------------------------------------
testing bindings in #<module gauche.package.util> ... ok
<gauche.package.build>---------------------------------------------------------
testing bindings in #<module gauche.package.build> ... ok
<gauche.package.compile>-------------------------------------------------------
testing bindings in #<module gauche.package.compile> ... ok
<gauche.package.fetch>---------------------------------------------------------
testing bindings in #<module gauche.package.fetch> ... ok
<gauche.package>---------------------------------------------------------------
testing bindings in #<module gauche.package> ... ok
passed.
Testing case-sensitive reader/writer ==========================================
test reader, expects "abc" ==> ok
test reader, expects "Abc" ==> ok
test reader, expects "aBc" ==> ok
test reader, expects "AbC" ==> ok
test writer, expects "abc" ==> ok
test writer, expects "Abc" ==> ok
test writer, expects "abC" ==> ok
passed.
Testing case-insensitive reader/writer ========================================
test reader, expects "abc" ==> ok
test reader, expects "abc" ==> ok
test reader, expects "abc" ==> ok
test reader, expects "AbC" ==> ok
test writer, expects "abc" ==> ok
test writer, expects "|Abc|" ==> ok
test writer, expects "|abC|" ==> ok
passed.
Testing optimizer =============================================================
<inlining>---------------------------------------------------------------------
test inlining const4 + constant folding, expects (((CONSTI 8)) ((RET))) ==> ok
test inlining add4 + constant folding, expects (((CONSTI 9)) ((RET))) ==> ok
<lambda lifting>---------------------------------------------------------------
test pass4 lambda marking bug, expects #t ==> ok
test lifting constant lambda, expects () ==> ok
test constant closure identity, expects #t ==> ok
<transformation>---------------------------------------------------------------
test intermediate lref elimination 1, expects () ==> ok
test intermediate lref elimination 2, expects () ==> ok
test intermediate lref elimination 3, expects (((PUSH-LOCAL-ENV 1))) ==> ok
test intermediate lref elimination 4, expects (((PUSH-LOCAL-ENV 1))) ==> ok
test intermediate lref elimination 5, expects (((PUSH-LOCAL-ENV 2))) ==> ok
test intermediate lref elimination 6, expects () ==> ok
test intermediate lref elimination 7, expects (((PUSH-LOCAL-ENV 1))) ==> ok
test intermediate lref elimination 8, expects () ==> ok
test make sure define-inline'd procs be optimized, expects () ==> ok
passed.
Testing control ===============================================================
<control.job>------------------------------------------------------------------
testing bindings in #<module control.job> ... ok
test make-job, expects #t ==> ok
test job-touch! acknowledge (pre), expects #f ==> ok
test job-touch! acknowledge, expects #t ==> ok
test job-touch! start (pre), expects #f ==> ok
test job-touch! start, expects #t ==> ok
test job-touch! finish (pre), expects #f ==> ok
test job-touch! finish, expects #t ==> ok
test job-run! precondition, expects (#f #f) ==> ok
test job-run! postcondition, expects (done ok #t) ==> ok
test job-run! error condition, expects (error gosh) ==> ok
test job-run! killed, expects (killed test) ==> ok
test job-wait, job-kill, expects (killed foo) ==> ok
test job-wait and error, expects (error "bang") ==> ok
<control.thread-pool>----------------------------------------------------------
testing bindings in #<module control.thread-pool> ... ok
test pool, expects (5 #t 5 #f) ==> ok
test doit, expects #(0 1 2 3 4 5 6 7 8 9) ==> ok
test error results, expects (ng ng ng ng ng) ==> ok
test add-job! backlog, expects #t ==> ok
test add-job! timeout, expects #f ==> ok
test add-job! backlog, expects #t ==> ok
test wait-all timeout, expects #f ==> ok
test shutdown - raising <thread-pool-shutting-down>, expects #<<thread-pool-shut-down>> ==> ok
test shutdown - killing a job in the queue, expects killed ==> ok
test shutdown check, expects finished ==> ok
test forced shutdown, expects killed ==> ok
test thread pool termination, expects terminated ==> ok
passed.
Testing debug features ========================================================
<stack trace>------------------------------------------------------------------
test trace crossing C stack boundary, expects (rz rf re rd rc rb ra) ==> ok
passed.
Testing utility scripts =======================================================
<gosh>-------------------------------------------------------------------------
test 'main' in an alternative module, expects "foo" ==> ok
<gauche-config>----------------------------------------------------------------
test gauhce-config -V, expects "0.9.3.3" ==> ok
test gauhce-config -I, expects "-I/usr/local/lib/gauche-0.9/0.9.3.3/include" ==> ok
test gauhce-config -L, expects "-L/usr/local/lib/gauche-0.9/0.9.3.3/i686-pc-linux-gnu " ==> ok
test gauhce-config -l, expects "-lgauche-0.9 -ldl -lcrypt -lutil -lm  -lpthread" ==> ok
test gauhce-config --cc, expects "gcc -std=gnu99" ==> ok
test gauhce-config --ac, expects "/usr/local/share/gauche-0.9/0.9.3.3/" ==> ok
test gauhce-config --reconfigure, expects "./configure  '--enable-multibyte=utf-8'" ==> ok
test gauhce-config --arch, expects "i686-pc-linux-gnu" ==> ok
test gauhce-config --syslibdir, expects "/usr/local/share/gauche-0.9/0.9.3.3/lib" ==> ok
test gauhce-config --sysarchdir, expects "/usr/local/lib/gauche-0.9/0.9.3.3/i686-pc-linux-gnu" ==> ok
test gauhce-config --sysincdir, expects "/usr/local/lib/gauche-0.9/0.9.3.3/include" ==> ok
test gauhce-config --sitelibdir, expects "/usr/local/share/gauche-0.9/site/lib" ==> ok
test gauhce-config --sitearchdir, expects "/usr/local/lib/gauche-0.9/site/i686-pc-linux-gnu" ==> ok
test gauhce-config --siteincdir, expects "/usr/local/lib/gauche-0.9/site/include" ==> ok
test gauhce-config --pkglibdir, expects "${datadir}/gauche-0.9/site/lib" ==> ok
test gauhce-config --pkgarchdir, expects "${libdir}/gauche-0.9/site/i686-pc-linux-gnu" ==> ok
test gauhce-config --pkgincdir, expects "${libdir}/gauche-0.9/site/include" ==> ok
test gauhce-config --mandir, expects "/usr/local/share/man" ==> ok
test gauhce-config --infodir, expects "/usr/local/share/info" ==> ok
test gauhce-config --object-suffix, expects "o" ==> ok
test gauhce-config --executable-suffix, expects "" ==> ok
test gauhce-config --so-suffix, expects "so" ==> ok
test gauhce-config --so-ldflags, expects " -shared -o" ==> ok
test gauhce-config --so-libs, expects "" ==> ok
test gauhce-config --dylib-suffix, expects "so" ==> ok
test gauhce-config --dylib-ldflags, expects " -shared -o" ==> ok
test gauhce-config --rpath-flag, expects "-Wl,--rpath -Wl," ==> ok
<gauche-install>---------------------------------------------------------------
test -d, expects #t ==> ok
test file -> file, expects #t ==> ok
test files -> dir, expects #t ==> ok
test -T, expects #t ==> ok
test -U, expects #t ==> ok
test -T -p, expects #t ==> ok
test -U -p, expects #t ==> ok
<gauche-package>---------------------------------------------------------------
test checking existence of DIST, expects #t ==> ok
test checking existence of configure.ac, expects #t ==> ok
test checking existence of Makefile.in, expects #t ==> ok
test checking existence of test.c, expects #t ==> ok
test checking existence of test.h, expects #t ==> ok
test checking existence of test.scm, expects #t ==> ok
test checking existence of testlib.stub, expects #t ==> ok
test checking existence of test/module.scm, expects #t ==> ok
test gauche-package compile, expects #t ==> ok
passed.