Skip to content
This repository has been archived by the owner on Mar 26, 2024. It is now read-only.

Many tests failing on OS X #306

Closed
JeNeSuisPasDave opened this issue Sep 5, 2015 · 2 comments
Closed

Many tests failing on OS X #306

JeNeSuisPasDave opened this issue Sep 5, 2015 · 2 comments

Comments

@JeNeSuisPasDave
Copy link

Lots of tests failing on my OS X 10.9.5 system.

Also any REPL command generates "error: uninitialized global variable".

Just search for FAIL in these test results:

bin/picrin contrib/10.macro/t/ir-macro.scm
case 0�[0;32m PASS: (aif (member 'b '(a b c)) (car it) #f) equals b�[0;39m
case 1�[0;32m PASS: (let ((if 42)) (mif 1 2 3)) equals 2�[0;39m
case 2�[0;32m PASS: (let ((it 42)) (mif 1 it 2)) equals 42�[0;39m
case 3�[0;32m PASS: (mif 'a 'b 'c) equals b�[0;39m
case 4�[0;32m PASS: (loop (if (= a 2) (exit #f)) (set! a 2)) equals #f�[0;39m
case 5�[0;32m PASS: (loop (define a 1) (if (= a 1) (exit #f))) equals #f�[0;39m

�[0;34mTest Result: 6 / 6 (100%) [PASS/TOTAL]�[0;39m
for test in `ls contrib/20.r7rs/t/*.scm`; do \
      bin/picrin "$test"; \
    done
case 0�[0;32m PASS: (cond-expand (r7rs #t) (else #f)) equals #t�[0;39m
case 1�[0;32m PASS: (cond-expand ((library (scheme write)) #t) (else #f)) equals #t�[0;39m
case 2�[0;32m PASS: (cond-expand ((not r6rs) #t) (else #f)) equals #t�[0;39m
case 3�[0;32m PASS: (cond-expand ((and r7rs (library (picrin test))) #t) (else #f)) equals #t�[0;39m
case 4�[0;32m PASS: (cond-expand ((or r6rs r7rs) #t) (else #f)) equals #t�[0;39m
case 5�[0;32m PASS: #t equals #t�[0;39m
case 6�[0;32m PASS: #t equals #t�[0;39m
case 7�[0;32m PASS: #t equals #t�[0;39m
case 8�[0;32m PASS: #t equals #t�[0;39m
case 9�[0;32m PASS: #t equals #t�[0;39m
case 10�[0;32m PASS: x equals 28�[0;39m
case 11�[0;32m PASS: 'a equals a�[0;39m
case 12�[0;32m PASS: '#(a b c) equals #(a b c)�[0;39m
case 13�[0;32m PASS: '(+ 1 2) equals (+ 1 2)�[0;39m
case 14�[0;32m PASS: 'a equals a�[0;39m
case 15�[0;32m PASS: '#(a b c) equals #(a b c)�[0;39m
case 16�[0;32m PASS: '() equals ()�[0;39m
case 17�[0;32m PASS: '(+ 1 2) equals (+ 1 2)�[0;39m
case 18�[0;32m PASS: ''a equals 'a�[0;39m
case 19�[0;32m PASS: ''a equals 'a�[0;39m
case 20�[0;32m PASS: '"abc" equals "abc"�[0;39m
case 21�[0;32m PASS: "abc" equals "abc"�[0;39m
case 22�[0;32m PASS: '145932 equals 145932�[0;39m
case 23�[0;32m PASS: 145932 equals 145932�[0;39m
case 24�[0;32m PASS: '#t equals #t�[0;39m
case 25�[0;32m PASS: #t equals #t�[0;39m
case 26�[0;32m PASS: (+ 3 4) equals 7�[0;39m
case 27�[0;32m PASS: ((if #f + *) 3 4) equals 12�[0;39m
case 28�[0;32m PASS: ((lambda (x) (+ x x)) 4) equals 8�[0;39m
case 29�[0;32m PASS: (reverse-subtract 7 10) equals 3�[0;39m
case 30�[0;32m PASS: (add4 6) equals 10�[0;39m
case 31�[0;32m PASS: ((lambda x x) 3 4 5 6) equals (3 4 5 6)�[0;39m
case 32�[0;32m PASS: ((lambda (x y . z) z) 3 4 5 6) equals (5 6)�[0;39m
case 33�[0;32m PASS: (if (> 3 2) 'yes 'no) equals yes�[0;39m
case 34�[0;32m PASS: (if (> 2 3) 'yes 'no) equals no�[0;39m
case 35�[0;32m PASS: (if (> 3 2) (- 3 2) (+ 3 2)) equals 1�[0;39m
case 36�[0;32m PASS: (+ x 1) equals 3�[0;39m
case 37�[0;32m PASS: (cond ((> 3 2) 'greater) ((< 3 2) 'less)) equals greater�[0;39m
case 38�[0;32m PASS: (cond ((> 3 3) 'greater) ((< 3 3) 'less) (else 'equal)) equals equal�[0;39m
case 39�[0;32m PASS: (cond ((assv 'b '((a 1) (b 2))) => cadr) (else #f)) equals 2�[0;39m
case 40�[0;32m PASS: (case (* 2 3) ((2 3 5 7) 'prime) ((1 4 6 8 9) 'composite)) equals composite�[0;39m
case 41�[0;32m PASS: (case (car '(c d)) ((a e i o u) 'vowel) ((w y) 'semivowel) (else => (lambda (x) x))) equals c�[0;39m
case 42�[0;32m PASS: (map (lambda (x) (case x ((a e i o u) => (lambda (w) (cons 'vowel w))) ((w y) (cons 'semivowel x)) (else => (lambda (w) (cons 'other w))))) '(z y x w u)) equals ((other . z) (semivowel . y) (other . x) (semivowel . w) (vowel . u))�[0;39m
case 43�[0;32m PASS: (and (= 2 2) (> 2 1)) equals #t�[0;39m
case 44�[0;32m PASS: (and (= 2 2) (< 2 1)) equals #f�[0;39m
case 45�[0;32m PASS: (and 1 2 'c '(f g)) equals (f g)�[0;39m
case 46�[0;32m PASS: (and) equals #t�[0;39m
case 47�[0;32m PASS: (or (= 2 2) (> 2 1)) equals #t�[0;39m
case 48�[0;32m PASS: (or (= 2 2) (< 2 1)) equals #t�[0;39m
case 49�[0;32m PASS: (or #f #f #f) equals #f�[0;39m
case 50�[0;32m PASS: (or (memq 'b '(a b c)) (/ 3 0)) equals (b c)�[0;39m
case 51�[0;32m PASS: (let ((x 2) (y 3)) (* x y)) equals 6�[0;39m
case 52�[0;32m PASS: (let ((x 2) (y 3)) (let ((x 7) (z (+ x y))) (* z x))) equals 35�[0;39m
case 53�[0;32m PASS: (let ((x 2) (y 3)) (let* ((x 7) (z (+ x y))) (* z x))) equals 70�[0;39m
case 54�[0;32m PASS: (letrec ((even? (lambda (n) (if (zero? n) #t (odd? (- n 1))))) (odd? (lambda (n) (if (zero? n) #f (even? (- n 1)))))) (even? 88)) equals #t�[0;39m
case 55�[0;32m PASS: (letrec* ((p (lambda (x) (+ 1 (q (- x 1))))) (q (lambda (y) (if (zero? y) 0 (+ 1 (p (- y 1)))))) (x (p 5)) (y x)) y) equals 5�[0;39m
case 56�[0;32m PASS: a equals 27�[0;39m
case 57�[0;32m PASS: b equals 9.728�[0;39m
case 58�[0;32m PASS: c equals 3.62173�[0;39m
case 59�[0;32m PASS: (* root rem) equals 35�[0;39m
case 60�[0;32m PASS: (let ((a 'a) (b 'b) (x 'x) (y 'y)) (let*-values (((a b) (values x y)) ((x y) (values a b))) (list a b x y))) equals (x y x y)�[0;39m
case 61�[0;32m PASS: (+ x 1) equals 6�[0;39m
case 62�[0;32m PASS: (do ((vec (make-vector 5)) (i 0 (+ i 1))) ((= i 5) vec) (vector-set! vec i i)) equals #(0 1 2 3 4)�[0;39m
case 63�[0;32m PASS: (let ((x '(1 3 5 7 9))) (do ((x x (cdr x)) (sum 0 (+ sum (car x)))) ((null? x) sum))) equals 25�[0;39m
case 64�[0;32m PASS: (let loop ((numbers '(3 -2 1 6 -5)) (nonneg '()) (neg '())) (cond ((null? numbers) (list nonneg neg)) ((>= (car numbers) 0) (loop (cdr numbers) (cons (car numbers) nonneg) neg)) ((< (car numbers) 0) (loop (cdr numbers) nonneg (cons (car numbers) neg))))) equals ((6 1 3) (-5 -2))�[0;39m
case 65�[0;32m PASS: (force (delay (+ 1 2))) equals 3�[0;39m
case 66�[0;32m PASS: (let ((p (delay (+ 1 2)))) (list (force p) (force p))) equals (3 3)�[0;39m
case 67�[0;32m PASS: (head (tail (tail integers))) equals 2�[0;39m
case 68�[0;32m PASS: (head (tail (tail (stream-filter odd? integers)))) equals 5�[0;39m
case 69�[0;32m PASS: (force p) equals 6�[0;39m
case 70�[0;32m PASS: (begin (set! x 10) (force p)) equals 6�[0;39m
case 71�[0;32m PASS: (promise? (delay (+ 2 2))) equals #t�[0;39m
case 72�[0;32m PASS: (promise? (make-promise (+ 2 2))) equals #t�[0;39m
case 73�[0;32m PASS: (let ((x (delay (+ 2 2)))) (force x) (promise? x)) equals #t�[0;39m
case 74�[0;32m PASS: (let ((x (make-promise (+ 2 2)))) (force x) (promise? x)) equals #t�[0;39m
case 75�[0;32m PASS: (f 12) equals "12"�[0;39m
case 76�[0;32m PASS: (parameterize ((radix 2)) (f 12)) equals "1100"�[0;39m
case 77�[0;32m PASS: (f 12) equals "12"�[0;39m
case 78�[0;32m PASS: `(list ,(+ 1 2) 4) equals (list 3 4)�[0;39m
case 79�[0;32m PASS: `(list ,name ',name) equals (list a 'a)�[0;39m
case 80�[0;32m PASS: `(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b) equals (a 3 4 5 6 b)�[0;39m
case 81�[0;32m PASS: `#(10 5 ,(square 2) ,@(map square '(4 3)) 8) equals #(10 5 4 16 9 8)�[0;39m
case 82 �[0;31mFAIL: `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)
   expected (a `(b ,(+ 1 2) ,(foo 4 d) e) f) but got (a (#<identifier quasiquote> (b (#<identifier unquote> (+ 1 2)) (#<identifier unquote> (foo 4 d)) e)) f)�[0;39m
case 83 �[0;31mFAIL: `(a `(b ,,name1 ,',name2 d) e)
   expected (a `(b ,x ,'y d) e) but got (a (#<identifier quasiquote> (b (#<identifier unquote> x) (#<identifier unquote> 'y) d)) e)�[0;39m
case 84�[0;32m PASS: `(list ,(+ 1 2) 4) equals (list 3 4)�[0;39m
case 85�[0;32m PASS: `(list ,(+ 1 2) 4) equals (list 3 4)�[0;39m
case 86�[0;32m PASS: (plus) equals 0�[0;39m
case 87�[0;32m PASS: (plus 1) equals 1�[0;39m
case 88�[0;32m PASS: (plus 1 2) equals 3�[0;39m
case 89�[0;32m PASS: (plus 1 2 3) equals 6�[0;39m
case 90�[0;32m PASS: (plus 1 2 3 4) equals 10�[0;39m
case 91�[0;32m PASS: (mult) equals 1�[0;39m
case 92�[0;32m PASS: (mult 1) equals 1�[0;39m
case 93�[0;32m PASS: (mult 1 2) equals 2�[0;39m
case 94�[0;32m PASS: (mult 1 2 3) equals 6�[0;39m
case 95�[0;32m PASS: (mult 1 2 3 4) equals 24�[0;39m
case 96�[0;32m PASS: (let-syntax ((when (syntax-rules () ((when test stmt1 stmt2 ...) (if test (begin stmt1 stmt2 ...)))))) (let ((if #t)) (when if (set! if 'now)) if)) equals now�[0;39m
case 97�[0;32m PASS: (let ((x 'outer)) (let-syntax ((m (syntax-rules () ((m) x)))) (let ((x 'inner)) (m)))) equals outer�[0;39m
case 98�[0;32m PASS: (letrec-syntax ((my-or (syntax-rules () ((my-or) #f) ((my-or e) e) ((my-or e1 e2 ...) (let ((temp e1)) (if temp temp (my-or e2 ...))))))) (let ((x #f) (y 7) (temp 8) (let odd?) (if even?)) (my-or x (let temp) (if y) y))) equals 7�[0;39m
case 99�[0;32m PASS: (sequence 1 2 3 4) equals 4�[0;39m
case 100�[0;32m PASS: (mad-hatter) equals 42�[0;39m
case 101�[0;32m PASS: (let ((=> #f)) (cond (#t => 'ok))) equals ok�[0;39m
case 102�[0;32m PASS: (add3 3) equals 6�[0;39m
case 103�[0;32m PASS: (first '(1 2)) equals 1�[0;39m
case 104�[0;32m PASS: (let ((x 5)) (define foo (lambda (y) (bar x y))) (define bar (lambda (a b) (+ (* a b) a))) (foo (+ x 3))) equals 45�[0;39m
case 105�[0;32m PASS: (let () (define-values () (values)) 'ok) equals ok�[0;39m
case 106�[0;32m PASS: (let () (define-values (x) (values 1)) x) equals 1�[0;39m
case 107�[0;32m PASS: (let () (define-values x (values 1 2)) (apply + x)) equals 3�[0;39m
case 108�[0;32m PASS: (let () (define-values (x y) (values 1 2)) (+ x y)) equals 3�[0;39m
case 109�[0;32m PASS: (let () (define-values (x y z) (values 1 2 3)) (+ x y z)) equals 6�[0;39m
case 110�[0;32m PASS: (let () (define-values (x y . z) (values 1 2 3 4)) (+ x y (car z) (cadr z))) equals 10�[0;39m
case 111�[0;32m PASS: (let ((x 1) (y 2)) (define-syntax swap! (syntax-rules () ((swap! a b) (let ((tmp a)) (set! a b) (set! b tmp))))) (swap! x y) (list x y)) equals (2 1)�[0;39m
case 112�[0;32m PASS: (pare? (kons 1 2)) equals #t�[0;39m
case 113�[0;32m PASS: (pare? (cons 1 2)) equals #f�[0;39m
case 114�[0;32m PASS: (kar (kons 1 2)) equals 1�[0;39m
case 115�[0;32m PASS: (kdr (kons 1 2)) equals 2�[0;39m
case 116�[0;32m PASS: (let ((k (kons 1 2))) (set-kar! k 3) (kar k)) equals 3�[0;39m
case 117�[0;32m PASS: (eqv? 'a 'a) equals #t�[0;39m
case 118�[0;32m PASS: (eqv? 'a 'b) equals #f�[0;39m
case 119�[0;32m PASS: (eqv? 2 2) equals #t�[0;39m
case 120�[0;32m PASS: (eqv? '() '()) equals #t�[0;39m
case 121�[0;32m PASS: (eqv? 100000000 100000000) equals #t�[0;39m
case 122�[0;32m PASS: (eqv? (cons 1 2) (cons 1 2)) equals #f�[0;39m
case 123�[0;32m PASS: (eqv? (lambda () 1) (lambda () 2)) equals #f�[0;39m
case 124�[0;32m PASS: (eqv? #f 'nil) equals #f�[0;39m
case 125�[0;32m PASS: (let ((g (gen-counter))) (eqv? g g)) equals #t�[0;39m
case 126�[0;32m PASS: (eqv? (gen-counter) (gen-counter)) equals #f�[0;39m
case 127�[0;32m PASS: (let ((g (gen-loser))) (eqv? g g)) equals #t�[0;39m
case 128�[0;32m PASS: (letrec ((f (lambda () (if (eqv? f g) 'f 'both))) (g (lambda () (if (eqv? f g) 'g 'both)))) (eqv? f g)) equals #f�[0;39m
case 129�[0;32m PASS: (let ((x '(a))) (eqv? x x)) equals #t�[0;39m
case 130�[0;32m PASS: (eq? 'a 'a) equals #t�[0;39m
case 131�[0;32m PASS: (eq? (list 'a) (list 'a)) equals #f�[0;39m
case 132�[0;32m PASS: (eq? '() '()) equals #t�[0;39m
case 133�[0;32m PASS: (let ((x '(a))) (eq? x x)) equals #t�[0;39m
case 134�[0;32m PASS: (let ((x '#())) (eq? x x)) equals #t�[0;39m
case 135�[0;32m PASS: (let ((p (lambda (x) x))) (eq? p p)) equals #t�[0;39m
case 136�[0;32m PASS: (equal? 'a 'a) equals #t�[0;39m
case 137�[0;32m PASS: (equal? '(a) '(a)) equals #t�[0;39m
case 138�[0;32m PASS: (equal? '(a (b) c) '(a (b) c)) equals #t�[0;39m
case 139�[0;32m PASS: (equal? "abc" "abc") equals #t�[0;39m
case 140�[0;32m PASS: (equal? 2 2) equals #t�[0;39m
case 141�[0;32m PASS: (equal? (make-vector 5 'a) (make-vector 5 'a)) equals #t�[0;39m
case 142�[0;32m PASS: (equal? l m) equals #t�[0;39m
case 143�[0;32m PASS: (equal? l m) equals #f�[0;39m
case 144�[0;32m PASS: (equal? v w) equals #t�[0;39m
case 145�[0;32m PASS: (equal? v w) equals #f�[0;39m
case 146�[0;32m PASS: (equal? v w) equals #t�[0;39m
case 147�[0;32m PASS: (equal? v w) equals #f�[0;39m
case 148�[0;32m PASS: (complex? 3) equals #t�[0;39m
case 149�[0;32m PASS: (real? 3) equals #t�[0;39m
case 150�[0;32m PASS: (real? +inf.0) equals #t�[0;39m
case 151�[0;32m PASS: (integer? 3) equals #t�[0;39m
case 152�[0;32m PASS: (exact? 3) equals #f�[0;39m
case 153�[0;32m PASS: (exact-integer? 32) equals #t�[0;39m
case 154�[0;32m PASS: (exact-integer? 32) equals #f�[0;39m
case 155�[0;32m PASS: (finite? 3) equals #t�[0;39m
case 156�[0;32m PASS: (finite? +inf.0) equals #f�[0;39m
case 157�[0;32m PASS: (infinite? 3) equals #f�[0;39m
case 158�[0;32m PASS: (infinite? +inf.0) equals #t�[0;39m
case 159�[0;32m PASS: (infinite? +nan.0) equals #f�[0;39m
case 160�[0;32m PASS: (nan? +nan.0) equals #t�[0;39m
case 161�[0;32m PASS: (nan? 32) equals #f�[0;39m
case 162�[0;32m PASS: (< 1 2 3) equals #t�[0;39m
case 163�[0;32m PASS: (< 1 1 2) equals #f�[0;39m
case 164�[0;32m PASS: (> 3 2 1) equals #t�[0;39m
case 165�[0;32m PASS: (> -3 2 1) equals #f�[0;39m
case 166�[0;32m PASS: (<= 1 1 2) equals #t�[0;39m
case 167�[0;32m PASS: (<= 1 2 1) equals #f�[0;39m
case 168�[0;32m PASS: (>= 2 1 1) equals #t�[0;39m
case 169�[0;32m PASS: (>= 1 2 1) equals #f�[0;39m
case 170�[0;32m PASS: (if (and (= a b) (= b c)) (= a c) #t) equals #t�[0;39m
case 171�[0;32m PASS: (if (and (<= a j) (< j (+ j 1))) (not (<= (+ j 1) a)) #t) equals #t�[0;39m
case 172�[0;32m PASS: (zero? 0) equals #t�[0;39m
case 173�[0;32m PASS: (zero? 0) equals #t�[0;39m
case 174�[0;32m PASS: (zero? 1) equals #f�[0;39m
case 175�[0;32m PASS: (zero? -1) equals #f�[0;39m
case 176�[0;32m PASS: (positive? 0) equals #f�[0;39m
case 177�[0;32m PASS: (positive? 0) equals #f�[0;39m
case 178�[0;32m PASS: (positive? 1) equals #t�[0;39m
case 179�[0;32m PASS: (positive? 1) equals #t�[0;39m
case 180�[0;32m PASS: (positive? -1) equals #f�[0;39m
case 181�[0;32m PASS: (positive? -1) equals #f�[0;39m
case 182�[0;32m PASS: (positive? +inf.0) equals #t�[0;39m
case 183�[0;32m PASS: (positive? -inf.0) equals #f�[0;39m
case 184�[0;32m PASS: (negative? 0) equals #f�[0;39m
case 185�[0;32m PASS: (negative? 0) equals #f�[0;39m
case 186�[0;32m PASS: (negative? 1) equals #f�[0;39m
case 187�[0;32m PASS: (negative? 1) equals #f�[0;39m
case 188�[0;32m PASS: (negative? -1) equals #t�[0;39m
case 189�[0;32m PASS: (negative? -1) equals #t�[0;39m
case 190�[0;32m PASS: (negative? +inf.0) equals #f�[0;39m
case 191�[0;32m PASS: (negative? -inf.0) equals #t�[0;39m
case 192�[0;32m PASS: (odd? 0) equals #f�[0;39m
case 193�[0;32m PASS: (odd? 1) equals #t�[0;39m
case 194�[0;32m PASS: (odd? -1) equals #t�[0;39m
case 195�[0;32m PASS: (odd? 102) equals #f�[0;39m
case 196�[0;32m PASS: (even? 0) equals #t�[0;39m
case 197�[0;32m PASS: (even? 1) equals #f�[0;39m
case 198�[0;32m PASS: (even? -2) equals #t�[0;39m
case 199�[0;32m PASS: (even? 102) equals #t�[0;39m
case 200�[0;32m PASS: (max 3) equals 3�[0;39m
case 201�[0;32m PASS: (max 3 4) equals 4�[0;39m
case 202�[0;32m PASS: (max 3.9 4) equals 4�[0;39m
case 203�[0;32m PASS: (max 5 3.9 4) equals 5�[0;39m
case 204�[0;32m PASS: (max 100 +inf.0) equals +inf.0�[0;39m
case 205�[0;32m PASS: (min 3) equals 3�[0;39m
case 206�[0;32m PASS: (min 3 4) equals 3�[0;39m
case 207�[0;32m PASS: (min 3 3.1) equals 3�[0;39m
case 208�[0;32m PASS: (min -inf.0 -100) equals -inf.0�[0;39m
case 209�[0;32m PASS: (+ 3 4) equals 7�[0;39m
case 210�[0;32m PASS: (+ 3) equals 3�[0;39m
case 211�[0;32m PASS: (+) equals 0�[0;39m
case 212�[0;32m PASS: (* 4) equals 4�[0;39m
case 213�[0;32m PASS: (*) equals 1�[0;39m
case 214�[0;32m PASS: (- 3 4) equals -1�[0;39m
case 215�[0;32m PASS: (- 3 4 5) equals -6�[0;39m
case 216�[0;32m PASS: (- 3) equals -3�[0;39m
case 217�[0;32m PASS: (abs -7) equals 7�[0;39m
case 218�[0;32m PASS: (abs 7) equals 7�[0;39m
case 219�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (floor/ 5 2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (2 1)�[0;39m
case 220�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (floor/ -5 2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (-3 1)�[0;39m
case 221�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (floor/ 5 -2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (-3 -1)�[0;39m
case 222�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (floor/ -5 -2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (2 -1)�[0;39m
case 223�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (truncate/ 5 2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (2 1)�[0;39m
case 224�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (truncate/ -5 2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (-2 -1)�[0;39m
case 225�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (truncate/ 5 -2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (-2 1)�[0;39m
case 226�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (truncate/ -5 -2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (2 -1)�[0;39m
case 227�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (truncate/ -5 -2)) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (2 -1)�[0;39m
case 228�[0;32m PASS: (modulo 13 4) equals 1�[0;39m
case 229�[0;32m PASS: (remainder 13 4) equals 1�[0;39m
case 230�[0;32m PASS: (modulo -13 4) equals 3�[0;39m
case 231�[0;32m PASS: (remainder -13 4) equals -1�[0;39m
case 232�[0;32m PASS: (modulo 13 -4) equals -3�[0;39m
case 233�[0;32m PASS: (remainder 13 -4) equals 1�[0;39m
case 234�[0;32m PASS: (modulo -13 -4) equals -1�[0;39m
case 235�[0;32m PASS: (remainder -13 -4) equals -1�[0;39m
case 236�[0;32m PASS: (remainder -13 -4) equals -1�[0;39m
case 237�[0;32m PASS: (gcd 32 -36) equals 4�[0;39m
case 238�[0;32m PASS: (gcd) equals 0�[0;39m
case 239�[0;32m PASS: (lcm 32 -36) equals 288�[0;39m
case 240�[0;32m PASS: (lcm 32 -36) equals 288�[0;39m
case 241�[0;32m PASS: (lcm) equals 1�[0;39m
case 242�[0;32m PASS: (floor -4.3) equals -5�[0;39m
case 243�[0;32m PASS: (ceiling -4.3) equals -4�[0;39m
case 244�[0;32m PASS: (truncate -4.3) equals -4�[0;39m
case 245�[0;32m PASS: (round -4.3) equals -4�[0;39m
case 246�[0;32m PASS: (floor 3.5) equals 3�[0;39m
case 247�[0;32m PASS: (ceiling 3.5) equals 4�[0;39m
case 248�[0;32m PASS: (truncate 3.5) equals 3�[0;39m
case 249�[0;32m PASS: (round 3.5) equals 4�[0;39m
case 250�[0;32m PASS: (round 7) equals 7�[0;39m
case 251�[0;32m PASS: (inexact (exp 0)) equals 1�[0;39m
case 252�[0;32m PASS: (exp 3) equals 20.0855�[0;39m
case 253�[0;32m PASS: (inexact (log 1)) equals 0�[0;39m
case 254�[0;32m PASS: (log (exp 1)) equals 1�[0;39m
case 255�[0;32m PASS: (log (exp 42)) equals 42�[0;39m
case 256�[0;32m PASS: (log 100 10) equals 2�[0;39m
case 257�[0;32m PASS: (log 4096 2) equals 12�[0;39m
case 258�[0;32m PASS: (inexact (sin 0)) equals 0�[0;39m
case 259�[0;32m PASS: (sin 1.5708) equals 1�[0;39m
case 260�[0;32m PASS: (inexact (cos 0)) equals 1�[0;39m
case 261�[0;32m PASS: (cos 3.14159) equals -1�[0;39m
case 262�[0;32m PASS: (inexact (tan 0)) equals 0�[0;39m
case 263 �[0;31mFAIL: (tan 1)
   expected 1.55741 but got 1.55741�[0;39m
case 264�[0;32m PASS: (asin 0) equals 0�[0;39m
case 265�[0;32m PASS: (asin 1) equals 1.5708�[0;39m
case 266�[0;32m PASS: (acos 1) equals 0�[0;39m
case 267�[0;32m PASS: (acos -1) equals 3.14159�[0;39m
case 268�[0;32m PASS: (atan 0 1) equals 0�[0;39m
case 269�[0;32m PASS: (atan -0 1) equals -0�[0;39m
case 270�[0;32m PASS: (atan 1 1) equals 0.785398�[0;39m
case 271�[0;32m PASS: (atan 1 0) equals 1.5708�[0;39m
case 272�[0;32m PASS: (atan 1 -1) equals 2.35619�[0;39m
case 273�[0;32m PASS: (atan 0 -1) equals 3.14159�[0;39m
case 274�[0;32m PASS: (atan -0 -1) equals -3.14159�[0;39m
case 275�[0;32m PASS: (atan -1 -1) equals -2.35619�[0;39m
case 276�[0;32m PASS: (atan -1 0) equals -1.5708�[0;39m
case 277�[0;32m PASS: (atan -1 1) equals -0.785398�[0;39m
case 278�[0;32m PASS: (square 42) equals 1764�[0;39m
case 279�[0;32m PASS: (square 2) equals 4�[0;39m
case 280�[0;32m PASS: (inexact (sqrt 9)) equals 3�[0;39m
case 281�[0;32m PASS: (sqrt 2) equals 1.41421�[0;39m
case 282�[0;32m PASS: (call-with-values (lambda () (exact-integer-sqrt 4)) list) equals (2 0)�[0;39m
case 283�[0;32m PASS: (call-with-values (lambda () (exact-integer-sqrt 5)) list) equals (2 1)�[0;39m
case 284�[0;32m PASS: (expt 3 3) equals 27�[0;39m
case 285�[0;32m PASS: (expt 0 0) equals 1�[0;39m
case 286�[0;32m PASS: (expt 0 1) equals 0�[0;39m
case 287�[0;32m PASS: (expt 0 0) equals 1�[0;39m
case 288�[0;32m PASS: (expt 0 1) equals 0�[0;39m
case 289�[0;32m PASS: (inexact 1) equals 1�[0;39m
case 290�[0;32m PASS: (inexact? (inexact 1)) equals #t�[0;39m
case 291�[0;32m PASS: (exact 1) equals 1�[0;39m
case 292�[0;32m PASS: (exact? (exact 1)) equals #t�[0;39m
case 293�[0;32m PASS: (number->string 10) equals "10"�[0;39m
case 294�[0;32m PASS: (number->string 10 10) equals "10"�[0;39m
case 295�[0;32m PASS: (number->string 2 2) equals "10"�[0;39m
case 296�[0;32m PASS: (number->string 8 8) equals "10"�[0;39m
case 297�[0;32m PASS: (number->string 16 16) equals "10"�[0;39m
case 298�[0;32m PASS: (number->string 2.3) equals "2.3"�[0;39m
case 299�[0;32m PASS: (number->string 2.3) equals "2.3"�[0;39m
case 300�[0;32m PASS: (number->string 2.301) equals "2.301"�[0;39m
case 301�[0;32m PASS: (string->number "100") equals 100�[0;39m
case 302�[0;32m PASS: (string->number "100" 16) equals 256�[0;39m
case 303 �[0;31mFAIL: (string->number "1e2")
   expected 100 but got 100�[0;39m
case 304�[0;32m PASS: #t equals #t�[0;39m
case 305�[0;32m PASS: #f equals #f�[0;39m
case 306�[0;32m PASS: '#f equals #f�[0;39m
case 307�[0;32m PASS: (not #t) equals #f�[0;39m
case 308�[0;32m PASS: (not 3) equals #f�[0;39m
case 309�[0;32m PASS: (not (list 3)) equals #f�[0;39m
case 310�[0;32m PASS: (not #f) equals #t�[0;39m
case 311�[0;32m PASS: (not '()) equals #f�[0;39m
case 312�[0;32m PASS: (not (list)) equals #f�[0;39m
case 313�[0;32m PASS: (not 'nil) equals #f�[0;39m
case 314�[0;32m PASS: (boolean? #f) equals #t�[0;39m
case 315�[0;32m PASS: (boolean? 0) equals #f�[0;39m
case 316�[0;32m PASS: (boolean? '()) equals #f�[0;39m
case 317�[0;32m PASS: (boolean=? #t #t) equals #t�[0;39m
case 318�[0;32m PASS: (boolean=? #f #f) equals #t�[0;39m
case 319�[0;32m PASS: (boolean=? #t #f) equals #f�[0;39m
case 320�[0;32m PASS: (boolean=? #f #f #f) equals #t�[0;39m
case 321�[0;32m PASS: (boolean=? #t #t #f) equals #f�[0;39m
case 322�[0;32m PASS: (values y) equals (a b c)�[0;39m
case 323�[0;32m PASS: (list? y) equals #t�[0;39m
case 324�[0;32m PASS: (values x) equals (a . 4)�[0;39m
case 325�[0;32m PASS: (eqv? x y) equals #t�[0;39m
case 326�[0;32m PASS: (list? y) equals #f�[0;39m
case 327�[0;32m PASS: (list? x) equals #f�[0;39m
case 328�[0;32m PASS: (pair? '(a . b)) equals #t�[0;39m
case 329�[0;32m PASS: (pair? '(a b c)) equals #t�[0;39m
case 330�[0;32m PASS: (pair? '()) equals #f�[0;39m
case 331�[0;32m PASS: (pair? '#(a b)) equals #f�[0;39m
case 332�[0;32m PASS: (cons 'a '()) equals (a)�[0;39m
case 333�[0;32m PASS: (cons '(a) '(b c d)) equals ((a) b c d)�[0;39m
case 334�[0;32m PASS: (cons "a" '(b c)) equals ("a" b c)�[0;39m
case 335�[0;32m PASS: (cons 'a 3) equals (a . 3)�[0;39m
case 336�[0;32m PASS: (cons '(a b) 'c) equals ((a b) . c)�[0;39m
case 337�[0;32m PASS: (car '(a b c)) equals a�[0;39m
case 338�[0;32m PASS: (car '((a) b c d)) equals (a)�[0;39m
case 339�[0;32m PASS: (car '(1 . 2)) equals 1�[0;39m
case 340�[0;32m PASS: (cdr '((a) b c d)) equals (b c d)�[0;39m
case 341�[0;32m PASS: (cdr '(1 . 2)) equals 2�[0;39m
case 342�[0;32m PASS: (list? '(a b c)) equals #t�[0;39m
case 343�[0;32m PASS: (list? '()) equals #t�[0;39m
case 344�[0;32m PASS: (list? '(a . b)) equals #f�[0;39m
case 345�[0;32m PASS: (let ((x (list 'a))) (set-cdr! x x) (list? x)) equals #f�[0;39m
case 346�[0;32m PASS: (make-list 2 3) equals (3 3)�[0;39m
case 347�[0;32m PASS: (list 'a (+ 3 4) 'c) equals (a 7 c)�[0;39m
case 348�[0;32m PASS: (list) equals ()�[0;39m
case 349�[0;32m PASS: (length '(a b c)) equals 3�[0;39m
case 350�[0;32m PASS: (length '(a (b) (c d e))) equals 3�[0;39m
case 351�[0;32m PASS: (length '()) equals 0�[0;39m
case 352�[0;32m PASS: (append '(x) '(y)) equals (x y)�[0;39m
case 353�[0;32m PASS: (append '(a) '(b c d)) equals (a b c d)�[0;39m
case 354�[0;32m PASS: (append '(a (b)) '((c))) equals (a (b) (c))�[0;39m
case 355�[0;32m PASS: (append '(a b) '(c . d)) equals (a b c . d)�[0;39m
case 356�[0;32m PASS: (append '() 'a) equals a�[0;39m
case 357�[0;32m PASS: (reverse '(a b c)) equals (c b a)�[0;39m
case 358�[0;32m PASS: (reverse '(a (b c) d (e (f)))) equals ((e (f)) d (b c) a)�[0;39m
case 359�[0;32m PASS: (list-tail '(a b c d e) 3) equals (d e)�[0;39m
case 360�[0;32m PASS: (list-ref '(a b c d) 2) equals c�[0;39m
case 361�[0;32m PASS: (list-ref '(a b c d) (exact (round 1.8))) equals c�[0;39m
case 362�[0;32m PASS: (let ((lst (list 0 '(2 2 2 2) "Anna"))) (list-set! lst 1 '("Sue" "Sue")) lst) equals (0 ("Sue" "Sue") "Anna")�[0;39m
case 363�[0;32m PASS: (memq 'a '(a b c)) equals (a b c)�[0;39m
case 364�[0;32m PASS: (memq 'b '(a b c)) equals (b c)�[0;39m
case 365�[0;32m PASS: (memq 'a '(b c d)) equals #f�[0;39m
case 366�[0;32m PASS: (memq (list 'a) '(b (a) c)) equals #f�[0;39m
case 367�[0;32m PASS: (member (list 'a) '(b (a) c)) equals ((a) c)�[0;39m
case 368�[0;32m PASS: (memv 101 '(100 101 102)) equals (101 102)�[0;39m
case 369�[0;32m PASS: (assq 'a e) equals (a 1)�[0;39m
case 370�[0;32m PASS: (assq 'b e) equals (b 2)�[0;39m
case 371�[0;32m PASS: (assq 'd e) equals #f�[0;39m
case 372�[0;32m PASS: (assq (list 'a) '(((a)) ((b)) ((c)))) equals #f�[0;39m
case 373�[0;32m PASS: (assoc (list 'a) '(((a)) ((b)) ((c)))) equals ((a))�[0;39m
case 374�[0;32m PASS: (assoc 2 '((1 1) (2 4) (3 9)) =) equals (2 4)�[0;39m
case 375�[0;32m PASS: (assv 5 '((2 3) (5 7) (11 13))) equals (5 7)�[0;39m
case 376�[0;32m PASS: (list-copy '(1 2 3)) equals (1 2 3)�[0;39m
case 377�[0;32m PASS: (list-copy "foo") equals "foo"�[0;39m
case 378�[0;32m PASS: (list-copy '()) equals ()�[0;39m
case 379�[0;32m PASS: (list-copy '(3 . 4)) equals (3 . 4)�[0;39m
case 380�[0;32m PASS: (list-copy '(6 7 8 . 9)) equals (6 7 8 . 9)�[0;39m
case 381�[0;32m PASS: '((a b) (c d) e) equals ((a b) (c d) e)�[0;39m
case 382�[0;32m PASS: (eq? (car l1) (car l2)) equals #t�[0;39m
case 383�[0;32m PASS: (eq? (cadr l1) (cadr l2)) equals #t�[0;39m
case 384�[0;32m PASS: (eq? (cdr l1) (cdr l2)) equals #f�[0;39m
case 385�[0;32m PASS: (eq? (cddr l1) (cddr l2)) equals #f�[0;39m
case 386�[0;32m PASS: (symbol? 'foo) equals #t�[0;39m
case 387�[0;32m PASS: (symbol? (car '(a b))) equals #t�[0;39m
case 388�[0;32m PASS: (symbol? "bar") equals #f�[0;39m
case 389�[0;32m PASS: (symbol? 'nil) equals #t�[0;39m
case 390�[0;32m PASS: (symbol? '()) equals #f�[0;39m
case 391�[0;32m PASS: (symbol? #f) equals #f�[0;39m
case 392�[0;32m PASS: (symbol=? 'a 'a) equals #t�[0;39m
case 393�[0;32m PASS: (symbol=? 'a 'A) equals #f�[0;39m
case 394�[0;32m PASS: (symbol=? 'a 'a 'a) equals #t�[0;39m
case 395�[0;32m PASS: (symbol=? 'a 'a 'A) equals #f�[0;39m
case 396�[0;32m PASS: (symbol->string 'flying-fish) equals "flying-fish"�[0;39m
case 397�[0;32m PASS: (symbol->string 'Martin) equals "Martin"�[0;39m
case 398�[0;32m PASS: (symbol->string (string->symbol "Malvina")) equals "Malvina"�[0;39m
case 399�[0;32m PASS: (string->symbol "mISSISSIppi") equals mISSISSIppi�[0;39m
case 400�[0;32m PASS: (eq? 'bitBlt (string->symbol "bitBlt")) equals #t�[0;39m
case 401�[0;32m PASS: (eq? 'LollyPop (string->symbol (symbol->string 'LollyPop))) equals #t�[0;39m
case 402�[0;32m PASS: (string=? "K. Harper, M.D." (symbol->string (string->symbol "K. Harper, M.D."))) equals #t�[0;39m
case 403�[0;32m PASS: (char? #\a) equals #t�[0;39m
case 404�[0;32m PASS: (char? "a") equals #f�[0;39m
case 405�[0;32m PASS: (char? 'a) equals #f�[0;39m
case 406�[0;32m PASS: (char? 0) equals #f�[0;39m
case 407�[0;32m PASS: (char=? #\a #\a #\a) equals #t�[0;39m
case 408�[0;32m PASS: (char=? #\a #\A) equals #f�[0;39m
case 409�[0;32m PASS: (char<? #\a #\b #\c) equals #t�[0;39m
case 410�[0;32m PASS: (char<? #\a #\a) equals #f�[0;39m
case 411�[0;32m PASS: (char<? #\b #\a) equals #f�[0;39m
case 412�[0;32m PASS: (char>? #\a #\b) equals #f�[0;39m
case 413�[0;32m PASS: (char>? #\a #\a) equals #f�[0;39m
case 414�[0;32m PASS: (char>? #\c #\b #\a) equals #t�[0;39m
case 415�[0;32m PASS: (char<=? #\a #\b #\b) equals #t�[0;39m
case 416�[0;32m PASS: (char<=? #\a #\a) equals #t�[0;39m
case 417�[0;32m PASS: (char<=? #\b #\a) equals #f�[0;39m
case 418�[0;32m PASS: (char>=? #\a #\b) equals #f�[0;39m
case 419�[0;32m PASS: (char>=? #\a #\a) equals #t�[0;39m
case 420�[0;32m PASS: (char>=? #\b #\b #\a) equals #t�[0;39m
case 421�[0;32m PASS: (char->integer #\a) equals 97�[0;39m
case 422�[0;32m PASS: (integer->char 97) equals #\a�[0;39m
case 423�[0;32m PASS: (string? "") equals #t�[0;39m
case 424�[0;32m PASS: (string? " ") equals #t�[0;39m
case 425�[0;32m PASS: (string? 'a) equals #f�[0;39m
case 426�[0;32m PASS: (string? #\a) equals #f�[0;39m
case 427�[0;32m PASS: (string-length (make-string 3)) equals 3�[0;39m
case 428�[0;32m PASS: (make-string 3 #\-) equals "---"�[0;39m
case 429�[0;32m PASS: (string) equals ""�[0;39m
case 430�[0;32m PASS: (string #\- #\- #\-) equals "---"�[0;39m
case 431�[0;32m PASS: (string #\k #\i #\t #\t #\e #\n) equals "kitten"�[0;39m
case 432�[0;32m PASS: (string-length "") equals 0�[0;39m
case 433�[0;32m PASS: (string-length "a") equals 1�[0;39m
case 434�[0;32m PASS: (string-length "abc") equals 3�[0;39m
case 435�[0;32m PASS: (string-ref "abc" 0) equals #\a�[0;39m
case 436�[0;32m PASS: (string-ref "abc" 1) equals #\b�[0;39m
case 437�[0;32m PASS: (string-ref "abc" 2) equals #\c�[0;39m
case 438�[0;32m PASS: (let ((str (string #\a #\b #\c))) (string-set! str 1 #\-) str) equals "a-c"�[0;39m
case 439�[0;32m PASS: (string=? "" "") equals #t�[0;39m
case 440�[0;32m PASS: (string=? "abc" "abc" "abc") equals #t�[0;39m
case 441�[0;32m PASS: (string=? "" "abc") equals #f�[0;39m
case 442�[0;32m PASS: (string=? "abc" "aBc") equals #f�[0;39m
case 443�[0;32m PASS: (string<? "" "") equals #f�[0;39m
case 444�[0;32m PASS: (string<? "abc" "abc") equals #f�[0;39m
case 445�[0;32m PASS: (string<? "abc" "abcd" "acd") equals #t�[0;39m
case 446�[0;32m PASS: (string<? "abcd" "abc") equals #f�[0;39m
case 447�[0;32m PASS: (string<? "abc" "bbc") equals #t�[0;39m
case 448�[0;32m PASS: (string>? "" "") equals #f�[0;39m
case 449�[0;32m PASS: (string>? "abc" "abc") equals #f�[0;39m
case 450�[0;32m PASS: (string>? "abc" "abcd") equals #f�[0;39m
case 451�[0;32m PASS: (string>? "acd" "abcd" "abc") equals #t�[0;39m
case 452�[0;32m PASS: (string>? "abc" "bbc") equals #f�[0;39m
case 453�[0;32m PASS: (string<=? "" "") equals #t�[0;39m
case 454�[0;32m PASS: (string<=? "abc" "abc") equals #t�[0;39m
case 455�[0;32m PASS: (string<=? "abc" "abcd" "abcd") equals #t�[0;39m
case 456�[0;32m PASS: (string<=? "abcd" "abc") equals #f�[0;39m
case 457�[0;32m PASS: (string<=? "abc" "bbc") equals #t�[0;39m
case 458�[0;32m PASS: (string>=? "" "") equals #t�[0;39m
case 459�[0;32m PASS: (string>=? "abc" "abc") equals #t�[0;39m
case 460�[0;32m PASS: (string>=? "abc" "abcd") equals #f�[0;39m
case 461�[0;32m PASS: (string>=? "abcd" "abcd" "abc") equals #t�[0;39m
case 462�[0;32m PASS: (string>=? "abc" "bbc") equals #f�[0;39m
case 463�[0;32m PASS: (substring "" 0 0) equals ""�[0;39m
case 464�[0;32m PASS: (substring "a" 0 0) equals ""�[0;39m
case 465�[0;32m PASS: (substring "abc" 1 1) equals ""�[0;39m
case 466�[0;32m PASS: (substring "abc" 0 2) equals "ab"�[0;39m
case 467�[0;32m PASS: (substring "abc" 1 3) equals "bc"�[0;39m
case 468�[0;32m PASS: (string-append "") equals ""�[0;39m
case 469�[0;32m PASS: (string-append "" "") equals ""�[0;39m
case 470�[0;32m PASS: (string-append "" "abc") equals "abc"�[0;39m
case 471�[0;32m PASS: (string-append "abc" "") equals "abc"�[0;39m
case 472�[0;32m PASS: (string-append "abc" "de") equals "abcde"�[0;39m
case 473�[0;32m PASS: (string-append "abc" "de" "f") equals "abcdef"�[0;39m
case 474�[0;32m PASS: (string->list "") equals ()�[0;39m
case 475�[0;32m PASS: (string->list "a") equals (#\a)�[0;39m
case 476�[0;32m PASS: (string->list "abc") equals (#\a #\b #\c)�[0;39m
case 477�[0;32m PASS: (string->list "abc" 0) equals (#\a #\b #\c)�[0;39m
case 478�[0;32m PASS: (string->list "abc" 1) equals (#\b #\c)�[0;39m
case 479�[0;32m PASS: (string->list "abc" 1 3) equals (#\b #\c)�[0;39m
case 480�[0;32m PASS: (list->string '()) equals ""�[0;39m
case 481�[0;32m PASS: (list->string '(#\a #\b #\c)) equals "abc"�[0;39m
case 482�[0;32m PASS: (string-copy "") equals ""�[0;39m
case 483�[0;32m PASS: (string-copy "" 0) equals ""�[0;39m
case 484�[0;32m PASS: (string-copy "" 0 0) equals ""�[0;39m
case 485�[0;32m PASS: (string-copy "abc") equals "abc"�[0;39m
case 486�[0;32m PASS: (string-copy "abc" 0) equals "abc"�[0;39m
case 487�[0;32m PASS: (string-copy "abc" 1) equals "bc"�[0;39m
case 488�[0;32m PASS: (string-copy "abc" 1 2) equals "b"�[0;39m
case 489�[0;32m PASS: (string-copy "abc" 1 3) equals "bc"�[0;39m
case 490�[0;32m PASS: (let ((str (make-string 5 #\x))) (string-fill! str #\-) str) equals "-----"�[0;39m
case 491�[0;32m PASS: (let ((str (make-string 5 #\x))) (string-fill! str #\- 2) str) equals "xx---"�[0;39m
case 492�[0;32m PASS: (let ((str (make-string 5 #\x))) (string-fill! str #\- 2 3) str) equals "xx-xx"�[0;39m
case 493�[0;32m PASS: (let ((str (string-copy "abcde"))) (string-copy! str 1 "12345" 0 2) str) equals "a12de"�[0;39m
case 494�[0;32m PASS: (let ((str (make-string 5 #\x))) (string-copy! str 0 "-----") str) equals "-----"�[0;39m
case 495�[0;32m PASS: (let ((str (make-string 5 #\x))) (string-copy! str 0 "-----" 2) str) equals "---xx"�[0;39m
case 496�[0;32m PASS: (let ((str (make-string 5 #\x))) (string-copy! str 2 "-----" 0 3) str) equals "xx---"�[0;39m
case 497�[0;32m PASS: (let ((str (make-string 5 #\x))) (string-copy! str 2 "-----" 2 3) str) equals "xx-xx"�[0;39m
case 498�[0;32m PASS: (let ((str (string-copy "abcde"))) (string-copy! str 1 str 0 2) str) equals "aabde"�[0;39m
case 499�[0;32m PASS: (let ((str (string-copy "abcde"))) (string-copy! str 3 str 0 2) str) equals "abcab"�[0;39m
case 500�[0;32m PASS: (vector? #()) equals #t�[0;39m
case 501�[0;32m PASS: (vector? #(1 2 3)) equals #t�[0;39m
case 502�[0;32m PASS: (vector? '#(1 2 3)) equals #t�[0;39m
case 503�[0;32m PASS: (vector-length (make-vector 0)) equals 0�[0;39m
case 504�[0;32m PASS: (vector-length (make-vector 1000)) equals 1000�[0;39m
case 505�[0;32m PASS: '#(0 (2 2 2 2) "Anna") equals #(0 (2 2 2 2) "Anna")�[0;39m
case 506�[0;32m PASS: (vector 'a 'b 'c) equals #(a b c)�[0;39m
case 507�[0;32m PASS: (vector-ref '#(1 1 2 3 5 8 13 21) 5) equals 8�[0;39m
case 508�[0;32m PASS: (vector-ref '#(1 1 2 3 5 8 13 21) (let ((i (round (* 2 (acos -1))))) (if (inexact? i) (exact i) i))) equals 13�[0;39m
case 509�[0;32m PASS: (let ((vec (vector 0 '(2 2 2 2) "Anna"))) (vector-set! vec 1 '("Sue" "Sue")) vec) equals #(0 ("Sue" "Sue") "Anna")�[0;39m
case 510�[0;32m PASS: (vector->list '#(dah dah didah)) equals (dah dah didah)�[0;39m
case 511�[0;32m PASS: (vector->list '#(dah dah didah) 1) equals (dah didah)�[0;39m
case 512�[0;32m PASS: (vector->list '#(dah dah didah) 1 2) equals (dah)�[0;39m
case 513�[0;32m PASS: (list->vector '(dididit dah)) equals #(dididit dah)�[0;39m
case 514�[0;32m PASS: (string->vector "") equals #()�[0;39m
case 515�[0;32m PASS: (string->vector "ABC") equals #(#\A #\B #\C)�[0;39m
case 516�[0;32m PASS: (string->vector "ABC" 1) equals #(#\B #\C)�[0;39m
case 517�[0;32m PASS: (string->vector "ABC" 1 2) equals #(#\B)�[0;39m
case 518�[0;32m PASS: (vector->string #()) equals ""�[0;39m
case 519�[0;32m PASS: (vector->string #(#\1 #\2 #\3)) equals "123"�[0;39m
case 520�[0;32m PASS: (vector->string #(#\1 #\2 #\3) 1) equals "23"�[0;39m
case 521�[0;32m PASS: (vector->string #(#\1 #\2 #\3) 1 2) equals "2"�[0;39m
case 522�[0;32m PASS: (vector-copy #()) equals #()�[0;39m
case 523�[0;32m PASS: (vector-copy #(a b c)) equals #(a b c)�[0;39m
case 524�[0;32m PASS: (vector-copy #(a b c) 1) equals #(b c)�[0;39m
case 525�[0;32m PASS: (vector-copy #(a b c) 1 2) equals #(b)�[0;39m
case 526�[0;32m PASS: (vector-append #()) equals #()�[0;39m
case 527�[0;32m PASS: (vector-append #() #()) equals #()�[0;39m
case 528�[0;32m PASS: (vector-append #() #(a b c)) equals #(a b c)�[0;39m
case 529�[0;32m PASS: (vector-append #(a b c) #()) equals #(a b c)�[0;39m
case 530�[0;32m PASS: (vector-append #(a b c) #(d e)) equals #(a b c d e)�[0;39m
case 531�[0;32m PASS: (vector-append #(a b c) #(d e) #(f)) equals #(a b c d e f)�[0;39m
case 532�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-fill! vec 'smash 2 4) vec) equals #(1 2 smash smash 5)�[0;39m
case 533�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-fill! vec 'x) vec) equals #(x x x x x)�[0;39m
case 534�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-fill! vec 'x 2) vec) equals #(1 2 x x x)�[0;39m
case 535�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-fill! vec 'x 2 3) vec) equals #(1 2 x 4 5)�[0;39m
case 536�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-copy! vec 1 #(a b c d e) 0 2) vec) equals #(1 a b 4 5)�[0;39m
case 537�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-copy! vec 0 #(a b c d e)) vec) equals #(a b c d e)�[0;39m
case 538�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-copy! vec 0 #(a b c d e) 2) vec) equals #(c d e 4 5)�[0;39m
case 539�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-copy! vec 2 #(a b c d e) 0 3) vec) equals #(1 2 a b c)�[0;39m
case 540�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-copy! vec 2 #(a b c d e) 2 3) vec) equals #(1 2 c 4 5)�[0;39m
case 541�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-copy! vec 1 vec 0 2) vec) equals #(1 1 2 4 5)�[0;39m
case 542�[0;32m PASS: (let ((vec (vector 1 2 3 4 5))) (vector-copy! vec 3 vec 0 2) vec) equals #(1 2 3 1 2)�[0;39m
case 543�[0;32m PASS: (bytevector? #u8()) equals #t�[0;39m
case 544�[0;32m PASS: (bytevector? #u8(0 1 2)) equals #t�[0;39m
case 545�[0;32m PASS: (bytevector? #()) equals #f�[0;39m
case 546�[0;32m PASS: (bytevector? #(0 1 2)) equals #f�[0;39m
case 547�[0;32m PASS: (bytevector? '()) equals #f�[0;39m
case 548�[0;32m PASS: (bytevector? (make-bytevector 0)) equals #t�[0;39m
case 549�[0;32m PASS: (bytevector-length (make-bytevector 0)) equals 0�[0;39m
case 550�[0;32m PASS: (bytevector-length (make-bytevector 1024)) equals 1024�[0;39m
case 551�[0;32m PASS: (bytevector-length (make-bytevector 1024 255)) equals 1024�[0;39m
case 552�[0;32m PASS: (bytevector-length (bytevector 0 1 2)) equals 3�[0;39m
case 553�[0;32m PASS: (bytevector-u8-ref (bytevector 0 1 2) 0) equals 0�[0;39m
case 554�[0;32m PASS: (bytevector-u8-ref (bytevector 0 1 2) 1) equals 1�[0;39m
case 555�[0;32m PASS: (bytevector-u8-ref (bytevector 0 1 2) 2) equals 2�[0;39m
case 556�[0;32m PASS: (let ((bv (bytevector 0 1 2))) (bytevector-u8-set! bv 1 255) bv) equals #u8(0 255 2)�[0;39m
case 557�[0;32m PASS: (bytevector-copy #u8()) equals #u8()�[0;39m
case 558�[0;32m PASS: (bytevector-copy #u8(0 1 2)) equals #u8(0 1 2)�[0;39m
case 559�[0;32m PASS: (bytevector-copy #u8(0 1 2) 1) equals #u8(1 2)�[0;39m
case 560�[0;32m PASS: (bytevector-copy #u8(0 1 2) 1 2) equals #u8(1)�[0;39m
case 561�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (bytevector-copy! bv 1 #u8(6 7 8 9 10) 0 2) bv) equals #u8(1 6 7 4 5)�[0;39m
case 562�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (bytevector-copy! bv 0 #u8(6 7 8 9 10)) bv) equals #u8(6 7 8 9 10)�[0;39m
case 563�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (bytevector-copy! bv 0 #u8(6 7 8 9 10) 2) bv) equals #u8(8 9 10 4 5)�[0;39m
case 564�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (bytevector-copy! bv 2 #u8(6 7 8 9 10) 0 3) bv) equals #u8(1 2 6 7 8)�[0;39m
case 565�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (bytevector-copy! bv 2 #u8(6 7 8 9 10) 2 3) bv) equals #u8(1 2 8 4 5)�[0;39m
case 566�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (bytevector-copy! bv 1 bv 0 2) bv) equals #u8(1 1 2 4 5)�[0;39m
case 567�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (bytevector-copy! bv 3 bv 0 2) bv) equals #u8(1 2 3 1 2)�[0;39m
case 568�[0;32m PASS: (bytevector-append #u8()) equals #u8()�[0;39m
case 569�[0;32m PASS: (bytevector-append #u8() #u8()) equals #u8()�[0;39m
case 570�[0;32m PASS: (bytevector-append #u8() #u8(0 1 2)) equals #u8(0 1 2)�[0;39m
case 571�[0;32m PASS: (bytevector-append #u8(0 1 2) #u8()) equals #u8(0 1 2)�[0;39m
case 572�[0;32m PASS: (bytevector-append #u8(0 1 2) #u8(3 4)) equals #u8(0 1 2 3 4)�[0;39m
case 573�[0;32m PASS: (bytevector-append #u8(0 1 2) #u8(3 4) #u8(5)) equals #u8(0 1 2 3 4 5)�[0;39m
case 574�[0;32m PASS: (procedure? car) equals #t�[0;39m
case 575�[0;32m PASS: (procedure? 'car) equals #f�[0;39m
case 576�[0;32m PASS: (procedure? (lambda (x) (* x x))) equals #t�[0;39m
case 577�[0;32m PASS: (procedure? '(lambda (x) (* x x))) equals #f�[0;39m
case 578�[0;32m PASS: (call-with-current-continuation procedure?) equals #t�[0;39m
case 579�[0;32m PASS: (apply + (list 3 4)) equals 7�[0;39m
case 580�[0;32m PASS: (call-with-values (lambda () ((compose exact-integer-sqrt *) 12 75)) list) equals (30 0)�[0;39m
case 581�[0;32m PASS: (map cadr '((a b) (d e) (g h))) equals (b e h)�[0;39m
case 582�[0;32m PASS: (map (lambda (n) (expt n n)) '(1 2 3 4 5)) equals (1 4 27 256 3125)�[0;39m
case 583�[0;32m PASS: (map + '(1 2 3) '(4 5 6 7)) equals (5 7 9)�[0;39m
case 584�[0;32m PASS: (let ((res (let ((count 0)) (map (lambda (ignored) (set! count (+ count 1)) count) '(a b))))) (or (equal? res '(1 2)) (equal? res '(2 1)))) equals #t�[0;39m
case 585�[0;32m PASS: (let ((ls1 (list 10 100 1000)) (ls2 (list 1 2 3 4 5 6))) (set-cdr! (cddr ls1) ls1) (map * ls1 ls2)) equals (10 200 3000 40 500 6000)�[0;39m
case 586�[0;32m PASS: (string-map (lambda (c) (integer->char (+ 1 (char->integer c)))) "HAL") equals "IBM"�[0;39m
case 587�[0;32m PASS: (vector-map cadr '#((a b) (d e) (g h))) equals #(b e h)�[0;39m
case 588�[0;32m PASS: (vector-map (lambda (n) (expt n n)) '#(1 2 3 4 5)) equals #(1 4 27 256 3125)�[0;39m
case 589�[0;32m PASS: (vector-map + '#(1 2 3) '#(4 5 6 7)) equals #(5 7 9)�[0;39m
case 590�[0;32m PASS: (let ((res (let ((count 0)) (vector-map (lambda (ignored) (set! count (+ count 1)) count) '#(a b))))) (or (equal? res #(1 2)) (equal? res #(2 1)))) equals #t�[0;39m
case 591�[0;32m PASS: (let ((v (make-vector 5))) (for-each (lambda (i) (vector-set! v i (* i i))) '(0 1 2 3 4)) v) equals #(0 1 4 9 16)�[0;39m
case 592�[0;32m PASS: (let ((ls1 (list 10 100 1000)) (ls2 (list 1 2 3 4 5 6)) (count 0)) (set-cdr! (cddr ls1) ls1) (for-each (lambda (x y) (set! count (+ count (* x y)))) ls2 ls1) count) equals 9750�[0;39m
case 593�[0;32m PASS: (let ((v '())) (string-for-each (lambda (c) (set! v (cons (char->integer c) v))) "abcde") v) equals (101 100 99 98 97)�[0;39m
case 594�[0;32m PASS: (let ((v (make-list 5))) (vector-for-each (lambda (i) (list-set! v i (* i i))) '#(0 1 2 3 4)) v) equals (0 1 4 9 16)�[0;39m
case 595�[0;32m PASS: (call-with-current-continuation (lambda (exit) (for-each (lambda (x) (if (negative? x) (exit x))) '(54 0 37 -3 245 19)) #t)) equals -3�[0;39m
case 596�[0;32m PASS: (list-length '(1 2 3 4)) equals 4�[0;39m
case 597�[0;32m PASS: (list-length '(a b . c)) equals #f�[0;39m
case 598�[0;32m PASS: (call-with-values (lambda () (values 4 5)) (lambda (a b) b)) equals 5�[0;39m
case 599�[0;32m PASS: (call-with-values * -) equals -1�[0;39m
case 600�[0;32m PASS: (let ((path '()) (c #f)) (let ((add (lambda (s) (set! path (cons s path))))) (dynamic-wind (lambda () (add 'connect)) (lambda () (add (call-with-current-continuation (lambda (c0) (set! c c0) 'talk1)))) (lambda () (add 'disconnect))) (if (< (length path) 4) (c 'talk2) (reverse path)))) equals (connect talk1 disconnect connect talk2 disconnect)�[0;39m
case 601�[0;32m PASS: (call/cc (lambda (cc3) (let ((p (open-input-string "aa"))) ((call/cc (lambda (cc) (call-with-port p (lambda (port) (cc3 (read-char (call/cc (lambda (cc2) (cc cc2))))))))) p)))) equals #\a�[0;39m
case 602�[0;32m PASS: (with-exception-handler (lambda (con) 42) (lambda () (+ (raise-continuable "should be a number") 23))) equals 65�[0;39m
case 603�[0;32m PASS: (error-object? (guard (exn (else exn)) (error "BOOM!" 1 2 3))) equals #t�[0;39m
case 604�[0;32m PASS: (error-object-message (guard (exn (else exn)) (error "BOOM!" 1 2 3))) equals "BOOM!"�[0;39m
case 605�[0;32m PASS: (error-object-irritants (guard (exn (else exn)) (error "BOOM!" 1 2 3))) equals (1 2 3)�[0;39m
case 606�[0;32m PASS: (file-error? (guard (exn (else exn)) (error "BOOM!"))) equals #f�[0;39m
case 607�[0;32m PASS: (file-error? (guard (exn (else exn)) (open-input-file " no such file "))) equals #t�[0;39m
case 608�[0;32m PASS: (read-error? (guard (exn (else exn)) (error "BOOM!"))) equals #f�[0;39m
case 609�[0;32m PASS: (read-error? (guard (exn (else exn)) (read (open-input-string ")")))) equals #t�[0;39m
case 610�[0;32m PASS: (test-exception-handler-1 5) equals 106�[0;39m
case 611�[0;32m PASS: something-went-wrong equals #f�[0;39m
case 612�[0;32m PASS: (test-exception-handler-1 -1) equals exception�[0;39m
case 613�[0;32m PASS: something-went-wrong equals ("condition: " an-error)�[0;39m
case 614�[0;32m PASS: (test-exception-handler-2 5) equals 106�[0;39m
case 615�[0;32m PASS: something-went-wrong equals #f�[0;39m
case 616�[0;32m PASS: (test-exception-handler-2 -1) equals caught-another-exception�[0;39m
case 617�[0;32m PASS: something-went-wrong equals #t�[0;39m
case 618�[0;32m PASS: (get-output-string out) equals "should be a number"�[0;39m
case 619�[0;32m PASS: value equals 65�[0;39m
case 620�[0;32m PASS: value equals exception�[0;39m
case 621�[0;32m PASS: (get-output-string out) equals "condition: an-error!"�[0;39m
case 622�[0;32m PASS: (get-output-string out) equals ""�[0;39m
case 623�[0;32m PASS: value equals positive�[0;39m
case 624�[0;32m PASS: (get-output-string out) equals ""�[0;39m
case 625�[0;32m PASS: value equals negative�[0;39m
case 626�[0;32m PASS: (get-output-string out) equals "reraised 0!"�[0;39m
case 627�[0;32m PASS: value equals zero�[0;39m
case 628�[0;32m PASS: (guard (condition ((assq 'a condition) => cdr) ((assq 'b condition))) (raise (list (cons 'a 42)))) equals 42�[0;39m
case 629�[0;32m PASS: (guard (condition ((assq 'a condition) => cdr) ((assq 'b condition))) (raise (list (cons 'b 23)))) equals (b . 23)�[0;39m
case 630�[0;32m PASS: (guard (condition ((assq 'c condition) 'caught-c) ((assq 'd condition) 'caught-d)) (list (sqrt 8) (guard (condition ((assq 'a condition) => cdr) ((assq 'b condition))) (raise (list (cons 'd 24)))))) equals caught-d�[0;39m
case 631�[0;32m PASS: (eval '(* 7 3) (scheme-report-environment 5)) equals 21�[0;39m
case 632�[0;32m PASS: (let ((f (eval '(lambda (f x) (f x x)) (null-environment 5)))) (f + 10)) equals 20�[0;39m
case 633�[0;32m PASS: (eval '(expt 2 10) (environment '(scheme base))) equals 1024�[0;39m
case 634�[0;32m PASS: (inexact (eval '(sin 0) (environment '(scheme inexact)))) equals 0�[0;39m
case 635�[0;32m PASS: (eval '(+ (expt 2 10) (inexact (sin 0))) (environment '(scheme base) '(scheme inexact))) equals 1024�[0;39m
case 636�[0;32m PASS: (port? (current-input-port)) equals #t�[0;39m
case 637�[0;32m PASS: (input-port? (current-input-port)) equals #t�[0;39m
case 638�[0;32m PASS: (output-port? (current-output-port)) equals #t�[0;39m
case 639�[0;32m PASS: (output-port? (current-error-port)) equals #t�[0;39m
case 640�[0;32m PASS: (input-port? (open-input-string "abc")) equals #t�[0;39m
case 641�[0;32m PASS: (output-port? (open-output-string)) equals #t�[0;39m
case 642�[0;32m PASS: (textual-port? (open-input-string "abc")) equals #t�[0;39m
case 643�[0;32m PASS: (textual-port? (open-output-string)) equals #t�[0;39m
case 644�[0;32m PASS: (binary-port? (open-input-bytevector #u8(0 1 2))) equals #t�[0;39m
case 645�[0;32m PASS: (binary-port? (open-output-bytevector)) equals #t�[0;39m
case 646�[0;32m PASS: (input-port-open? (open-input-string "abc")) equals #t�[0;39m
case 647�[0;32m PASS: (output-port-open? (open-output-string)) equals #t�[0;39m
case 648�[0;32m PASS: (let ((in (open-input-string "abc"))) (close-input-port in) (input-port-open? in)) equals #f�[0;39m
case 649�[0;32m PASS: (let ((out (open-output-string))) (close-output-port out) (output-port-open? out)) equals #f�[0;39m
case 650�[0;32m PASS: (let ((out (open-output-string))) (close-port out) (output-port-open? out)) equals #f�[0;39m
case 651�[0;32m PASS: (eof-object? (eof-object)) equals #t�[0;39m
case 652�[0;32m PASS: (eof-object? (read (open-input-string ""))) equals #t�[0;39m
case 653�[0;32m PASS: (char-ready? (open-input-string "42")) equals #t�[0;39m
case 654�[0;32m PASS: (read (open-input-string " 42 ")) equals 42�[0;39m
case 655�[0;32m PASS: (eof-object? (read-char (open-input-string ""))) equals #t�[0;39m
case 656�[0;32m PASS: (read-char (open-input-string "abc")) equals #\a�[0;39m
case 657�[0;32m PASS: (eof-object? (read-line (open-input-string ""))) equals #t�[0;39m
case 658�[0;32m PASS: (read-line (open-input-string "abc")) equals "abc"�[0;39m
case 659�[0;32m PASS: (read-line (open-input-string "abc
def
")) equals "abc"�[0;39m
case 660�[0;32m PASS: (eof-object? (read-string 3 (open-input-string ""))) equals #t�[0;39m
case 661�[0;32m PASS: (read-string 3 (open-input-string "abcd")) equals "abc"�[0;39m
case 662�[0;32m PASS: (read-string 3 (open-input-string "abc
def
")) equals "abc"�[0;39m
case 663�[0;32m PASS: (let ((out (open-output-string))) (write 'abc out) (get-output-string out)) equals "abc"�[0;39m
case 664�[0;32m PASS: (let ((out (open-output-string))) (display "abc def" out) (get-output-string out)) equals "abc def"�[0;39m
case 665�[0;32m PASS: (let ((out (open-output-string))) (display #\a out) (display "b" out) (display #\c out) (get-output-string out)) equals "abc"�[0;39m
case 666�[0;32m PASS: (let* ((out (open-output-string)) (r (begin (newline out) (get-output-string out)))) (or (equal? r "
") (equal? r "
"))) equals #t�[0;39m
case 667�[0;32m PASS: (let ((out (open-output-string))) (write-string "abc def" out) (get-output-string out)) equals "abc def"�[0;39m
case 668�[0;32m PASS: (let ((out (open-output-string))) (write-string "abc def" out 4) (get-output-string out)) equals "def"�[0;39m
case 669�[0;32m PASS: (let ((out (open-output-string))) (write-string "abc def" out 2 5) (get-output-string out)) equals "c d"�[0;39m
case 670�[0;32m PASS: (let ((out (open-output-string))) (flush-output-port out) (get-output-string out)) equals ""�[0;39m
case 671�[0;32m PASS: (eof-object? (read-u8 (open-input-bytevector #u8()))) equals #t�[0;39m
case 672�[0;32m PASS: (read-u8 (open-input-bytevector #u8(1 2 3))) equals 1�[0;39m
case 673�[0;32m PASS: (eof-object? (read-bytevector 3 (open-input-bytevector #u8()))) equals #t�[0;39m
case 674�[0;32m PASS: (u8-ready? (open-input-bytevector #u8(1))) equals #t�[0;39m
case 675�[0;32m PASS: (read-bytevector 3 (open-input-bytevector #u8(1))) equals #u8(1)�[0;39m
case 676�[0;32m PASS: (read-bytevector 3 (open-input-bytevector #u8(1 2))) equals #u8(1 2)�[0;39m
case 677�[0;32m PASS: (read-bytevector 3 (open-input-bytevector #u8(1 2 3))) equals #u8(1 2 3)�[0;39m
case 678�[0;32m PASS: (read-bytevector 3 (open-input-bytevector #u8(1 2 3 4))) equals #u8(1 2 3)�[0;39m
case 679�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (eof-object? (read-bytevector! bv (open-input-bytevector #u8())))) equals #t�[0;39m
case 680�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (read-bytevector! bv (open-input-bytevector #u8(6 7 8 9 10)) 0 5) bv) equals #u8(6 7 8 9 10)�[0;39m
case 681�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (read-bytevector! bv (open-input-bytevector #u8(6 7 8 9 10)) 0 3) bv) equals #u8(6 7 8 4 5)�[0;39m
case 682�[0;32m PASS: (let ((bv (bytevector 1 2 3 4 5))) (read-bytevector! bv (open-input-bytevector #u8(6 7 8 9 10)) 3 4) bv) equals #u8(1 2 3 6 5)�[0;39m
case 683�[0;32m PASS: (let ((out (open-output-bytevector))) (write-u8 1 out) (write-u8 2 out) (write-u8 3 out) (get-output-bytevector out)) equals #u8(1 2 3)�[0;39m
case 684�[0;32m PASS: (let ((out (open-output-bytevector))) (write-bytevector #u8(1 2 3 4 5) out) (get-output-bytevector out)) equals #u8(1 2 3 4 5)�[0;39m
case 685�[0;32m PASS: (let ((out (open-output-bytevector))) (write-bytevector #u8(1 2 3 4 5) out 2) (get-output-bytevector out)) equals #u8(3 4 5)�[0;39m
case 686�[0;32m PASS: (let ((out (open-output-bytevector))) (write-bytevector #u8(1 2 3 4 5) out 2 4) (get-output-bytevector out)) equals #u8(3 4)�[0;39m
case 687�[0;32m PASS: (let ((out (open-output-bytevector))) (flush-output-port out) (get-output-bytevector out)) equals #u8()�[0;39m
case 688�[0;32m PASS: (and (member (let ((out (open-output-string)) (x (list 1))) (set-cdr! x x) (write x out) (get-output-string out)) '("#0=(1 . #0#)" "#1=(1 . #1#)")) #t) equals #t�[0;39m
case 689�[0;32m PASS: (let ((out (open-output-string)) (x (list 1 2 3))) (write (list x x) out) (get-output-string out)) equals "((1 2 3) (1 2 3))"�[0;39m
case 690�[0;32m PASS: (let ((out (open-output-string)) (x (list 1 2 3))) (write-simple (list x x) out) (get-output-string out)) equals "((1 2 3) (1 2 3))"�[0;39m
case 691�[0;32m PASS: (and (member (let ((out (open-output-string)) (x (list 1 2 3))) (write-shared (list x x) out) (get-output-string out)) '("(#0=(1 2 3) #0#)" "(#1=(1 2 3) #1#)")) #t) equals #t�[0;39m
case 692�[0;32m PASS: (read (open-input-string "#t")) equals #t�[0;39m
case 693�[0;32m PASS: (read (open-input-string "#true")) equals #t�[0;39m
case 694�[0;32m PASS: (read (open-input-string "#f")) equals #f�[0;39m
case 695�[0;32m PASS: (read (open-input-string "#false")) equals #f�[0;39m
case 696�[0;32m PASS: (read2 (open-input-string "#t(5)")) equals (#t 5)�[0;39m
case 697�[0;32m PASS: (read2 (open-input-string "#true 6 ")) equals (#t . 6)�[0;39m
case 698�[0;32m PASS: (read2 (open-input-string "#f 7")) equals (#f . 7)�[0;39m
case 699�[0;32m PASS: (read2 (open-input-string "#false\"8\"")) equals (#f . "8")�[0;39m
case 700�[0;32m PASS: (read (open-input-string "()")) equals ()�[0;39m
case 701�[0;32m PASS: (read (open-input-string "(1 2)")) equals (1 2)�[0;39m
case 702�[0;32m PASS: (read (open-input-string "(1 . 2)")) equals (1 . 2)�[0;39m
case 703�[0;32m PASS: (read (open-input-string "(1 . (2))")) equals (1 2)�[0;39m
case 704�[0;32m PASS: (read (open-input-string "(1 . (2 3 4 . (5)))")) equals (1 2 3 4 5)�[0;39m
case 705�[0;32m PASS: (cadr (read (open-input-string "#0=(1 . #0#)"))) equals 1�[0;39m
case 706�[0;32m PASS: (cadr (read (open-input-string "(#0=(1 2 3) #0#)"))) equals (1 2 3)�[0;39m
case 707�[0;32m PASS: (read (open-input-string "'(1 2)")) equals '(1 2)�[0;39m
case 708�[0;32m PASS: (read (open-input-string "'(1 ,2)")) equals '(1 ,2)�[0;39m
case 709�[0;32m PASS: (read (open-input-string "'(1 ,@2)")) equals '(1 ,@2)�[0;39m
case 710�[0;32m PASS: (read (open-input-string "`(1 ,2)")) equals `(1 ,2)�[0;39m
case 711�[0;32m PASS: (read (open-input-string "#()")) equals #()�[0;39m
case 712�[0;32m PASS: (read (open-input-string "#(a b)")) equals #(a b)�[0;39m
case 713�[0;32m PASS: (read (open-input-string "#u8()")) equals #u8()�[0;39m
case 714�[0;32m PASS: (read (open-input-string "#u8(0 1)")) equals #u8(0 1)�[0;39m
case 715�[0;32m PASS: (read (open-input-string "abc")) equals abc�[0;39m
case 716�[0;32m PASS: (read (open-input-string "abc def")) equals abc�[0;39m
case 717�[0;32m PASS: (read (open-input-string "ABC")) equals ABC�[0;39m
case 718�[0;32m PASS: (read (open-input-string "|H\\x65;llo|")) equals Hello�[0;39m
case 719�[0;32m PASS: (read (open-input-string "#!fold-case ABC")) equals abc�[0;39m
case 720�[0;32m PASS: (read (open-input-string "#!fold-case #!no-fold-case ABC")) equals ABC�[0;39m
case 721�[0;32m PASS: (read (open-input-string "#; abc def")) equals def�[0;39m
case 722�[0;32m PASS: (read (open-input-string "; abc 
def")) equals def�[0;39m
case 723�[0;32m PASS: (read (open-input-string "#| abc |# def")) equals def�[0;39m
case 724�[0;32m PASS: (read (open-input-string "#| abc #| def |# |# ghi")) equals ghi�[0;39m
case 725�[0;32m PASS: (read (open-input-string "#; ; abc
 def ghi")) equals ghi�[0;39m
case 726�[0;32m PASS: (read (open-input-string "(#;sqrt abs -16)")) equals (abs -16)�[0;39m
case 727�[0;32m PASS: (read (open-input-string "(a #; #;b c d)")) equals (a d)�[0;39m
case 728�[0;32m PASS: (read (open-input-string "(a #;(b #;c d) e)")) equals (a e)�[0;39m
case 729�[0;32m PASS: (read (open-input-string "(a . #;b c)")) equals (a . c)�[0;39m
case 730�[0;32m PASS: (read (open-input-string "(a . b #;c)")) equals (a . b)�[0;39m
case 731�[0;32m PASS: (read (open-input-string "#\\a")) equals #\a�[0;39m
case 732�[0;32m PASS: (read (open-input-string "#\\space")) equals #\space�[0;39m
case 733�[0;32m PASS: (char->integer (read (open-input-string "#\\null"))) equals 0�[0;39m
case 734�[0;32m PASS: (char->integer (read (open-input-string "#\\alarm"))) equals 7�[0;39m
case 735�[0;32m PASS: (char->integer (read (open-input-string "#\\backspace"))) equals 8�[0;39m
case 736�[0;32m PASS: (char->integer (read (open-input-string "#\\tab"))) equals 9�[0;39m
case 737�[0;32m PASS: (char->integer (read (open-input-string "#\\newline"))) equals 10�[0;39m
case 738�[0;32m PASS: (char->integer (read (open-input-string "#\\return"))) equals 13�[0;39m
case 739�[0;32m PASS: (#<identifier values> #<identifier z>) equals 1�[0;39m
case 740�[0;32m PASS: (#<identifier and> (#<identifier member> #<identifier z-str> (#<identifier quote> ("1"))) #t) equals #t�[0;39m
case 741�[0;32m PASS: (#<identifier values> #<identifier z>) equals -1�[0;39m
case 742�[0;32m PASS: (#<identifier and> (#<identifier member> #<identifier z-str> (#<identifier quote> ("-1"))) #t) equals #t�[0;39m
case 743�[0;32m PASS: (#<identifier values> #<identifier z>) equals +inf.0�[0;39m
case 744�[0;32m PASS: (#<identifier and> (#<identifier member> #<identifier z-str> (#<identifier quote> ("+inf.0" "+inf.0" "+Inf.0"))) #t) equals #t�[0;39m
case 745�[0;32m PASS: (#<identifier values> #<identifier z>) equals +inf.0�[0;39m
case 746�[0;32m PASS: (#<identifier and> (#<identifier member> #<identifier z-str> (#<identifier quote> ("+InF.0" "+inf.0" "+Inf.0"))) #t) equals #t�[0;39m
case 747�[0;32m PASS: (#<identifier values> #<identifier z>) equals -inf.0�[0;39m
case 748�[0;32m PASS: (#<identifier and> (#<identifier member> #<identifier z-str> (#<identifier quote> ("-inf.0" "-inf.0" "-Inf.0"))) #t) equals #t�[0;39m
case 749�[0;32m PASS: (#<identifier values> #<identifier z>) equals -inf.0�[0;39m
case 750�[0;32m PASS: (#<identifier and> (#<identifier member> #<identifier z-str> (#<identifier quote> ("-iNF.0" "-inf.0" "-Inf.0"))) #t) equals #t�[0;39m
case 751�[0;32m PASS: (string? (get-environment-variable "PATH")) equals #t�[0;39m
case 752�[0;32m PASS: (list? env) equals #t�[0;39m
case 753�[0;32m PASS: (all? env-pair? env) equals #t�[0;39m
case 754�[0;32m PASS: (list? (command-line)) equals #t�[0;39m
case 755�[0;32m PASS: (real? (current-second)) equals #t�[0;39m
case 756�[0;32m PASS: (inexact? (current-second)) equals #t�[0;39m
case 757�[0;32m PASS: (exact? (current-jiffy)) equals #t�[0;39m
case 758�[0;32m PASS: (exact? (jiffies-per-second)) equals #t�[0;39m
case 759�[0;32m PASS: (list? (features)) equals #t�[0;39m
case 760�[0;32m PASS: (and (memq 'r7rs (features)) #t) equals #t�[0;39m
case 761�[0;32m PASS: (file-exists? ".") equals #t�[0;39m
case 762�[0;32m PASS: (file-exists? " no such file ") equals #f�[0;39m
case 763�[0;32m PASS: (file-error? (guard (exn (else exn)) (delete-file " no such file "))) equals #t�[0;39m

�[0;34mTest Result: 760 / 764 (99.4764%) [PASS/TOTAL]�[0;39m
 �[0;31mFAIL: `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)
   expected (a `(b ,(+ 1 2) ,(foo 4 d) e) f) but got (a (#<identifier quasiquote> (b (#<identifier unquote> (+ 1 2)) (#<identifier unquote> (foo 4 d)) e)) f)�[0;39m
 �[0;31mFAIL: `(a `(b ,,name1 ,',name2 d) e)
   expected (a `(b ,x ,'y d) e) but got (a (#<identifier quasiquote> (b (#<identifier unquote> x) (#<identifier unquote> 'y) d)) e)�[0;39m
 �[0;31mFAIL: (tan 1)
   expected 1.55741 but got 1.55741�[0;39m
 �[0;31mFAIL: (string->number "1e2")
   expected 100 but got 100�[0;39m
case 0�[0;32m PASS: (mbi-dirty-v1 10 (+ i 1)) equals 11�[0;39m

�[0;34mTest Result: 1 / 1 (100%) [PASS/TOTAL]�[0;39m
for test in `ls contrib/30.optional/t/*.scm`; do \
      bin/picrin $test; \
    done
case 0�[0;32m PASS: (optional '() 0) equals 0�[0;39m
case 1�[0;32m PASS: (optional '(1) 0) equals 1�[0;39m
case 2�[0;32m PASS: (let-optionals* '() ((a 0) (b 0)) (list a b)) equals (0 0)�[0;39m
case 3�[0;32m PASS: (let-optionals* '(1) ((a 0) (b 0)) (list a b)) equals (1 0)�[0;39m
case 4�[0;32m PASS: (let-optionals* '(1 2) ((a 0) (b 0)) (list a b)) equals (1 2)�[0;39m
case 5�[0;32m PASS: (let-optionals* '(1) ((a 0) (b a)) (list a b)) equals (1 1)�[0;39m
case 6�[0;32m PASS: (let-optionals* '() ((a 0) . r) (list a r)) equals (0 ())�[0;39m
case 7�[0;32m PASS: (let-optionals* '(1) ((a 0) . r) (list a r)) equals (1 ())�[0;39m
case 8�[0;32m PASS: (let-optionals* '(1 2) ((a 0) . r) (list a r)) equals (1 (2))�[0;39m
for test in `ls contrib/30.random/t/*.scm`; do \
      bin/picrin $test; \
    done
case 0�[0;32m PASS: (procedure? random-real) equals #t�[0;39m
for test in `ls contrib/30.readline/t/*.scm`; do \
      bin/picrin $test; \
    done
case 0�[0;32m PASS: (history-length) equals 0�[0;39m
case 1�[0;32m PASS: (where-history) equals 0�[0;39m
case 2�[0;32m PASS: (history-length) equals 1�[0;39m
case 3�[0;32m PASS: (where-history) equals 1�[0;39m
case 4�[0;32m PASS: (history-length) equals 10�[0;39m
case 5�[0;32m PASS: (where-history) equals 1�[0;39m
case 6�[0;32m PASS: (history-length) equals 10�[0;39m
case 7�[0;32m PASS: (where-history) equals 1�[0;39m
case 8�[0;32m PASS: (history-set-pos 0) equals 0�[0;39m
case 9�[0;32m PASS: (where-history) equals 10�[0;39m
case 10�[0;32m PASS: (history-length) equals 7�[0;39m
case 11�[0;32m PASS: (where-history) equals 1�[0;39m
case 12�[0;32m PASS: (history-stifled?) equals #t�[0;39m
case 13�[0;32m PASS: (history-stifled?) equals #f�[0;39m
case 14�[0;32m PASS: (history-length) equals 7�[0;39m
case 15�[0;32m PASS: (where-history) equals 1�[0;39m
case 16�[0;32m PASS: (history-length) equals 8�[0;39m
case 17�[0;32m PASS: (where-history) equals 1�[0;39m
case 18�[0;32m PASS: (current-history) equals "12"�[0;39m
case 19�[0;32m PASS: (where-history) equals 1�[0;39m
case 20�[0;32m PASS: (previous-history) equals #f�[0;39m
case 21�[0;32m PASS: (where-history) equals 1�[0;39m
case 22�[0;32m PASS: (next-history) equals "11"�[0;39m
case 23�[0;32m PASS: (where-history) equals 2�[0;39m
case 24�[0;32m PASS: (history-set-pos 5) equals 0�[0;39m
case 25�[0;32m PASS: (where-history) equals 3�[0;39m
case 26�[0;32m PASS: (history-set-pos (history-length)) equals -1�[0;39m
case 27�[0;32m PASS: (where-history) equals 3�[0;39m
case 28�[0;32m PASS: (history-set-pos -1) equals -1�[0;39m
case 29�[0;32m PASS: (where-history) equals 3�[0;39m
case 30�[0;32m PASS: (history-set-pos 0) equals 0�[0;39m
case 31�[0;32m PASS: (where-history) equals 8�[0;39m
case 32�[0;32m PASS: (history-set-pos (- (history-length) 2)) equals 0�[0;39m
case 33�[0;32m PASS: (where-history) equals 2�[0;39m
case 34�[0;32m PASS: (current-history) equals "11"�[0;39m
case 35�[0;32m PASS: (where-history) equals 2�[0;39m
case 36�[0;32m PASS: (previous-history) equals "12"�[0;39m
case 37�[0;32m PASS: (where-history) equals 1�[0;39m
case 38�[0;32m PASS: (next-history) equals "11"�[0;39m
case 39�[0;32m PASS: (where-history) equals 2�[0;39m
case 40�[0;32m PASS: (history-get 11) equals "11"�[0;39m
case 41�[0;32m PASS: (remove-history 1) equals "6"�[0;39m
case 42�[0;32m PASS: (where-history) equals 6�[0;39m
case 43�[0;32m PASS: (current-history) equals "7"�[0;39m
case 44�[0;32m PASS: (next-history) equals "5"�[0;39m
case 45�[0;32m PASS: (history-get 6) equals #f�[0;39m
case 46�[0;32m PASS: (history-length) equals 7�[0;39m
case 47�[0;32m PASS: (history-search "7" -1) equals 0�[0;39m
case 48�[0;32m PASS: (where-history) equals 6�[0;39m
case 49�[0;32m PASS: (history-search "7" 0) equals -1�[0;39m
case 50�[0;32m PASS: (history-search "7" -1) equals -1�[0;39m
case 51�[0;32m PASS: (where-history) equals 7�[0;39m
case 52�[0;32m PASS: (history-search "7" 0) equals 0�[0;39m
case 53�[0;32m PASS: (where-history) equals 6�[0;39m
case 54�[0;32m PASS: (history-search-prefix "1" 0) equals 0�[0;39m
case 55�[0;32m PASS: (where-history) equals 3�[0;39m
case 56�[0;32m PASS: (history-search-prefix "1" -1) equals 0�[0;39m
case 57�[0;32m PASS: (where-history) equals 2�[0;39m
case 58�[0;32m PASS: (history-search-prefix "1" 0) equals 0�[0;39m
case 59�[0;32m PASS: (where-history) equals 2�[0;39m
case 60�[0;32m PASS: (history-search-prefix "9" -1) equals 0�[0;39m
case 61�[0;32m PASS: (where-history) equals 4�[0;39m
case 62�[0;32m PASS: (history-length) equals 7�[0;39m
case 63�[0;32m PASS: (history-length) equals 0�[0;39m
case 64�[0;32m PASS: (where-history) equals 0�[0;39m
case 65�[0;32m PASS: (history-length) equals 1�[0;39m
case 66�[0;32m PASS: (where-history) equals 1�[0;39m
case 67�[0;32m PASS: (history-get 1) equals "f"�[0;39m
case 68 �[0;31mFAIL: (history-length)
   expected 8 but got 1�[0;39m
case 69 �[0;31mFAIL: (history-length)
   expected 5 but got 0�[0;39m
case 70�[0;32m PASS: (history-expand "!b") equals "baz"�[0;39m
case 71�[0;32m PASS: (history-expand "!!") equals "baz"�[0;39m
case 72�[0;32m PASS: (history-expand "!?r?") equals "bar"�[0;39m
case 73�[0;32m PASS: (history-expand "!!:$") equals "arg"�[0;39m
case 74�[0;32m PASS: (history-expand "!$") equals "arg"�[0;39m
case 75�[0;32m PASS: (history-expand "!!:s/com/command/") equals "command arg"�[0;39m

�[0;34mTest Result: 74 / 76 (97.3684%) [PASS/TOTAL]�[0;39m
 �[0;31mFAIL: (history-length)
   expected 8 but got 1�[0;39m
 �[0;31mFAIL: (history-length)
   expected 5 but got 0�[0;39m
for test in `ls contrib/30.regexp/t/*.scm`; do \
      bin/picrin $test; \
    done
case 0�[0;32m PASS: (regexp? (regexp "simple")) equals #t�[0;39m
case 1�[0;32m PASS: (regexp? "it\\s[s]e+ms\\s(reg)?exp") equals #f�[0;39m
case 2�[0;32m PASS: (#<identifier call-with-values> (#<identifier lambda> () (regexp-match (regexp "a(b)cd") "abdacabcd")) (#<identifier lambda> #<identifier results> #<identifier results>)) equals (("abcd" "b") (5 6))�[0;39m
case 3�[0;32m PASS: (regexp-split (regexp ",") "a,b,c,d") equals ("a" "b" "c" "d")�[0;39m
case 4�[0;32m PASS: (regexp-split (regexp "\\.+") "a.b....c.....d") equals ("a" "b" "c" "d")�[0;39m
case 5�[0;32m PASS: (regexp-replace (regexp ",") "a,b,c,d" " ") equals "a b c d"�[0;39m
case 6�[0;32m PASS: (regexp-replace (regexp "[
     ]") "newline
tab space " " ") equals "newline tab space "�[0;39m
for test in `ls contrib/40.srfi/t/*.scm`; do \
      bin/picrin "$test"; \
    done
case 0�[0;32m PASS: (cons 'a '()) equals (a)�[0;39m
case 1�[0;32m PASS: (cons '(a) '(b c d)) equals ((a) b c d)�[0;39m
case 2�[0;32m PASS: (cons "a" '(b c)) equals ("a" b c)�[0;39m
case 3�[0;32m PASS: (cons 'a 3) equals (a . 3)�[0;39m
case 4�[0;32m PASS: (cons '(a b) 'c) equals ((a b) . c)�[0;39m
case 5�[0;32m PASS: (list 'a (+ 3 4) 'c) equals (a 7 c)�[0;39m
case 6�[0;32m PASS: (list) equals ()�[0;39m
case 7�[0;32m PASS: (xcons '(b c) 'a) equals (a b c)�[0;39m
case 8�[0;32m PASS: (cons* 1 2 3 4) equals (1 2 3 . 4)�[0;39m
case 9�[0;32m PASS: (cons* 1) equals 1�[0;39m
case 10�[0;32m PASS: (make-list 4 'c) equals (c c c c)�[0;39m
case 11�[0;32m PASS: (list-tabulate 4 values) equals (0 1 2 3)�[0;39m
case 12�[0;32m PASS: (iota 5) equals (0 1 2 3 4)�[0;39m
case 13 �[0;31mFAIL: (iota 5 0 -0.1)
   expected (0 -0.1 -0.2 -0.3 -0.4) but got (0 -0.1 -0.2 -0.3 -0.4)�[0;39m
case 14�[0;32m PASS: (pair? '(a . b)) equals #t�[0;39m
case 15�[0;32m PASS: (pair? '(a b c)) equals #t�[0;39m
case 16�[0;32m PASS: (pair? '()) equals #f�[0;39m
case 17�[0;32m PASS: (pair? '#(a b)) equals #f�[0;39m
case 18�[0;32m PASS: (pair? 7) equals #f�[0;39m
case 19�[0;32m PASS: (pair? 'a) equals #f�[0;39m
case 20�[0;32m PASS: (list= eq?) equals #t�[0;39m
case 21�[0;32m PASS: (list= eq? '(a)) equals #t�[0;39m
case 22�[0;32m PASS: (car '(a b c)) equals a�[0;39m
case 23�[0;32m PASS: (car '((a) b c d)) equals (a)�[0;39m
case 24�[0;32m PASS: (car '(1 . 2)) equals 1�[0;39m
case 25�[0;32m PASS: (error-object? (guard (exn (else exn)) (car '()))) equals #t�[0;39m
case 26�[0;32m PASS: (cdr '(a b c)) equals (b c)�[0;39m
case 27�[0;32m PASS: (cdr '((a) b c d)) equals (b c d)�[0;39m
case 28�[0;32m PASS: (cdr '(1 . 2)) equals 2�[0;39m
case 29�[0;32m PASS: (error-object? (guard (exn (else exn)) (cdr '()))) equals #t�[0;39m
case 30�[0;32m PASS: (list-ref '(a b c d) 2) equals c�[0;39m
case 31�[0;32m PASS: (take '(a b c d e) 2) equals (a b)�[0;39m
case 32�[0;32m PASS: (take '(1 2 3 . d) 2) equals (1 2)�[0;39m
case 33�[0;32m PASS: (take '(1 2 3 . d) 3) equals (1 2 3)�[0;39m
case 34�[0;32m PASS: (drop '(a b c d e) 2) equals (c d e)�[0;39m
case 35�[0;32m PASS: (drop '(1 2 3 . d) 2) equals (3 . d)�[0;39m
case 36�[0;32m PASS: (drop '(1 2 3 . d) 3) equals d�[0;39m
case 37�[0;32m PASS: (take-right '(a b c d e) 2) equals (d e)�[0;39m
case 38�[0;32m PASS: (drop-right '(a b c d e) 2) equals (a b c)�[0;39m
case 39�[0;32m PASS: (take! (circular-list 1 3 5) 8) equals (1 3)�[0;39m
case 40�[0;32m PASS: (last '(a b c)) equals c�[0;39m
case 41�[0;32m PASS: (last-pair '(a b c)) equals (c)�[0;39m
case 42�[0;32m PASS: (append '(x) '(y)) equals (x y)�[0;39m
case 43�[0;32m PASS: (append '(a) '(b c d)) equals (a b c d)�[0;39m
case 44�[0;32m PASS: (append '(a (b)) '((c))) equals (a (b) (c))�[0;39m
case 45�[0;32m PASS: (append '(a b) '(c . d)) equals (a b c . d)�[0;39m
case 46�[0;32m PASS: (append '() 'a) equals a�[0;39m
case 47�[0;32m PASS: (append '(x y)) equals (x y)�[0;39m
case 48�[0;32m PASS: (append) equals ()�[0;39m
case 49�[0;32m PASS: (reverse '(a b c)) equals (c b a)�[0;39m
case 50�[0;32m PASS: (reverse '(a (b c) d (e (f)))) equals ((e (f)) d (b c) a)�[0;39m
case 51�[0;32m PASS: (zip '(one two three) '(1 2 3) '(odd even odd even odd even odd even)) equals ((one 1 odd) (two 2 even) (three 3 odd))�[0;39m
case 52�[0;32m PASS: (zip '(1 2 3)) equals ((1) (2) (3))�[0;39m
case 53�[0;32m PASS: (zip '(3 1 4 1) (circular-list #f #t)) equals ((3 #f) (1 #t) (4 #f) (1 #t))�[0;39m
case 54�[0;32m PASS: (count even? '(3 1 4 1 5 9 2 5 6)) equals 3�[0;39m
case 55�[0;32m PASS: (count < '(1 2 4 8) '(2 4 6 8 10 12 14 16)) equals 3�[0;39m
case 56�[0;32m PASS: (count < '(3 1 4 1) (circular-list 1 10)) equals 2�[0;39m
case 57�[0;32m PASS: (pair-fold-right cons '() '(a b c)) equals ((a b c) (b c) (c))�[0;39m
case 58�[0;32m PASS: (map cadr '((a b) (d e) (g h))) equals (b e h)�[0;39m
case 59�[0;32m PASS: (map (lambda (n) (expt n n)) '(1 2 3 4 5)) equals (1 4 27 256 3125)�[0;39m
case 60�[0;32m PASS: (map + '(1 2 3) '(4 5 6)) equals (5 7 9)�[0;39m
case 61�[0;32m PASS: (map + '(3 1 4 1) (circular-list 1 0)) equals (4 1 5 1)�[0;39m
case 62�[0;32m PASS: (let ((v (make-vector 5))) (for-each (lambda (i) (vector-set! v i (* i i))) '(0 1 2 3 4)) v) equals #(0 1 4 9 16)�[0;39m
case 63�[0;32m PASS: (filter-map (lambda (x) (and (number? x) (* x x))) '(a 1 b 3 c 7)) equals (1 9 49)�[0;39m
case 64�[0;32m PASS: (filter even? '(0 7 8 8 43 -4)) equals (0 8 8 -4)�[0;39m
case 65�[0;32m PASS: (remove even? '(0 7 8 8 43 -4)) equals (7 43)�[0;39m
case 66�[0;32m PASS: (find even? '(3 1 4 1 5 9)) equals 4�[0;39m
case 67�[0;32m PASS: (find-tail even? '(3 1 37 -8 -5 0 0)) equals (-8 -5 0 0)�[0;39m
case 68�[0;32m PASS: (find-tail even? '(3 1 37 -5)) equals #f�[0;39m
case 69�[0;32m PASS: (take-while even? '(2 18 3 10 22 9)) equals (2 18)�[0;39m
case 70�[0;32m PASS: (drop-while even? '(2 18 3 10 22 9)) equals (3 10 22 9)�[0;39m
case 71�[0;32m PASS: (any integer? '(a 3 b 2.7)) equals #t�[0;39m
case 72�[0;32m PASS: (any integer? '(a 3.1 b 2.7)) equals #f�[0;39m
case 73�[0;32m PASS: (any < '(3 1 4 1 5) '(2 7 1 8 2)) equals #t�[0;39m
case 74�[0;32m PASS: (list-index even? '(3 1 4 1 5 9)) equals 2�[0;39m
case 75�[0;32m PASS: (member (list 'a) '(b (a) c)) equals ((a) c)�[0;39m
case 76�[0;32m PASS: (memq 'a '(a b c)) equals (a b c)�[0;39m
case 77�[0;32m PASS: (memq 'b '(a b c)) equals (b c)�[0;39m
case 78�[0;32m PASS: (memq 'a '(b c d)) equals #f�[0;39m
case 79�[0;32m PASS: (memq (list 'a) '(b (a) c)) equals #f�[0;39m
case 80�[0;32m PASS: (memv 101 '(100 101 102)) equals (101 102)�[0;39m
case 81�[0;32m PASS: (delete-duplicates '(a b a c a b c z)) equals (a b c z)�[0;39m
case 82�[0;32m PASS: (delete-duplicates '((a . 3) (b . 7) (a . 9) (c . 1)) (lambda (x y) (eq? (car x) (car y)))) equals ((a . 3) (b . 7) (c . 1))�[0;39m
case 83�[0;32m PASS: (assoc (list 'a) '(((a)) ((b)) ((c)))) equals ((a))�[0;39m
case 84�[0;32m PASS: (assq 'a e) equals (a 1)�[0;39m
case 85�[0;32m PASS: (assq 'b e) equals (b 2)�[0;39m
case 86�[0;32m PASS: (assq 'd e) equals #f�[0;39m
case 87�[0;32m PASS: (assq (list 'a) '(((a)) ((b)) ((c)))) equals #f�[0;39m
case 88�[0;32m PASS: (assv 5 '((2 3) (5 7) (11 13))) equals (5 7)�[0;39m
case 89�[0;32m PASS: (lset<= eq? '(a) '(a b a) '(a b c c)) equals #t�[0;39m
case 90�[0;32m PASS: (lset<= eq?) equals #t�[0;39m
case 91�[0;32m PASS: (lset<= eq? '(a)) equals #t�[0;39m
case 92�[0;32m PASS: (lset= eq? '(b e a) '(a e b) '(e e b a)) equals #t�[0;39m
case 93�[0;32m PASS: (lset= eq?) equals #t�[0;39m
case 94�[0;32m PASS: (lset= eq? '(a)) equals #t�[0;39m
case 95�[0;32m PASS: (lset-adjoin eq? '(a b c d c e) 'a 'e 'i 'o 'u) equals (u o i a b c d c e)�[0;39m
case 96�[0;32m PASS: (lset-union eq? '(a b c d e) '(a e i o u)) equals (u o i a b c d e)�[0;39m
case 97�[0;32m PASS: (lset-union eq? '(a a c) '(x a x)) equals (x a a c)�[0;39m
case 98�[0;32m PASS: (lset-union eq?) equals ()�[0;39m
case 99�[0;32m PASS: (lset-union eq? '(a b c)) equals (a b c)�[0;39m
case 100�[0;32m PASS: (lset-intersection eq? '(a b c d e) '(a e i o u)) equals (a e)�[0;39m
case 101�[0;32m PASS: (lset-intersection eq? '(a x y a) '(x a x z)) equals (a x a)�[0;39m
case 102�[0;32m PASS: (lset-intersection eq? '(a b c)) equals (a b c)�[0;39m
case 103�[0;32m PASS: (lset-difference eq? '(a b c d e) '(a e i o u)) equals (b c d)�[0;39m
case 104�[0;32m PASS: (lset-difference eq? '(a b c)) equals (a b c)�[0;39m
case 105�[0;32m PASS: (lset-xor eq? '(a b c d e) '(a e i o u)) equals (d c b i o u)�[0;39m
case 106�[0;32m PASS: (lset-xor eq?) equals ()�[0;39m
case 107�[0;32m PASS: (lset-xor eq? '(a b c d e)) equals (a b c d e)�[0;39m

�[0;34mTest Result: 107 / 108 (99.0741%) [PASS/TOTAL]�[0;39m
 �[0;31mFAIL: (iota 5 0 -0.1)
   expected (0 -0.1 -0.2 -0.3 -0.4) but got (0 -0.1 -0.2 -0.3 -0.4)�[0;39m
case 0�[0;32m PASS: (socket? '()) equals #f�[0;39m
error: "Connection refused"
  at (anonymous lambda) (native function)
  at (anonymous lambda) (unknown location)
  at (anonymous lambda) (native function)
make: *** [test-srfi] Error 1
@KeenS
Copy link
Member

KeenS commented Sep 6, 2015

@JeNeSuisPasDave
All of them are known failure. Some are failing because of bad test cases (but we don't know how to fix), some are failing because of picrin's incompleteness, and the others are OS X specific failure (again, we don't know how to fix).
Most of failure is in extension library so don' worry, picrin behaves fine in usual use cases.

@nyuichi
Copy link
Member

nyuichi commented Feb 7, 2016

fixed

@nyuichi nyuichi closed this as completed Feb 7, 2016
Sign up for free to subscribe to this conversation on GitHub. Already have an account? Sign in.
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
3 participants
@nyuichi @JeNeSuisPasDave @KeenS