diff options
Diffstat (limited to 'ipl/packs/skeem/test.std')
| -rw-r--r-- | ipl/packs/skeem/test.std | 1180 |
1 files changed, 1180 insertions, 0 deletions
diff --git a/ipl/packs/skeem/test.std b/ipl/packs/skeem/test.std new file mode 100644 index 0000000..543ff04 --- /dev/null +++ b/ipl/packs/skeem/test.std @@ -0,0 +1,1180 @@ +CUR-SECTION +ERRS +SECTION +RECORD-ERROR +TEST +REPORT-ERRS +SECTION(2 1) +#t +(+ - ... !.. $.+ %.- &.! *.: /:. :+. <-. =. >. ?. ~. _. ^.) +SECTION(3 4) +#t +DISJOINT-TYPE-FUNCTIONS +TYPE-EXAMPLES +I + #<procedure BOOLEAN_P> + #<procedure CHAR_P> + #<procedure NULL_P> + #<procedure NUMBER_P> + #<procedure PAIR_P> + #<procedure PROCEDURE_P> + #<procedure STRING_P> + #<procedure SYMBOL_P> + #<procedure VECTOR_P> +#<output &output> +(#t #f #f #f #f #f #f #f #f)#t +(#t #f #f #f #f #f #f #f #f)#f +(#f #t #f #f #f #f #f #f #f)#\a +(#f #f #t #f #f #f #f #f #f)() +(#f #f #f #t #f #f #f #f #f)9739 +(#f #f #f #f #t #f #f #f #f)(TEST) +(#f #f #f #f #f #t #f #f #f)#<interpreted function RECORD-ERROR> +(#f #f #f #f #f #f #t #f #f)"test" +(#f #f #f #f #f #f #t #f #f)"" +(#f #f #f #f #f #f #f #t #f)TEST +(#f #f #f #f #f #f #f #f #t)#() +(#f #f #f #f #f #f #f #f #t)#(A B C) +TYPE-MATRIX +SECTION(4 1 2) +#t +(QUOTE (QUOTE A)) ==> (QUOTE A) +#t +(QUOTE (QUOTE A)) ==> (QUOTE A) +#t +SECTION(4 1 3) +#t +(#<procedure MULTIPLY> 3 4) ==> 12 +#t +SECTION(4 1 4) +#t +(#<interpreted function ???> 4) ==> 8 +#t +REVERSE-SUBTRACT +(#<interpreted function REVERSE-SUBTRACT> 7 10) ==> 3 +#t +ADD4 +(#<interpreted function ADD4> 6) ==> 10 +#t +(#<interpreted function ???> 3 4 5 6) ==> (3 4 5 6) +#t +(#<interpreted function ???> 3 4 5 6) ==> (5 6) +#t +SECTION(4 1 5) +#t +(IF YES) ==> YES +#t +(IF NO) ==> NO +#t +(IF 1) ==> 1 +#t +SECTION(4 1 6) +#t +X +(DEFINE 3) ==> 3 +#t +4 +(SET! 5) ==> 5 +#t +SECTION(4 2 1) +#t +(COND GREATER) ==> GREATER +#t +(COND EQUAL) ==> EQUAL +#t +(COND 2) ==> 2 +#t +(CASE COMPOSITE) ==> COMPOSITE +#t +(CASE CONSONANT) ==> CONSONANT +#t +(AND #t) ==> #t +#t +(AND #f) ==> #f +#t +(AND (F G)) ==> (F G) +#t +(AND #t) ==> #t +#t +(OR #t) ==> #t +#t +(OR #t) ==> #t +#t +(OR #f) ==> #f +#t +(OR #f) ==> #f +#t +(OR (B C)) ==> (B C) +#t +SECTION(4 2 2) +#t +(LET 6) ==> 6 +#t +(LET 35) ==> 35 +#t +(LET* 70) ==> 70 +#t +(LETREC #t) ==> #t +#t +X +(LET 5) ==> 5 +#t +(LET 34) ==> 34 +#t +(LET 6) ==> 6 +#t +(LET 34) ==> 34 +#t +(LET* 7) ==> 7 +#t +(LET* 34) ==> 34 +#t +(LET* 8) ==> 8 +#t +(LET* 34) ==> 34 +#t +(LETREC 9) ==> 9 +#t +(LETREC 34) ==> 34 +#t +(LETREC 10) ==> 10 +#t +(LETREC 34) ==> 34 +#t +SECTION(4 2 3) +#t +X +(BEGIN 6) ==> 6 +#t +SECTION(4 2 4) +#t +(DO #(0 1 2 3 4)) ==> #(0 1 2 3 4) +#t +(DO 25) ==> 25 +#t +(LET 1) ==> 1 +#t +(LET ((6 1 3) (-5 -2))) ==> ((6 1 3) (-5 -2)) +#t +SECTION(4 2 6) +#t +(QUASIQUOTE (LIST 3 4)) ==> (LIST 3 4) +#t +(QUASIQUOTE (LIST A (QUOTE A))) ==> (LIST A (QUOTE A)) +#t +(QUASIQUOTE (A 3 4 5 6 B)) ==> (A 3 4 5 6 B) +#t +(QUASIQUOTE ((FOO 7) . CONS)) ==> ((FOO 7) . CONS) +#t +SQT +(QUASIQUOTE #(10 5 2 4 3 8)) ==> #(10 5 2 4 3 8) +#t +(QUASIQUOTE 5) ==> 5 +#t +(QUASIQUOTE (A (QUASIQUOTE (B (UNQUOTE (+ 1 2)) (UNQUOTE (FOO 4 D)) E)) F)) ==> (A (QUASIQUOTE (B (UNQUOTE (+ 1 2)) (UNQUOTE (FOO 4 D)) E)) F) +#t +(QUASIQUOTE (A (QUASIQUOTE (B (UNQUOTE X) (UNQUOTE (QUOTE Y)) D)) E)) ==> (A (QUASIQUOTE (B (UNQUOTE X) (UNQUOTE (QUOTE Y)) D)) E) +#t +(QUASIQUOTE (LIST 3 4)) ==> (LIST 3 4) +#t +(QUASIQUOTE (QUASIQUOTE (LIST (UNQUOTE (+ 1 2)) 4))) ==> (QUASIQUOTE (LIST (UNQUOTE (+ 1 2)) 4)) +#t +SECTION(5 2 1) +#t +ADD3 +(DEFINE 6) ==> 6 +#t +FIRST +(DEFINE 1) ==> 1 +#t +SECTION(5 2 2) +#t +(DEFINE 45) ==> 45 +#t +X +FOO +(#<interpreted function FOO>) ==> 5 +#t +(DEFINE 34) ==> 34 +#t +FOO +(#<interpreted function FOO>) ==> 5 +#t +(DEFINE 34) ==> 34 +#t +FOO +(#<interpreted function FOO> 88) ==> 88 +#t +(#<interpreted function FOO> 4) ==> 4 +#t +(DEFINE 34) ==> 34 +#t +SECTION(6 1) +#t +(#<procedure NOT> #t) ==> #f +#t +(#<procedure NOT> 3) ==> #f +#t +(#<procedure NOT> (3)) ==> #f +#t +(#<procedure NOT> #f) ==> #t +#t +(#<procedure NOT> ()) ==> #f +#t +(#<procedure NOT> ()) ==> #f +#t +(#<procedure NOT> NIL) ==> #f +#t +(#<procedure BOOLEAN_P> #f) ==> #t +#t +(#<procedure BOOLEAN_P> 0) ==> #f +#t +(#<procedure BOOLEAN_P> ()) ==> #f +#t +SECTION(6 2) +#t +(#<procedure EQV_P> A A) ==> #t +#t +(#<procedure EQV_P> A B) ==> #f +#t +(#<procedure EQV_P> 2 2) ==> #t +#t +(#<procedure EQV_P> () ()) ==> #t +#t +(#<procedure EQV_P> 10000 10000) ==> #t +#t +(#<procedure EQV_P> (1 . 2) (1 . 2)) ==> #f +#t +(#<procedure EQV_P> #<interpreted function ???> #<interpreted function ???>) ==> #f +#t +(#<procedure EQV_P> #f NIL) ==> #f +#t +(#<procedure EQV_P> #<interpreted function ???> #<interpreted function ???>) ==> #t +#t +GEN-COUNTER +(#<procedure EQV_P> #<interpreted function ???> #<interpreted function ???>) ==> #t +#t +(#<procedure EQV_P> #<interpreted function ???> #<interpreted function ???>) ==> #f +#t +(#<procedure EQV_P> #<interpreted function ???> #<interpreted function ???>) ==> #f +#t +(#<procedure EQ_P> A A) ==> #t +#t +(#<procedure EQ_P> (A) (A)) ==> #f +#t +(#<procedure EQ_P> () ()) ==> #t +#t +(#<procedure EQ_P> #<procedure CAR> #<procedure CAR>) ==> #t +#t +(#<procedure EQ_P> (A) (A)) ==> #t +#t +(#<procedure EQ_P> #() #()) ==> #t +#t +(#<procedure EQ_P> #<interpreted function ???> #<interpreted function ???>) ==> #t +#t +(#<procedure EQUAL_P> A A) ==> #t +#t +(#<procedure EQUAL_P> (A) (A)) ==> #t +#t +(#<procedure EQUAL_P> (A (B) C) (A (B) C)) ==> #t +#t +(#<procedure EQUAL_P> "abc" "abc") ==> #t +#t +(#<procedure EQUAL_P> 2 2) ==> #t +#t +(#<procedure EQUAL_P> #(A A A A A) #(A A A A A)) ==> #t +#t +SECTION(6 3) +#t +(DOT (A B C D E)) ==> (A B C D E) +#t +X +Y +(#<procedure LIST_P> (A B C)) ==> #t +#t +4 +(SET-CDR! (A . 4)) ==> (A . 4) +#t +(#<procedure EQV_P> (A . 4) (A . 4)) ==> #t +#t +(DOT (A B C . D)) ==> (A B C . D) +#t +(#<procedure LIST_P> (A . 4)) ==> #f +#t +(LIST? #f) ==> #f +#t +(#<procedure PAIR_P> (A . B)) ==> #t +#t +(#<procedure PAIR_P> (A . 1)) ==> #t +#t +(#<procedure PAIR_P> (A B C)) ==> #t +#t +(#<procedure PAIR_P> ()) ==> #f +#t +(#<procedure PAIR_P> #(A B)) ==> #f +#t +(#<procedure CONS> A ()) ==> (A) +#t +(#<procedure CONS> (A) (B C D)) ==> ((A) B C D) +#t +(#<procedure CONS> "a" (B C)) ==> ("a" B C) +#t +(#<procedure CONS> A 3) ==> (A . 3) +#t +(#<procedure CONS> (A B) C) ==> ((A B) . C) +#t +(#<procedure CAR> (A B C)) ==> A +#t +(#<procedure CAR> ((A) B C D)) ==> (A) +#t +(#<procedure CAR> (1 . 2)) ==> 1 +#t +(#<procedure CDR> ((A) B C D)) ==> (B C D) +#t +(#<procedure CDR> (1 . 2)) ==> 2 +#t +(#<procedure LIST> A 7 C) ==> (A 7 C) +#t +(#<procedure LIST>) ==> () +#t +(#<procedure LENGTH> (A B C)) ==> 3 +#t +(#<procedure LENGTH> (A (B) (C D E))) ==> 3 +#t +(#<procedure LENGTH> ()) ==> 0 +#t +(#<procedure APPEND> (X) (Y)) ==> (X Y) +#t +(#<procedure APPEND> (A) (B C D)) ==> (A B C D) +#t +(#<procedure APPEND> (A (B)) ((C))) ==> (A (B) (C)) +#t +(#<procedure APPEND>) ==> () +#t +(#<procedure APPEND> (A B) (C . D)) ==> (A B C . D) +#t +(#<procedure APPEND> () A) ==> A +#t +(#<procedure REVERSE> (A B C)) ==> (C B A) +#t +(#<procedure REVERSE> (A (B C) D (E (F)))) ==> ((E (F)) D (B C) A) +#t +(#<procedure LIST_REF> (A B C D) 2) ==> C +#t +(#<procedure MEMQ> A (A B C)) ==> (A B C) +#t +(#<procedure MEMQ> B (A B C)) ==> (B C) +#t +(#<procedure MEMQ> A (B C D)) ==> #f +#t +(#<procedure MEMQ> (A) (B (A) C)) ==> #f +#t +(#<procedure MEMBER> (A) (B (A) C)) ==> ((A) C) +#t +(#<procedure MEMV> 101 (100 101 102)) ==> (101 102) +#t +E +(#<procedure ASSQ> A ((A 1) (B 2) (C 3))) ==> (A 1) +#t +(#<procedure ASSQ> B ((A 1) (B 2) (C 3))) ==> (B 2) +#t +(#<procedure ASSQ> D ((A 1) (B 2) (C 3))) ==> #f +#t +(#<procedure ASSQ> (A) (((A)) ((B)) ((C)))) ==> #f +#t +(#<procedure ASSOC> (A) (((A)) ((B)) ((C)))) ==> ((A)) +#t +(#<procedure ASSV> 5 ((2 3) (5 7) (11 13))) ==> (5 7) +#t +SECTION(6 4) +#t +(#<procedure SYMBOL_P> FOO) ==> #t +#t +(#<procedure SYMBOL_P> A) ==> #t +#t +(#<procedure SYMBOL_P> "bar") ==> #f +#t +(#<procedure SYMBOL_P> NIL) ==> #t +#t +(#<procedure SYMBOL_P> ()) ==> #f +#t +(#<procedure SYMBOL_P> #f) ==> #f +#t +CHAR-STANDARD-CASE +#f +(STANDARD-CASE #t) ==> #t +#t +(STANDARD-CASE #t) ==> #t +#t +STR-COPY +STRING-STANDARD-CASE +(#<procedure SYMBOL_2_STRING> FLYING-FISH) ==> "FLYING-FISH" +#t +(#<procedure SYMBOL_2_STRING> MARTIN) ==> "MARTIN" +#t +(#<procedure SYMBOL_2_STRING> |Malvina|) ==> "Malvina" +#t +(STANDARD-CASE #t) ==> #t +#t +X +Y +"cb" +(STRING-SET! "cb") ==> "cb" +#t +(#<procedure SYMBOL_2_STRING> |ab|) ==> "ab" +#t +(#<procedure STRING_2_SYMBOL> "ab") ==> |ab| +#t +(#<procedure EQ_P> MISSISSIPPI MISSISSIPPI) ==> #t +#t +(STRING->SYMBOL #f) ==> #f +#t +(#<procedure STRING_2_SYMBOL> "JOLLYWOG") ==> JOLLYWOG +#t +SECTION(6 5 5) +#t +(#<procedure NUMBER_P> 3) ==> #t +#t +(#<procedure COMPLEX_P> 3) ==> #t +#t +(#<procedure REAL_P> 3) ==> #t +#t +(#<procedure RATIONAL_P> 3) ==> #t +#t +(#<procedure INTEGER_P> 3) ==> #t +#t +(#<procedure EXACT_P> 3) ==> #t +#t +(#<procedure INEXACT_P> 3) ==> #f +#t +(#<procedure EQ> 22 22 22) ==> #t +#t +(#<procedure EQ> 22 22) ==> #t +#t +(#<procedure EQ> 34 34 35) ==> #f +#t +(#<procedure EQ> 34 35) ==> #f +#t +(#<procedure GT> 3 -6246) ==> #t +#t +(#<procedure GT> 9 9 -2424) ==> #f +#t +(#<procedure GE> 3 -4 -6246) ==> #t +#t +(#<procedure GE> 9 9) ==> #t +#t +(#<procedure GE> 8 9) ==> #f +#t +(#<procedure LT> -1 2 3 4 5 6 7 8) ==> #t +#t +(#<procedure LT> -1 2 3 4 4 5 6 7) ==> #f +#t +(#<procedure LE> -1 2 3 4 5 6 7 8) ==> #t +#t +(#<procedure LE> -1 2 3 4 4 5 6 7) ==> #t +#t +(#<procedure LT> 1 3 2) ==> #f +#t +(#<procedure GE> 1 3 2) ==> #f +#t +(#<procedure ZERO_P> 0) ==> #t +#t +(#<procedure ZERO_P> 1) ==> #f +#t +(#<procedure ZERO_P> -1) ==> #f +#t +(#<procedure ZERO_P> -100) ==> #f +#t +(#<procedure POSITIVE_P> 4) ==> #t +#t +(#<procedure POSITIVE_P> -4) ==> #f +#t +(#<procedure POSITIVE_P> 0) ==> #f +#t +(#<procedure NEGATIVE_P> 4) ==> #f +#t +(#<procedure NEGATIVE_P> -4) ==> #t +#t +(#<procedure NEGATIVE_P> 0) ==> #f +#t +(#<procedure ODD_P> 3) ==> #t +#t +(#<procedure ODD_P> 2) ==> #f +#t +(#<procedure ODD_P> -4) ==> #f +#t +(#<procedure ODD_P> -1) ==> #t +#t +(#<procedure EVEN_P> 3) ==> #f +#t +(#<procedure EVEN_P> 2) ==> #t +#t +(#<procedure EVEN_P> -4) ==> #t +#t +(#<procedure EVEN_P> -1) ==> #f +#t +(#<procedure MAX> 34 5 7 38 6) ==> 38 +#t +(#<procedure MIN> 3 5 5 330 4 -24) ==> -24 +#t +(#<procedure ADD> 3 4) ==> 7 +#t +(#<procedure ADD> 3) ==> 3 +#t +(#<procedure ADD>) ==> 0 +#t +(#<procedure MULTIPLY> 4) ==> 4 +#t +(#<procedure MULTIPLY>) ==> 1 +#t +(#<procedure SUBTRACT> 3 4) ==> -1 +#t +(#<procedure SUBTRACT> 3) ==> -3 +#t +(#<procedure ABS> -7) ==> 7 +#t +(#<procedure ABS> 7) ==> 7 +#t +(#<procedure ABS> 0) ==> 0 +#t +(#<procedure QUOTIENT> 35 7) ==> 5 +#t +(#<procedure QUOTIENT> -35 7) ==> -5 +#t +(#<procedure QUOTIENT> 35 -7) ==> -5 +#t +(#<procedure QUOTIENT> -35 -7) ==> 5 +#t +(#<procedure MODULO> 13 4) ==> 1 +#t +(#<procedure REMAINDER> 13 4) ==> 1 +#t +(#<procedure MODULO> -13 4) ==> 3 +#t +(#<procedure REMAINDER> -13 4) ==> -1 +#t +(#<procedure MODULO> 13 -4) ==> -3 +#t +(#<procedure REMAINDER> 13 -4) ==> 1 +#t +(#<procedure MODULO> -13 -4) ==> -1 +#t +(#<procedure REMAINDER> -13 -4) ==> -1 +#t +DIVTEST +(#<interpreted function DIVTEST> 238 9) ==> #t +#t +(#<interpreted function DIVTEST> -238 9) ==> #t +#t +(#<interpreted function DIVTEST> 238 -9) ==> #t +#t +(#<interpreted function DIVTEST> -238 -9) ==> #t +#t +(#<procedure GCD> 0 4) ==> 4 +#t +(#<procedure GCD> -4 0) ==> 4 +#t +(#<procedure GCD> 32 -36) ==> 4 +#t +(#<procedure GCD>) ==> 0 +#t +(#<procedure LCM> 32 -36) ==> 288 +#t +(#<procedure LCM>) ==> 1 +#t +TEST-INEXACT +TEST-BIGNUM +SECTION(6 5 6) +#t +(#<procedure NUMBER_2_STRING> 0) ==> "0" +#t +(#<procedure NUMBER_2_STRING> 100) ==> "100" +#t +(#<procedure NUMBER_2_STRING> 256 16) ==> "100" +#t +(#<procedure STRING_2_NUMBER> "100") ==> 100 +#t +(#<procedure STRING_2_NUMBER> "100" 16) ==> 256 +#t +(#<procedure STRING_2_NUMBER> "") ==> #f +#t +(#<procedure STRING_2_NUMBER> ".") ==> #f +#t +(#<procedure STRING_2_NUMBER> "d") ==> #f +#t +(#<procedure STRING_2_NUMBER> "D") ==> #f +#t +(#<procedure STRING_2_NUMBER> "i") ==> #f +#t +(#<procedure STRING_2_NUMBER> "I") ==> #f +#t +(#<procedure STRING_2_NUMBER> "3i") ==> #f +#t +(#<procedure STRING_2_NUMBER> "3I") ==> #f +#t +(#<procedure STRING_2_NUMBER> "33i") ==> #f +#t +(#<procedure STRING_2_NUMBER> "33I") ==> #f +#t +(#<procedure STRING_2_NUMBER> "3.3i") ==> #f +#t +(#<procedure STRING_2_NUMBER> "3.3I") ==> #f +#t +(#<procedure STRING_2_NUMBER> "-") ==> #f +#t +(#<procedure STRING_2_NUMBER> "+") ==> #f +#t +SECTION(6 6) +#t +(#<procedure EQV_P> #\space #\space) ==> #t +#t +(#<procedure EQV_P> #\space #\space) ==> #t +#t +(#<procedure CHAR_P> #\a) ==> #t +#t +(#<procedure CHAR_P> #\() ==> #t +#t +(#<procedure CHAR_P> #\space) ==> #t +#t +(#<procedure CHAR_P> #\newline) ==> #t +#t +(#<procedure CHAR_EQ> #\A #\B) ==> #f +#t +(#<procedure CHAR_EQ> #\a #\b) ==> #f +#t +(#<procedure CHAR_EQ> #\9 #\0) ==> #f +#t +(#<procedure CHAR_EQ> #\A #\A) ==> #t +#t +(#<procedure CHAR_LT> #\A #\B) ==> #t +#t +(#<procedure CHAR_LT> #\a #\b) ==> #t +#t +(#<procedure CHAR_LT> #\9 #\0) ==> #f +#t +(#<procedure CHAR_LT> #\A #\A) ==> #f +#t +(#<procedure CHAR_GT> #\A #\B) ==> #f +#t +(#<procedure CHAR_GT> #\a #\b) ==> #f +#t +(#<procedure CHAR_GT> #\9 #\0) ==> #t +#t +(#<procedure CHAR_GT> #\A #\A) ==> #f +#t +(#<procedure CHAR_LE> #\A #\B) ==> #t +#t +(#<procedure CHAR_LE> #\a #\b) ==> #t +#t +(#<procedure CHAR_LE> #\9 #\0) ==> #f +#t +(#<procedure CHAR_LE> #\A #\A) ==> #t +#t +(#<procedure CHAR_GE> #\A #\B) ==> #f +#t +(#<procedure CHAR_GE> #\a #\b) ==> #f +#t +(#<procedure CHAR_GE> #\9 #\0) ==> #t +#t +(#<procedure CHAR_GE> #\A #\A) ==> #t +#t +(#<procedure CHAR_CI_EQ> #\A #\B) ==> #f +#t +(#<procedure CHAR_CI_EQ> #\a #\B) ==> #f +#t +(#<procedure CHAR_CI_EQ> #\A #\b) ==> #f +#t +(#<procedure CHAR_CI_EQ> #\a #\b) ==> #f +#t +(#<procedure CHAR_CI_EQ> #\9 #\0) ==> #f +#t +(#<procedure CHAR_CI_EQ> #\A #\A) ==> #t +#t +(#<procedure CHAR_CI_EQ> #\A #\a) ==> #t +#t +(#<procedure CHAR_CI_LT> #\A #\B) ==> #t +#t +(#<procedure CHAR_CI_LT> #\a #\B) ==> #t +#t +(#<procedure CHAR_CI_LT> #\A #\b) ==> #t +#t +(#<procedure CHAR_CI_LT> #\a #\b) ==> #t +#t +(#<procedure CHAR_CI_LT> #\9 #\0) ==> #f +#t +(#<procedure CHAR_CI_LT> #\A #\A) ==> #f +#t +(#<procedure CHAR_CI_LT> #\A #\a) ==> #f +#t +(#<procedure CHAR_CI_GT> #\A #\B) ==> #f +#t +(#<procedure CHAR_CI_GT> #\a #\B) ==> #f +#t +(#<procedure CHAR_CI_GT> #\A #\b) ==> #f +#t +(#<procedure CHAR_CI_GT> #\a #\b) ==> #f +#t +(#<procedure CHAR_CI_GT> #\9 #\0) ==> #t +#t +(#<procedure CHAR_CI_GT> #\A #\A) ==> #f +#t +(#<procedure CHAR_CI_GT> #\A #\a) ==> #f +#t +(#<procedure CHAR_CI_LE> #\A #\B) ==> #t +#t +(#<procedure CHAR_CI_LE> #\a #\B) ==> #t +#t +(#<procedure CHAR_CI_LE> #\A #\b) ==> #t +#t +(#<procedure CHAR_CI_LE> #\a #\b) ==> #t +#t +(#<procedure CHAR_CI_LE> #\9 #\0) ==> #f +#t +(#<procedure CHAR_CI_LE> #\A #\A) ==> #t +#t +(#<procedure CHAR_CI_LE> #\A #\a) ==> #t +#t +(#<procedure CHAR_CI_GE> #\A #\B) ==> #f +#t +(#<procedure CHAR_CI_GE> #\a #\B) ==> #f +#t +(#<procedure CHAR_CI_GE> #\A #\b) ==> #f +#t +(#<procedure CHAR_CI_GE> #\a #\b) ==> #f +#t +(#<procedure CHAR_CI_GE> #\9 #\0) ==> #t +#t +(#<procedure CHAR_CI_GE> #\A #\A) ==> #t +#t +(#<procedure CHAR_CI_GE> #\A #\a) ==> #t +#t +(#<procedure CHAR_ALPHABETIC_P> #\a) ==> #t +#t +(#<procedure CHAR_ALPHABETIC_P> #\A) ==> #t +#t +(#<procedure CHAR_ALPHABETIC_P> #\z) ==> #t +#t +(#<procedure CHAR_ALPHABETIC_P> #\Z) ==> #t +#t +(#<procedure CHAR_ALPHABETIC_P> #\0) ==> #f +#t +(#<procedure CHAR_ALPHABETIC_P> #\9) ==> #f +#t +(#<procedure CHAR_ALPHABETIC_P> #\space) ==> #f +#t +(#<procedure CHAR_ALPHABETIC_P> #\;) ==> #f +#t +(#<procedure CHAR_NUMERIC_P> #\a) ==> #f +#t +(#<procedure CHAR_NUMERIC_P> #\A) ==> #f +#t +(#<procedure CHAR_NUMERIC_P> #\z) ==> #f +#t +(#<procedure CHAR_NUMERIC_P> #\Z) ==> #f +#t +(#<procedure CHAR_NUMERIC_P> #\0) ==> #t +#t +(#<procedure CHAR_NUMERIC_P> #\9) ==> #t +#t +(#<procedure CHAR_NUMERIC_P> #\space) ==> #f +#t +(#<procedure CHAR_NUMERIC_P> #\;) ==> #f +#t +(#<procedure CHAR_WHITESPACE_P> #\a) ==> #f +#t +(#<procedure CHAR_WHITESPACE_P> #\A) ==> #f +#t +(#<procedure CHAR_WHITESPACE_P> #\z) ==> #f +#t +(#<procedure CHAR_WHITESPACE_P> #\Z) ==> #f +#t +(#<procedure CHAR_WHITESPACE_P> #\0) ==> #f +#t +(#<procedure CHAR_WHITESPACE_P> #\9) ==> #f +#t +(#<procedure CHAR_WHITESPACE_P> #\space) ==> #t +#t +(#<procedure CHAR_WHITESPACE_P> #\;) ==> #f +#t +(#<procedure CHAR_UPPER_CASE_P> #\0) ==> #f +#t +(#<procedure CHAR_UPPER_CASE_P> #\9) ==> #f +#t +(#<procedure CHAR_UPPER_CASE_P> #\space) ==> #f +#t +(#<procedure CHAR_UPPER_CASE_P> #\;) ==> #f +#t +(#<procedure CHAR_LOWER_CASE_P> #\0) ==> #f +#t +(#<procedure CHAR_LOWER_CASE_P> #\9) ==> #f +#t +(#<procedure CHAR_LOWER_CASE_P> #\space) ==> #f +#t +(#<procedure CHAR_LOWER_CASE_P> #\;) ==> #f +#t +(#<procedure INTEGER_2_CHAR> 46) ==> #\. +#t +(#<procedure INTEGER_2_CHAR> 65) ==> #\A +#t +(#<procedure INTEGER_2_CHAR> 97) ==> #\a +#t +(#<procedure CHAR_UPCASE> #\A) ==> #\A +#t +(#<procedure CHAR_UPCASE> #\a) ==> #\A +#t +(#<procedure CHAR_DOWNCASE> #\A) ==> #\a +#t +(#<procedure CHAR_DOWNCASE> #\a) ==> #\a +#t +SECTION(6 7) +#t +(#<procedure STRING_P> "The word \"recursion\\\" has many meanings.") ==> #t +#t +(#<procedure STRING_P> "") ==> #t +#t +F +(STRING-SET! "?**") ==> "?**" +#t +(#<procedure STRING> #\a #\b #\c) ==> "abc" +#t +(#<procedure STRING>) ==> "" +#t +(#<procedure STRING_LENGTH> "abc") ==> 3 +#t +(#<procedure STRING_REF> "abc" 0) ==> #\a +#t +(#<procedure STRING_REF> "abc" 2) ==> #\c +#t +(#<procedure STRING_LENGTH> "") ==> 0 +#t +(#<procedure SUBSTRING> "ab" 0 0) ==> "" +#t +(#<procedure SUBSTRING> "ab" 1 1) ==> "" +#t +(#<procedure SUBSTRING> "ab" 2 2) ==> "" +#t +(#<procedure SUBSTRING> "ab" 0 1) ==> "a" +#t +(#<procedure SUBSTRING> "ab" 1 2) ==> "b" +#t +(#<procedure SUBSTRING> "ab" 0 2) ==> "ab" +#t +(#<procedure STRING_APPEND> "foo" "bar") ==> "foobar" +#t +(#<procedure STRING_APPEND> "foo") ==> "foo" +#t +(#<procedure STRING_APPEND> "foo" "") ==> "foo" +#t +(#<procedure STRING_APPEND> "" "foo") ==> "foo" +#t +(#<procedure STRING_APPEND>) ==> "" +#t +(#<procedure MAKE_STRING> 0) ==> "" +#t +(#<procedure STRING_EQ> "" "") ==> #t +#t +(#<procedure STRING_LT> "" "") ==> #f +#t +(#<procedure STRING_GT> "" "") ==> #f +#t +(#<procedure STRING_LE> "" "") ==> #t +#t +(#<procedure STRING_GE> "" "") ==> #t +#t +(#<procedure STRING_CI_EQ> "" "") ==> #t +#t +(#<procedure STRING_CI_LT> "" "") ==> #f +#t +(#<procedure STRING_CI_GT> "" "") ==> #f +#t +(#<procedure STRING_CI_LE> "" "") ==> #t +#t +(#<procedure STRING_CI_GE> "" "") ==> #t +#t +(#<procedure STRING_EQ> "A" "B") ==> #f +#t +(#<procedure STRING_EQ> "a" "b") ==> #f +#t +(#<procedure STRING_EQ> "9" "0") ==> #f +#t +(#<procedure STRING_EQ> "A" "A") ==> #t +#t +(#<procedure STRING_LT> "A" "B") ==> #t +#t +(#<procedure STRING_LT> "a" "b") ==> #t +#t +(#<procedure STRING_LT> "9" "0") ==> #f +#t +(#<procedure STRING_LT> "A" "A") ==> #f +#t +(#<procedure STRING_GT> "A" "B") ==> #f +#t +(#<procedure STRING_GT> "a" "b") ==> #f +#t +(#<procedure STRING_GT> "9" "0") ==> #t +#t +(#<procedure STRING_GT> "A" "A") ==> #f +#t +(#<procedure STRING_LE> "A" "B") ==> #t +#t +(#<procedure STRING_LE> "a" "b") ==> #t +#t +(#<procedure STRING_LE> "9" "0") ==> #f +#t +(#<procedure STRING_LE> "A" "A") ==> #t +#t +(#<procedure STRING_GE> "A" "B") ==> #f +#t +(#<procedure STRING_GE> "a" "b") ==> #f +#t +(#<procedure STRING_GE> "9" "0") ==> #t +#t +(#<procedure STRING_GE> "A" "A") ==> #t +#t +(#<procedure STRING_CI_EQ> "A" "B") ==> #f +#t +(#<procedure STRING_CI_EQ> "a" "B") ==> #f +#t +(#<procedure STRING_CI_EQ> "A" "b") ==> #f +#t +(#<procedure STRING_CI_EQ> "a" "b") ==> #f +#t +(#<procedure STRING_CI_EQ> "9" "0") ==> #f +#t +(#<procedure STRING_CI_EQ> "A" "A") ==> #t +#t +(#<procedure STRING_CI_EQ> "A" "a") ==> #t +#t +(#<procedure STRING_CI_LT> "A" "B") ==> #t +#t +(#<procedure STRING_CI_LT> "a" "B") ==> #t +#t +(#<procedure STRING_CI_LT> "A" "b") ==> #t +#t +(#<procedure STRING_CI_LT> "a" "b") ==> #t +#t +(#<procedure STRING_CI_LT> "9" "0") ==> #f +#t +(#<procedure STRING_CI_LT> "A" "A") ==> #f +#t +(#<procedure STRING_CI_LT> "A" "a") ==> #f +#t +(#<procedure STRING_CI_GT> "A" "B") ==> #f +#t +(#<procedure STRING_CI_GT> "a" "B") ==> #f +#t +(#<procedure STRING_CI_GT> "A" "b") ==> #f +#t +(#<procedure STRING_CI_GT> "a" "b") ==> #f +#t +(#<procedure STRING_CI_GT> "9" "0") ==> #t +#t +(#<procedure STRING_CI_GT> "A" "A") ==> #f +#t +(#<procedure STRING_CI_GT> "A" "a") ==> #f +#t +(#<procedure STRING_CI_LE> "A" "B") ==> #t +#t +(#<procedure STRING_CI_LE> "a" "B") ==> #t +#t +(#<procedure STRING_CI_LE> "A" "b") ==> #t +#t +(#<procedure STRING_CI_LE> "a" "b") ==> #t +#t +(#<procedure STRING_CI_LE> "9" "0") ==> #f +#t +(#<procedure STRING_CI_LE> "A" "A") ==> #t +#t +(#<procedure STRING_CI_LE> "A" "a") ==> #t +#t +(#<procedure STRING_CI_GE> "A" "B") ==> #f +#t +(#<procedure STRING_CI_GE> "a" "B") ==> #f +#t +(#<procedure STRING_CI_GE> "A" "b") ==> #f +#t +(#<procedure STRING_CI_GE> "a" "b") ==> #f +#t +(#<procedure STRING_CI_GE> "9" "0") ==> #t +#t +(#<procedure STRING_CI_GE> "A" "A") ==> #t +#t +(#<procedure STRING_CI_GE> "A" "a") ==> #t +#t +SECTION(6 8) +#t +(#<procedure VECTOR_P> #(0 (2 2 2 2) "Anna")) ==> #t +#t +(#<procedure VECTOR_P> #()) ==> #t +#t +(#<procedure VECTOR> A B C) ==> #(A B C) +#t +(#<procedure VECTOR>) ==> #() +#t +(#<procedure VECTOR_LENGTH> #(0 (2 2 2 2) "Anna")) ==> 3 +#t +(#<procedure VECTOR_LENGTH> #()) ==> 0 +#t +(#<procedure VECTOR_REF> #(1 1 2 3 5 8 13 21) 5) ==> 8 +#t +(VECTOR-SET #(0 ("Sue" "Sue") "Anna")) ==> #(0 ("Sue" "Sue") "Anna") +#t +(#<procedure MAKE_VECTOR> 2 HI) ==> #(HI HI) +#t +(#<procedure MAKE_VECTOR> 0) ==> #() +#t +(#<procedure MAKE_VECTOR> 0 A) ==> #() +#t +SECTION(6 9) +#t +(#<procedure PROCEDURE_P> #<procedure CAR>) ==> #t +#t +(#<procedure PROCEDURE_P> CAR) ==> #f +#t +(#<procedure PROCEDURE_P> #<interpreted function ???>) ==> #t +#t +(#<procedure PROCEDURE_P> (LAMBDA (X) (* X X))) ==> #f +#t +(#<procedure CALL_WITH_CURRENT_CONTINUATION> #<procedure PROCEDURE_P>) ==> #t +#t +(#<procedure APPLY> #<procedure ADD> (3 4)) ==> 7 +#t +(#<procedure APPLY> #<interpreted function ???> (3 4)) ==> 7 +#t +(#<procedure APPLY> #<procedure ADD> 10 (3 4)) ==> 17 +#t +(#<procedure APPLY> #<procedure LIST> ()) ==> () +#t +COMPOSE +(#<interpreted function ???> 12 75) ==> 30 +#t +(#<procedure MAP> #<procedure CXXR> ((A B) (D E) (G H))) ==> (B E H) +#t +(#<procedure MAP> #<procedure ADD> (1 2 3) (4 5 6)) ==> (5 7 9) +#t +(FOR-EACH #(0 1 4 9 16)) ==> #(0 1 4 9 16) +#t +(#<procedure CALL_WITH_CURRENT_CONTINUATION> #<interpreted function ???>) ==> -3 +#t +LIST-LENGTH +(#<interpreted function LIST-LENGTH> (1 2 3 4)) ==> 4 +#t +(#<interpreted function LIST-LENGTH> (A B . C)) ==> #f +#t +(#<procedure MAP> #<procedure CXXR> ()) ==> () +#t +NEXT-LEAF-GENERATOR +LEAF-EQ? +TEST-CONT +TEST-DELAY +SECTION(6 10 1) +#t +(#<procedure INPUT_PORT_P> #<input &input>) ==> #t +#t +(#<procedure OUTPUT_PORT_P> #<output &output>) ==> #t +#t +(#<procedure CALL_WITH_INPUT_FILE> "test.scm" #<procedure INPUT_PORT_P>) ==> #t +#t +THIS-FILE +(#<procedure INPUT_PORT_P> #<input file(test.scm)>) ==> #t +#t +SECTION(6 10 2) +#t +(#<procedure PEEK_CHAR> #<input file(test.scm)>) ==> #\; +#t +(#<procedure READ_CHAR> #<input file(test.scm)>) ==> #\; +#t +(#<procedure READ> #<input file(test.scm)>) ==> (DEFINE CUR-SECTION (QUOTE ())) +#t +(#<procedure PEEK_CHAR> #<input file(test.scm)>) ==> #\( +#t +(#<procedure READ> #<input file(test.scm)>) ==> (DEFINE ERRS (QUOTE ())) +#t +#<input file(test.scm)> +#<input file(test.scm)> +CHECK-TEST-FILE +SECTION(6 10 3) +#t +WRITE-TEST-OBJ +DISPLAY-TEST-OBJ +LOAD-TEST-OBJ +(#<procedure CALL_WITH_OUTPUT_FILE> "tmp1" #<interpreted function ???>) ==> #t +#t +(#<procedure READ> #<input file(tmp1)>) ==> (DEFINE FOO (QUOTE (#t #f #\a () 9739 -3 . #((TEST) "te \" \" st" "" TEST #() B C)))) +(#<procedure EOF_OBJECT_P> #<eof>) ==> #t +(#<procedure EOF_OBJECT_P> #<eof>) ==> #t +(INPUT-PORT? #t) ==> #t +(#<procedure READ_CHAR> #<input file(tmp1)>) ==> #\; +(#<procedure READ> #<input file(tmp1)>) ==> (#t #f A () 9739 -3 . #((TEST) TE " " ST TEST #() B C)) +(#<procedure READ> #<input file(tmp1)>) ==> (DEFINE FOO (QUOTE (#t #f #\a () 9739 -3 . #((TEST) "te \" \" st" "" TEST #() B C)))) +#<input file(tmp1)> +TEST-FILE +#<output file(tmp2)> +#<output file(tmp2)> +#<output file(tmp2)> +#<output file(tmp2)> +(#<procedure OUTPUT_PORT_P> #<output file(tmp2)>) ==> #t +#t +#<output file(tmp2)> +(#<procedure READ> #<input file(tmp2)>) ==> (DEFINE FOO (QUOTE (#t #f #\a () 9739 -3 . #((TEST) "te \" \" st" "" TEST #() B C)))) +(#<procedure EOF_OBJECT_P> #<eof>) ==> #t +(#<procedure EOF_OBJECT_P> #<eof>) ==> #t +(INPUT-PORT? #t) ==> #t +(#<procedure READ_CHAR> #<input file(tmp2)>) ==> #\; +(#<procedure READ> #<input file(tmp2)>) ==> (#t #f A () 9739 -3 . #((TEST) TE " " ST TEST #() B C)) +(#<procedure READ> #<input file(tmp2)>) ==> (DEFINE FOO (QUOTE (#t #f #\a () 9739 -3 . #((TEST) "te \" \" st" "" TEST #() B C)))) +#<input file(tmp2)> +TEST-SC4 + +Passed all tests +#<output &output> + +;testing inexact numbers; +SECTION(6 5 5) +(#<procedure INEXACT_P> 3.9) ==> #t +(INEXACT? #t) ==> #t +(MAX 4.0) ==> 4.0 +(EXACT->INEXACT 4.0) ==> 4.0 +(#<procedure ROUND> -4.5) ==> -4.0 +(#<procedure ROUND> -3.5) ==> -4.0 +(#<procedure ROUND> -3.9) ==> -4.0 +(#<procedure ROUND> 0.0) ==> 0.0 +(#<procedure ROUND> 0.25) ==> 0.0 +(#<procedure ROUND> 0.8) ==> 1.0 +(#<procedure ROUND> 3.5) ==> 4.0 +(#<procedure ROUND> 4.5) ==> 4.0 +(#<procedure CALL_WITH_OUTPUT_FILE> "tmp3" #<interpreted function ???>) ==> #t +(#<procedure READ> #<input file(tmp3)>) ==> (DEFINE FOO (QUOTE (0.25 -3.25))) +(#<procedure EOF_OBJECT_P> #<eof>) ==> #t +(#<procedure EOF_OBJECT_P> #<eof>) ==> #t +(INPUT-PORT? #t) ==> #t +(#<procedure READ_CHAR> #<input file(tmp3)>) ==> #\; +(#<procedure READ> #<input file(tmp3)>) ==> (0.25 -3.25) +(#<procedure READ> #<input file(tmp3)>) ==> (DEFINE FOO (QUOTE (0.25 -3.25))) +(PENTIUM-FDIV-BUG #t) ==> #t + +Passed all tests +#<output &output> + +;testing bignums; +SECTION(6 5 5) +(#<procedure MODULO> -2177452800 86400) ==> 0 +(#<procedure MODULO> 2177452800 -86400) ==> 0 +(#<procedure MODULO> 2177452800 86400) ==> 0 +(#<procedure MODULO> -2177452800 -86400) ==> 0 +(REMAINDER #t) ==> #t +(REMAINDER #t) ==> #t +SECTION(6 5 6) +(#<procedure STRING_2_NUMBER> "281474976710655") ==> 281474976710655 +(#<procedure NUMBER_2_STRING> 281474976710655) ==> "281474976710655" + +Passed all tests +#<output &output> + +#<output &output> +To fully test continuations, Scheme 4, and DELAY/FORCE do:#<output &output> + +#<output &output> +(test-cont) (test-sc4) (test-delay)#<output &output> + +#<output &output> +"last item in file" |