| 1 |
;;;; `test.scm' Test correctness of scheme implementations. |
| 2 |
;;; Copyright (C) 1991, 1992, 1993, 1994, 1995 Aubrey Jaffer. |
| 3 |
|
| 4 |
;;; This includes examples from |
| 5 |
;;; William Clinger and Jonathan Rees, editors. |
| 6 |
;;; Revised^4 Report on the Algorithmic Language Scheme |
| 7 |
;;; and the IEEE specification. |
| 8 |
|
| 9 |
;;; The input tests read this file expecting it to be named "test.scm". |
| 10 |
;;; Files `tmp1', `tmp2' and `tmp3' will be created in the course of running |
| 11 |
;;; these tests. You may need to delete them in order to run |
| 12 |
;;; "test.scm" more than once. |
| 13 |
|
| 14 |
;;; There are three optional tests: |
| 15 |
;;; (TEST-CONT) tests multiple returns from call-with-current-continuation |
| 16 |
;;; |
| 17 |
;;; (TEST-SC4) tests procedures required by R4RS but not by IEEE |
| 18 |
;;; |
| 19 |
;;; (TEST-DELAY) tests DELAY and FORCE, which are not required by |
| 20 |
;;; either standard. |
| 21 |
|
| 22 |
;;; If you are testing a R3RS version which does not have `list?' do: |
| 23 |
;;; (define list? #f) |
| 24 |
|
| 25 |
;;; send corrections or additions to [email protected] or |
| 26 |
;;; Aubrey Jaffer, 84 Pleasant St., Wakefield MA 01880, USA |
| 27 |
|
| 28 |
(define cur-section '())(define errs '()) |
| 29 |
(define SECTION (lambda args |
| 30 |
(display "SECTION") (write args) (newline) |
| 31 |
(set! cur-section args) #t)) |
| 32 |
(define record-error (lambda (e) (set! errs (cons (list cur-section e) errs)))) |
| 33 |
|
| 34 |
(define test |
| 35 |
(lambda (expect fun . args) |
| 36 |
(write (cons fun args)) |
| 37 |
(display " ==> ") |
| 38 |
((lambda (res) |
| 39 |
(write res) |
| 40 |
(newline) |
| 41 |
(cond ((not (equal? expect res)) |
| 42 |
(record-error (list res expect (cons fun args))) |
| 43 |
(display " BUT EXPECTED ") |
| 44 |
(write expect) |
| 45 |
(newline) |
| 46 |
#f) |
| 47 |
(else #t))) |
| 48 |
(if (procedure? fun) (apply fun args) (car args))))) |
| 49 |
(define (report-errs) |
| 50 |
(newline) |
| 51 |
(if (null? errs) (display "Passed all tests") |
| 52 |
(begin |
| 53 |
(display "errors were:") |
| 54 |
(newline) |
| 55 |
(display "(SECTION (got expected (call)))") |
| 56 |
(newline) |
| 57 |
(for-each (lambda (l) (write l) (newline)) |
| 58 |
errs))) |
| 59 |
(newline)) |
| 60 |
|
| 61 |
(SECTION 2 1);; test that all symbol characters are supported. |
| 62 |
'(+ - ... !.. $.+ %.- &.! *.: /:. :+. <-. =. >. ?. ~. _. ^.) |
| 63 |
|
| 64 |
(SECTION 3 4) |
| 65 |
(define disjoint-type-functions |
| 66 |
(list boolean? char? null? number? pair? procedure? string? symbol? vector?)) |
| 67 |
(define type-examples |
| 68 |
(list |
| 69 |
#t #f #\a '() 9739 '(test) record-error "test" "" 'test '#() '#(a b c) )) |
| 70 |
(define i 1) |
| 71 |
(for-each (lambda (x) (display (make-string i #\ )) |
| 72 |
(set! i (+ 3 i)) |
| 73 |
(write x) |
| 74 |
(newline)) |
| 75 |
disjoint-type-functions) |
| 76 |
(define type-matrix |
| 77 |
(map (lambda (x) |
| 78 |
(let ((t (map (lambda (f) (f x)) disjoint-type-functions))) |
| 79 |
(write t) |
| 80 |
(write x) |
| 81 |
(newline) |
| 82 |
t)) |
| 83 |
type-examples)) |
| 84 |
(SECTION 4 1 2) |
| 85 |
(test '(quote a) 'quote (quote 'a)) |
| 86 |
(test '(quote a) 'quote ''a) |
| 87 |
(SECTION 4 1 3) |
| 88 |
(test 12 (if #f + *) 3 4) |
| 89 |
(SECTION 4 1 4) |
| 90 |
(test 8 (lambda (x) (+ x x)) 4) |
| 91 |
(define reverse-subtract |
| 92 |
(lambda (x y) (- y x))) |
| 93 |
(test 3 reverse-subtract 7 10) |
| 94 |
(define add4 |
| 95 |
(let ((x 4)) |
| 96 |
(lambda (y) (+ x y)))) |
| 97 |
(test 10 add4 6) |
| 98 |
(test '(3 4 5 6) (lambda x x) 3 4 5 6) |
| 99 |
(test '(5 6) (lambda (x y . z) z) 3 4 5 6) |
| 100 |
(SECTION 4 1 5) |
| 101 |
(test 'yes 'if (if (> 3 2) 'yes 'no)) |
| 102 |
(test 'no 'if (if (> 2 3) 'yes 'no)) |
| 103 |
(test '1 'if (if (> 3 2) (- 3 2) (+ 3 2))) |
| 104 |
(SECTION 4 1 6) |
| 105 |
(define x 2) |
| 106 |
(test 3 'define (+ x 1)) |
| 107 |
(set! x 4) |
| 108 |
(test 5 'set! (+ x 1)) |
| 109 |
(SECTION 4 2 1) |
| 110 |
(test 'greater 'cond (cond ((> 3 2) 'greater) |
| 111 |
((< 3 2) 'less))) |
| 112 |
(test 'equal 'cond (cond ((> 3 3) 'greater) |
| 113 |
((< 3 3) 'less) |
| 114 |
(else 'equal))) |
| 115 |
(test 2 'cond (cond ((assv 'b '((a 1) (b 2))) => cadr) |
| 116 |
(else #f))) |
| 117 |
(test 'composite 'case (case (* 2 3) |
| 118 |
((2 3 5 7) 'prime) |
| 119 |
((1 4 6 8 9) 'composite))) |
| 120 |
(test 'consonant 'case (case (car '(c d)) |
| 121 |
((a e i o u) 'vowel) |
| 122 |
((w y) 'semivowel) |
| 123 |
(else 'consonant))) |
| 124 |
(test #t 'and (and (= 2 2) (> 2 1))) |
| 125 |
(test #f 'and (and (= 2 2) (< 2 1))) |
| 126 |
(test '(f g) 'and (and 1 2 'c '(f g))) |
| 127 |
(test #t 'and (and)) |
| 128 |
(test #t 'or (or (= 2 2) (> 2 1))) |
| 129 |
(test #t 'or (or (= 2 2) (< 2 1))) |
| 130 |
(test #f 'or (or #f #f #f)) |
| 131 |
(test #f 'or (or)) |
| 132 |
(test '(b c) 'or (or (memq 'b '(a b c)) (+ 3 0))) |
| 133 |
(SECTION 4 2 2) |
| 134 |
(test 6 'let (let ((x 2) (y 3)) (* x y))) |
| 135 |
(test 35 'let (let ((x 2) (y 3)) (let ((x 7) (z (+ x y))) (* z x)))) |
| 136 |
(test 70 'let* (let ((x 2) (y 3)) (let* ((x 7) (z (+ x y))) (* z x)))) |
| 137 |
(test #t 'letrec (letrec ((even? |
| 138 |
(lambda (n) (if (zero? n) #t (odd? (- n 1))))) |
| 139 |
(odd? |
| 140 |
(lambda (n) (if (zero? n) #f (even? (- n 1)))))) |
| 141 |
(even? 88))) |
| 142 |
(define x 34) |
| 143 |
(test 5 'let (let ((x 3)) (define x 5) x)) |
| 144 |
(test 34 'let x) |
| 145 |
(test 6 'let (let () (define x 6) x)) |
| 146 |
(test 34 'let x) |
| 147 |
(test 7 'let* (let* ((x 3)) (define x 7) x)) |
| 148 |
(test 34 'let* x) |
| 149 |
(test 8 'let* (let* () (define x 8) x)) |
| 150 |
(test 34 'let* x) |
| 151 |
(test 9 'letrec (letrec () (define x 9) x)) |
| 152 |
(test 34 'letrec x) |
| 153 |
(test 10 'letrec (letrec ((x 3)) (define x 10) x)) |
| 154 |
(test 34 'letrec x) |
| 155 |
(SECTION 4 2 3) |
| 156 |
(define x 0) |
| 157 |
(test 6 'begin (begin (set! x 5) (+ x 1))) |
| 158 |
(SECTION 4 2 4) |
| 159 |
(test '#(0 1 2 3 4) 'do (do ((vec (make-vector 5)) |
| 160 |
(i 0 (+ i 1))) |
| 161 |
((= i 5) vec) |
| 162 |
(vector-set! vec i i))) |
| 163 |
(test 25 'do (let ((x '(1 3 5 7 9))) |
| 164 |
(do ((x x (cdr x)) |
| 165 |
(sum 0 (+ sum (car x)))) |
| 166 |
((null? x) sum)))) |
| 167 |
(test 1 'let (let foo () 1)) |
| 168 |
(test '((6 1 3) (-5 -2)) 'let |
| 169 |
(let loop ((numbers '(3 -2 1 6 -5)) |
| 170 |
(nonneg '()) |
| 171 |
(neg '())) |
| 172 |
(cond ((null? numbers) (list nonneg neg)) |
| 173 |
((negative? (car numbers)) |
| 174 |
(loop (cdr numbers) |
| 175 |
nonneg |
| 176 |
(cons (car numbers) neg))) |
| 177 |
(else |
| 178 |
(loop (cdr numbers) |
| 179 |
(cons (car numbers) nonneg) |
| 180 |
neg))))) |
| 181 |
(SECTION 4 2 6) |
| 182 |
(test '(list 3 4) 'quasiquote `(list ,(+ 1 2) 4)) |
| 183 |
(test '(list a (quote a)) 'quasiquote (let ((name 'a)) `(list ,name ',name))) |
| 184 |
(test '(a 3 4 5 6 b) 'quasiquote `(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b)) |
| 185 |
(test '((foo 7) . cons) |
| 186 |
'quasiquote |
| 187 |
`((foo ,(- 10 3)) ,@(cdr '(c)) . ,(car '(cons)))) |
| 188 |
|
| 189 |
;;; sqt is defined here because not all implementations are required to |
| 190 |
;;; support it. |
| 191 |
(define (sqt x) |
| 192 |
(do ((i 0 (+ i 1))) |
| 193 |
((> (* i i) x) (- i 1)))) |
| 194 |
|
| 195 |
(test '#(10 5 2 4 3 8) 'quasiquote `#(10 5 ,(sqt 4) ,@(map sqt '(16 9)) 8)) |
| 196 |
(test 5 'quasiquote `,(+ 2 3)) |
| 197 |
(test '(a `(b ,(+ 1 2) ,(foo 4 d) e) f) |
| 198 |
'quasiquote `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)) |
| 199 |
(test '(a `(b ,x ,'y d) e) 'quasiquote |
| 200 |
(let ((name1 'x) (name2 'y)) `(a `(b ,,name1 ,',name2 d) e))) |
| 201 |
(test '(list 3 4) 'quasiquote (quasiquote (list (unquote (+ 1 2)) 4))) |
| 202 |
(test '`(list ,(+ 1 2) 4) 'quasiquote '(quasiquote (list (unquote (+ 1 2)) 4))) |
| 203 |
(SECTION 5 2 1) |
| 204 |
(define add3 (lambda (x) (+ x 3))) |
| 205 |
(test 6 'define (add3 3)) |
| 206 |
(define first car) |
| 207 |
(test 1 'define (first '(1 2))) |
| 208 |
(SECTION 5 2 2) |
| 209 |
(test 45 'define |
| 210 |
(let ((x 5)) |
| 211 |
(define foo (lambda (y) (bar x y))) |
| 212 |
(define bar (lambda (a b) (+ (* a b) a))) |
| 213 |
(foo (+ x 3)))) |
| 214 |
(define x 34) |
| 215 |
(define (foo) (define x 5) x) |
| 216 |
(test 5 foo) |
| 217 |
(test 34 'define x) |
| 218 |
(define foo (lambda () (define x 5) x)) |
| 219 |
(test 5 foo) |
| 220 |
(test 34 'define x) |
| 221 |
(define (foo x) ((lambda () (define x 5) x)) x) |
| 222 |
(test 88 foo 88) |
| 223 |
(test 4 foo 4) |
| 224 |
(test 34 'define x) |
| 225 |
(SECTION 6 1) |
| 226 |
(test #f not #t) |
| 227 |
(test #f not 3) |
| 228 |
(test #f not (list 3)) |
| 229 |
(test #t not #f) |
| 230 |
(test #f not '()) |
| 231 |
(test #f not (list)) |
| 232 |
(test #f not 'nil) |
| 233 |
|
| 234 |
(test #t boolean? #f) |
| 235 |
(test #f boolean? 0) |
| 236 |
(test #f boolean? '()) |
| 237 |
(SECTION 6 2) |
| 238 |
(test #t eqv? 'a 'a) |
| 239 |
(test #f eqv? 'a 'b) |
| 240 |
(test #t eqv? 2 2) |
| 241 |
(test #t eqv? '() '()) |
| 242 |
(test #t eqv? '10000 '10000) |
| 243 |
(test #f eqv? (cons 1 2)(cons 1 2)) |
| 244 |
(test #f eqv? (lambda () 1) (lambda () 2)) |
| 245 |
(test #f eqv? #f 'nil) |
| 246 |
(let ((p (lambda (x) x))) |
| 247 |
(test #t eqv? p p)) |
| 248 |
(define gen-counter |
| 249 |
(lambda () |
| 250 |
(let ((n 0)) |
| 251 |
(lambda () (set! n (+ n 1)) n)))) |
| 252 |
(let ((g (gen-counter))) (test #t eqv? g g)) |
| 253 |
(test #f eqv? (gen-counter) (gen-counter)) |
| 254 |
(letrec ((f (lambda () (if (eqv? f g) 'f 'both))) |
| 255 |
(g (lambda () (if (eqv? f g) 'g 'both)))) |
| 256 |
(test #f eqv? f g)) |
| 257 |
|
| 258 |
(test #t eq? 'a 'a) |
| 259 |
(test #f eq? (list 'a) (list 'a)) |
| 260 |
(test #t eq? '() '()) |
| 261 |
(test #t eq? car car) |
| 262 |
(let ((x '(a))) (test #t eq? x x)) |
| 263 |
(let ((x '#())) (test #t eq? x x)) |
| 264 |
(let ((x (lambda (x) x))) (test #t eq? x x)) |
| 265 |
|
| 266 |
(test #t equal? 'a 'a) |
| 267 |
(test #t equal? '(a) '(a)) |
| 268 |
(test #t equal? '(a (b) c) '(a (b) c)) |
| 269 |
(test #t equal? "abc" "abc") |
| 270 |
(test #t equal? 2 2) |
| 271 |
(test #t equal? (make-vector 5 'a) (make-vector 5 'a)) |
| 272 |
(SECTION 6 3) |
| 273 |
(test '(a b c d e) 'dot '(a . (b . (c . (d . (e . ())))))) |
| 274 |
(define x (list 'a 'b 'c)) |
| 275 |
(define y x) |
| 276 |
(and list? (test #t list? y)) |
| 277 |
(set-cdr! x 4) |
| 278 |
(test '(a . 4) 'set-cdr! x) |
| 279 |
(test #t eqv? x y) |
| 280 |
(test '(a b c . d) 'dot '(a . (b . (c . d)))) |
| 281 |
(and list? (test #f list? y)) |
| 282 |
(and list? (let ((x (list 'a))) (set-cdr! x x) (test #f 'list? (list? x)))) |
| 283 |
|
| 284 |
(test #t pair? '(a . b)) |
| 285 |
(test #t pair? '(a . 1)) |
| 286 |
(test #t pair? '(a b c)) |
| 287 |
(test #f pair? '()) |
| 288 |
(test #f pair? '#(a b)) |
| 289 |
|
| 290 |
(test '(a) cons 'a '()) |
| 291 |
(test '((a) b c d) cons '(a) '(b c d)) |
| 292 |
(test '("a" b c) cons "a" '(b c)) |
| 293 |
(test '(a . 3) cons 'a 3) |
| 294 |
(test '((a b) . c) cons '(a b) 'c) |
| 295 |
|
| 296 |
(test 'a car '(a b c)) |
| 297 |
(test '(a) car '((a) b c d)) |
| 298 |
(test 1 car '(1 . 2)) |
| 299 |
|
| 300 |
(test '(b c d) cdr '((a) b c d)) |
| 301 |
(test 2 cdr '(1 . 2)) |
| 302 |
|
| 303 |
(test '(a 7 c) list 'a (+ 3 4) 'c) |
| 304 |
(test '() list) |
| 305 |
|
| 306 |
(test 3 length '(a b c)) |
| 307 |
(test 3 length '(a (b) (c d e))) |
| 308 |
(test 0 length '()) |
| 309 |
|
| 310 |
(test '(x y) append '(x) '(y)) |
| 311 |
(test '(a b c d) append '(a) '(b c d)) |
| 312 |
(test '(a (b) (c)) append '(a (b)) '((c))) |
| 313 |
(test '() append) |
| 314 |
(test '(a b c . d) append '(a b) '(c . d)) |
| 315 |
(test 'a append '() 'a) |
| 316 |
|
| 317 |
(test '(c b a) reverse '(a b c)) |
| 318 |
(test '((e (f)) d (b c) a) reverse '(a (b c) d (e (f)))) |
| 319 |
|
| 320 |
(test 'c list-ref '(a b c d) 2) |
| 321 |
|
| 322 |
(test '(a b c) memq 'a '(a b c)) |
| 323 |
(test '(b c) memq 'b '(a b c)) |
| 324 |
(test '#f memq 'a '(b c d)) |
| 325 |
(test '#f memq (list 'a) '(b (a) c)) |
| 326 |
(test '((a) c) member (list 'a) '(b (a) c)) |
| 327 |
(test '(101 102) memv 101 '(100 101 102)) |
| 328 |
|
| 329 |
(define e '((a 1) (b 2) (c 3))) |
| 330 |
(test '(a 1) assq 'a e) |
| 331 |
(test '(b 2) assq 'b e) |
| 332 |
(test #f assq 'd e) |
| 333 |
(test #f assq (list 'a) '(((a)) ((b)) ((c)))) |
| 334 |
(test '((a)) assoc (list 'a) '(((a)) ((b)) ((c)))) |
| 335 |
(test '(5 7) assv 5 '((2 3) (5 7) (11 13))) |
| 336 |
(SECTION 6 4) |
| 337 |
(test #t symbol? 'foo) |
| 338 |
(test #t symbol? (car '(a b))) |
| 339 |
(test #f symbol? "bar") |
| 340 |
(test #t symbol? 'nil) |
| 341 |
(test #f symbol? '()) |
| 342 |
(test #f symbol? #f) |
| 343 |
;;; But first, what case are symbols in? Determine the standard case: |
| 344 |
(define char-standard-case char-upcase) |
| 345 |
(if (string=? (symbol->string 'A) "a") |
| 346 |
(set! char-standard-case char-downcase)) |
| 347 |
(test #t 'standard-case |
| 348 |
(string=? (symbol->string 'a) (symbol->string 'A))) |
| 349 |
(test #t 'standard-case |
| 350 |
(or (string=? (symbol->string 'a) "A") |
| 351 |
(string=? (symbol->string 'A) "a"))) |
| 352 |
(define (str-copy s) |
| 353 |
(let ((v (make-string (string-length s)))) |
| 354 |
(do ((i (- (string-length v) 1) (- i 1))) |
| 355 |
((< i 0) v) |
| 356 |
(string-set! v i (string-ref s i))))) |
| 357 |
(define (string-standard-case s) |
| 358 |
(set! s (str-copy s)) |
| 359 |
(do ((i 0 (+ 1 i)) |
| 360 |
(sl (string-length s))) |
| 361 |
((>= i sl) s) |
| 362 |
(string-set! s i (char-standard-case (string-ref s i))))) |
| 363 |
(test (string-standard-case "flying-fish") symbol->string 'flying-fish) |
| 364 |
(test (string-standard-case "martin") symbol->string 'Martin) |
| 365 |
(test "Malvina" symbol->string (string->symbol "Malvina")) |
| 366 |
(test #t 'standard-case (eq? 'a 'A)) |
| 367 |
|
| 368 |
(define x (string #\a #\b)) |
| 369 |
(define y (string->symbol x)) |
| 370 |
(string-set! x 0 #\c) |
| 371 |
(test "cb" 'string-set! x) |
| 372 |
(test "ab" symbol->string y) |
| 373 |
(test y string->symbol "ab") |
| 374 |
|
| 375 |
(test #t eq? 'mISSISSIppi 'mississippi) |
| 376 |
(test #f 'string->symbol (eq? 'bitBlt (string->symbol "bitBlt"))) |
| 377 |
(test 'JollyWog string->symbol (symbol->string 'JollyWog)) |
| 378 |
|
| 379 |
(SECTION 6 5 5) |
| 380 |
(test #t number? 3) |
| 381 |
(test #t complex? 3) |
| 382 |
(test #t real? 3) |
| 383 |
(test #t rational? 3) |
| 384 |
(test #t integer? 3) |
| 385 |
|
| 386 |
(test #t exact? 3) |
| 387 |
(test #f inexact? 3) |
| 388 |
|
| 389 |
(test #t = 22 22 22) |
| 390 |
(test #t = 22 22) |
| 391 |
(test #f = 34 34 35) |
| 392 |
(test #f = 34 35) |
| 393 |
(test #t > 3 -6246) |
| 394 |
(test #f > 9 9 -2424) |
| 395 |
(test #t >= 3 -4 -6246) |
| 396 |
(test #t >= 9 9) |
| 397 |
(test #f >= 8 9) |
| 398 |
(test #t < -1 2 3 4 5 6 7 8) |
| 399 |
(test #f < -1 2 3 4 4 5 6 7) |
| 400 |
(test #t <= -1 2 3 4 5 6 7 8) |
| 401 |
(test #t <= -1 2 3 4 4 5 6 7) |
| 402 |
(test #f < 1 3 2) |
| 403 |
(test #f >= 1 3 2) |
| 404 |
|
| 405 |
(test #t zero? 0) |
| 406 |
(test #f zero? 1) |
| 407 |
(test #f zero? -1) |
| 408 |
(test #f zero? -100) |
| 409 |
(test #t positive? 4) |
| 410 |
(test #f positive? -4) |
| 411 |
(test #f positive? 0) |
| 412 |
(test #f negative? 4) |
| 413 |
(test #t negative? -4) |
| 414 |
(test #f negative? 0) |
| 415 |
(test #t odd? 3) |
| 416 |
(test #f odd? 2) |
| 417 |
(test #f odd? -4) |
| 418 |
(test #t odd? -1) |
| 419 |
(test #f even? 3) |
| 420 |
(test #t even? 2) |
| 421 |
(test #t even? -4) |
| 422 |
(test #f even? -1) |
| 423 |
|
| 424 |
(test 38 max 34 5 7 38 6) |
| 425 |
(test -24 min 3 5 5 330 4 -24) |
| 426 |
|
| 427 |
(test 7 + 3 4) |
| 428 |
(test '3 + 3) |
| 429 |
(test 0 +) |
| 430 |
(test 4 * 4) |
| 431 |
(test 1 *) |
| 432 |
|
| 433 |
(test -1 - 3 4) |
| 434 |
(test -3 - 3) |
| 435 |
(test 7 abs -7) |
| 436 |
(test 7 abs 7) |
| 437 |
(test 0 abs 0) |
| 438 |
|
| 439 |
(test 5 quotient 35 7) |
| 440 |
(test -5 quotient -35 7) |
| 441 |
(test -5 quotient 35 -7) |
| 442 |
(test 5 quotient -35 -7) |
| 443 |
(test 1 modulo 13 4) |
| 444 |
(test 1 remainder 13 4) |
| 445 |
(test 3 modulo -13 4) |
| 446 |
(test -1 remainder -13 4) |
| 447 |
(test -3 modulo 13 -4) |
| 448 |
(test 1 remainder 13 -4) |
| 449 |
(test -1 modulo -13 -4) |
| 450 |
(test -1 remainder -13 -4) |
| 451 |
(define (divtest n1 n2) |
| 452 |
(= n1 (+ (* n2 (quotient n1 n2)) |
| 453 |
(remainder n1 n2)))) |
| 454 |
(test #t divtest 238 9) |
| 455 |
(test #t divtest -238 9) |
| 456 |
(test #t divtest 238 -9) |
| 457 |
(test #t divtest -238 -9) |
| 458 |
|
| 459 |
(test 4 gcd 0 4) |
| 460 |
(test 4 gcd -4 0) |
| 461 |
(test 4 gcd 32 -36) |
| 462 |
(test 0 gcd) |
| 463 |
(test 288 lcm 32 -36) |
| 464 |
(test 1 lcm) |
| 465 |
|
| 466 |
;;;;From: [email protected] (Fred J Kaudel) |
| 467 |
;;; Modified by jaffer. |
| 468 |
(define (test-inexact) |
| 469 |
(define f3.9 (string->number "3.9")) |
| 470 |
(define f4.0 (string->number "4.0")) |
| 471 |
(define f-3.25 (string->number "-3.25")) |
| 472 |
(define f.25 (string->number ".25")) |
| 473 |
(define f4.5 (string->number "4.5")) |
| 474 |
(define f3.5 (string->number "3.5")) |
| 475 |
(define f0.0 (string->number "0.0")) |
| 476 |
(define f0.8 (string->number "0.8")) |
| 477 |
(define f1.0 (string->number "1.0")) |
| 478 |
(define wto write-test-obj) |
| 479 |
(define dto display-test-obj) |
| 480 |
(define lto load-test-obj) |
| 481 |
(newline) |
| 482 |
(display ";testing inexact numbers; ") |
| 483 |
(newline) |
| 484 |
(SECTION 6 5 5) |
| 485 |
(test #t inexact? f3.9) |
| 486 |
(test #t 'inexact? (inexact? (max f3.9 4))) |
| 487 |
(test f4.0 'max (max f3.9 4)) |
| 488 |
(test f4.0 'exact->inexact (exact->inexact 4)) |
| 489 |
(test (- f4.0) round (- f4.5)) |
| 490 |
(test (- f4.0) round (- f3.5)) |
| 491 |
(test (- f4.0) round (- f3.9)) |
| 492 |
(test f0.0 round f0.0) |
| 493 |
(test f0.0 round f.25) |
| 494 |
(test f1.0 round f0.8) |
| 495 |
(test f4.0 round f3.5) |
| 496 |
(test f4.0 round f4.5) |
| 497 |
(set! write-test-obj (list f.25 f-3.25));.25 inexact errors less likely. |
| 498 |
(set! display-test-obj (list f.25 f-3.25));.3 often has such errors (~10^-13) |
| 499 |
(set! load-test-obj (list 'define 'foo (list 'quote write-test-obj))) |
| 500 |
(test #t call-with-output-file |
| 501 |
"tmp3" |
| 502 |
(lambda (test-file) |
| 503 |
(write-char #\; test-file) |
| 504 |
(display write-test-obj test-file) |
| 505 |
(newline test-file) |
| 506 |
(write load-test-obj test-file) |
| 507 |
(output-port? test-file))) |
| 508 |
(check-test-file "tmp3") |
| 509 |
(set! write-test-obj wto) |
| 510 |
(set! display-test-obj dto) |
| 511 |
(set! load-test-obj lto) |
| 512 |
(let ((x (string->number "4195835.0")) |
| 513 |
(y (string->number "3145727.0"))) |
| 514 |
(test #t 'pentium-fdiv-bug (> f1.0 (- x (* (/ x y) y))))) |
| 515 |
(report-errs)) |
| 516 |
|
| 517 |
(define (test-bignum) |
| 518 |
(define tb |
| 519 |
(lambda (n1 n2) |
| 520 |
(= n1 (+ (* n2 (quotient n1 n2)) |
| 521 |
(remainder n1 n2))))) |
| 522 |
(newline) |
| 523 |
(display ";testing bignums; ") |
| 524 |
(newline) |
| 525 |
(section 6 5 5) |
| 526 |
(test 0 modulo -2177452800 86400) |
| 527 |
(test 0 modulo 2177452800 -86400) |
| 528 |
(test 0 modulo 2177452800 86400) |
| 529 |
(test 0 modulo -2177452800 -86400) |
| 530 |
(test #t 'remainder (tb 281474976710655 65535)) |
| 531 |
(test #t 'remainder (tb 281474976710654 65535)) |
| 532 |
(SECTION 6 5 6) |
| 533 |
(test 281474976710655 string->number "281474976710655") |
| 534 |
(test "281474976710655" number->string 281474976710655) |
| 535 |
(report-errs)) |
| 536 |
|
| 537 |
(SECTION 6 5 6) |
| 538 |
(test "0" number->string 0) |
| 539 |
(test "100" number->string 100) |
| 540 |
(test "100" number->string 256 16) |
| 541 |
(test 100 string->number "100") |
| 542 |
(test 256 string->number "100" 16) |
| 543 |
(test #f string->number "") |
| 544 |
(test #f string->number ".") |
| 545 |
(test #f string->number "d") |
| 546 |
(test #f string->number "D") |
| 547 |
(test #f string->number "i") |
| 548 |
(test #f string->number "I") |
| 549 |
(test #f string->number "3i") |
| 550 |
(test #f string->number "3I") |
| 551 |
(test #f string->number "33i") |
| 552 |
(test #f string->number "33I") |
| 553 |
(test #f string->number "3.3i") |
| 554 |
(test #f string->number "3.3I") |
| 555 |
(test #f string->number "-") |
| 556 |
(test #f string->number "+") |
| 557 |
|
| 558 |
(SECTION 6 6) |
| 559 |
(test #t eqv? '#\ #\Space) |
| 560 |
(test #t eqv? #\space '#\Space) |
| 561 |
(test #t char? #\a) |
| 562 |
(test #t char? #\() |
| 563 |
(test #t char? #\ ) |
| 564 |
(test #t char? '#\newline) |
| 565 |
|
| 566 |
(test #f char=? #\A #\B) |
| 567 |
(test #f char=? #\a #\b) |
| 568 |
(test #f char=? #\9 #\0) |
| 569 |
(test #t char=? #\A #\A) |
| 570 |
|
| 571 |
(test #t char<? #\A #\B) |
| 572 |
(test #t char<? #\a #\b) |
| 573 |
(test #f char<? #\9 #\0) |
| 574 |
(test #f char<? #\A #\A) |
| 575 |
|
| 576 |
(test #f char>? #\A #\B) |
| 577 |
(test #f char>? #\a #\b) |
| 578 |
(test #t char>? #\9 #\0) |
| 579 |
(test #f char>? #\A #\A) |
| 580 |
|
| 581 |
(test #t char<=? #\A #\B) |
| 582 |
(test #t char<=? #\a #\b) |
| 583 |
(test #f char<=? #\9 #\0) |
| 584 |
(test #t char<=? #\A #\A) |
| 585 |
|
| 586 |
(test #f char>=? #\A #\B) |
| 587 |
(test #f char>=? #\a #\b) |
| 588 |
(test #t char>=? #\9 #\0) |
| 589 |
(test #t char>=? #\A #\A) |
| 590 |
|
| 591 |
(test #f char-ci=? #\A #\B) |
| 592 |
(test #f char-ci=? #\a #\B) |
| 593 |
(test #f char-ci=? #\A #\b) |
| 594 |
(test #f char-ci=? #\a #\b) |
| 595 |
(test #f char-ci=? #\9 #\0) |
| 596 |
(test #t char-ci=? #\A #\A) |
| 597 |
(test #t char-ci=? #\A #\a) |
| 598 |
|
| 599 |
(test #t char-ci<? #\A #\B) |
| 600 |
(test #t char-ci<? #\a #\B) |
| 601 |
(test #t char-ci<? #\A #\b) |
| 602 |
(test #t char-ci<? #\a #\b) |
| 603 |
(test #f char-ci<? #\9 #\0) |
| 604 |
(test #f char-ci<? #\A #\A) |
| 605 |
(test #f char-ci<? #\A #\a) |
| 606 |
|
| 607 |
(test #f char-ci>? #\A #\B) |
| 608 |
(test #f char-ci>? #\a #\B) |
| 609 |
(test #f char-ci>? #\A #\b) |
| 610 |
(test #f char-ci>? #\a #\b) |
| 611 |
(test #t char-ci>? #\9 #\0) |
| 612 |
(test #f char-ci>? #\A #\A) |
| 613 |
(test #f char-ci>? #\A #\a) |
| 614 |
|
| 615 |
(test #t char-ci<=? #\A #\B) |
| 616 |
(test #t char-ci<=? #\a #\B) |
| 617 |
(test #t char-ci<=? #\A #\b) |
| 618 |
(test #t char-ci<=? #\a #\b) |
| 619 |
(test #f char-ci<=? #\9 #\0) |
| 620 |
(test #t char-ci<=? #\A #\A) |
| 621 |
(test #t char-ci<=? #\A #\a) |
| 622 |
|
| 623 |
(test #f char-ci>=? #\A #\B) |
| 624 |
(test #f char-ci>=? #\a #\B) |
| 625 |
(test #f char-ci>=? #\A #\b) |
| 626 |
(test #f char-ci>=? #\a #\b) |
| 627 |
(test #t char-ci>=? #\9 #\0) |
| 628 |
(test #t char-ci>=? #\A #\A) |
| 629 |
(test #t char-ci>=? #\A #\a) |
| 630 |
|
| 631 |
(test #t char-alphabetic? #\a) |
| 632 |
(test #t char-alphabetic? #\A) |
| 633 |
(test #t char-alphabetic? #\z) |
| 634 |
(test #t char-alphabetic? #\Z) |
| 635 |
(test #f char-alphabetic? #\0) |
| 636 |
(test #f char-alphabetic? #\9) |
| 637 |
(test #f char-alphabetic? #\space) |
| 638 |
(test #f char-alphabetic? #\;) |
| 639 |
|
| 640 |
(test #f char-numeric? #\a) |
| 641 |
(test #f char-numeric? #\A) |
| 642 |
(test #f char-numeric? #\z) |
| 643 |
(test #f char-numeric? #\Z) |
| 644 |
(test #t char-numeric? #\0) |
| 645 |
(test #t char-numeric? #\9) |
| 646 |
(test #f char-numeric? #\space) |
| 647 |
(test #f char-numeric? #\;) |
| 648 |
|
| 649 |
(test #f char-whitespace? #\a) |
| 650 |
(test #f char-whitespace? #\A) |
| 651 |
(test #f char-whitespace? #\z) |
| 652 |
(test #f char-whitespace? #\Z) |
| 653 |
(test #f char-whitespace? #\0) |
| 654 |
(test #f char-whitespace? #\9) |
| 655 |
(test #t char-whitespace? #\space) |
| 656 |
(test #f char-whitespace? #\;) |
| 657 |
|
| 658 |
(test #f char-upper-case? #\0) |
| 659 |
(test #f char-upper-case? #\9) |
| 660 |
(test #f char-upper-case? #\space) |
| 661 |
(test #f char-upper-case? #\;) |
| 662 |
|
| 663 |
(test #f char-lower-case? #\0) |
| 664 |
(test #f char-lower-case? #\9) |
| 665 |
(test #f char-lower-case? #\space) |
| 666 |
(test #f char-lower-case? #\;) |
| 667 |
|
| 668 |
(test #\. integer->char (char->integer #\.)) |
| 669 |
(test #\A integer->char (char->integer #\A)) |
| 670 |
(test #\a integer->char (char->integer #\a)) |
| 671 |
(test #\A char-upcase #\A) |
| 672 |
(test #\A char-upcase #\a) |
| 673 |
(test #\a char-downcase #\A) |
| 674 |
(test #\a char-downcase #\a) |
| 675 |
(SECTION 6 7) |
| 676 |
(test #t string? "The word \"recursion\\\" has many meanings.") |
| 677 |
(test #t string? "") |
| 678 |
(define f (make-string 3 #\*)) |
| 679 |
(test "?**" 'string-set! (begin (string-set! f 0 #\?) f)) |
| 680 |
(test "abc" string #\a #\b #\c) |
| 681 |
(test "" string) |
| 682 |
(test 3 string-length "abc") |
| 683 |
(test #\a string-ref "abc" 0) |
| 684 |
(test #\c string-ref "abc" 2) |
| 685 |
(test 0 string-length "") |
| 686 |
(test "" substring "ab" 0 0) |
| 687 |
(test "" substring "ab" 1 1) |
| 688 |
(test "" substring "ab" 2 2) |
| 689 |
(test "a" substring "ab" 0 1) |
| 690 |
(test "b" substring "ab" 1 2) |
| 691 |
(test "ab" substring "ab" 0 2) |
| 692 |
(test "foobar" string-append "foo" "bar") |
| 693 |
(test "foo" string-append "foo") |
| 694 |
(test "foo" string-append "foo" "") |
| 695 |
(test "foo" string-append "" "foo") |
| 696 |
(test "" string-append) |
| 697 |
(test "" make-string 0) |
| 698 |
(test #t string=? "" "") |
| 699 |
(test #f string<? "" "") |
| 700 |
(test #f string>? "" "") |
| 701 |
(test #t string<=? "" "") |
| 702 |
(test #t string>=? "" "") |
| 703 |
(test #t string-ci=? "" "") |
| 704 |
(test #f string-ci<? "" "") |
| 705 |
(test #f string-ci>? "" "") |
| 706 |
(test #t string-ci<=? "" "") |
| 707 |
(test #t string-ci>=? "" "") |
| 708 |
|
| 709 |
(test #f string=? "A" "B") |
| 710 |
(test #f string=? "a" "b") |
| 711 |
(test #f string=? "9" "0") |
| 712 |
(test #t string=? "A" "A") |
| 713 |
|
| 714 |
(test #t string<? "A" "B") |
| 715 |
(test #t string<? "a" "b") |
| 716 |
(test #f string<? "9" "0") |
| 717 |
(test #f string<? "A" "A") |
| 718 |
|
| 719 |
(test #f string>? "A" "B") |
| 720 |
(test #f string>? "a" "b") |
| 721 |
(test #t string>? "9" "0") |
| 722 |
(test #f string>? "A" "A") |
| 723 |
|
| 724 |
(test #t string<=? "A" "B") |
| 725 |
(test #t string<=? "a" "b") |
| 726 |
(test #f string<=? "9" "0") |
| 727 |
(test #t string<=? "A" "A") |
| 728 |
|
| 729 |
(test #f string>=? "A" "B") |
| 730 |
(test #f string>=? "a" "b") |
| 731 |
(test #t string>=? "9" "0") |
| 732 |
(test #t string>=? "A" "A") |
| 733 |
|
| 734 |
(test #f string-ci=? "A" "B") |
| 735 |
(test #f string-ci=? "a" "B") |
| 736 |
(test #f string-ci=? "A" "b") |
| 737 |
(test #f string-ci=? "a" "b") |
| 738 |
(test #f string-ci=? "9" "0") |
| 739 |
(test #t string-ci=? "A" "A") |
| 740 |
(test #t string-ci=? "A" "a") |
| 741 |
|
| 742 |
(test #t string-ci<? "A" "B") |
| 743 |
(test #t string-ci<? "a" "B") |
| 744 |
(test #t string-ci<? "A" "b") |
| 745 |
(test #t string-ci<? "a" "b") |
| 746 |
(test #f string-ci<? "9" "0") |
| 747 |
(test #f string-ci<? "A" "A") |
| 748 |
(test #f string-ci<? "A" "a") |
| 749 |
|
| 750 |
(test #f string-ci>? "A" "B") |
| 751 |
(test #f string-ci>? "a" "B") |
| 752 |
(test #f string-ci>? "A" "b") |
| 753 |
(test #f string-ci>? "a" "b") |
| 754 |
(test #t string-ci>? "9" "0") |
| 755 |
(test #f string-ci>? "A" "A") |
| 756 |
(test #f string-ci>? "A" "a") |
| 757 |
|
| 758 |
(test #t string-ci<=? "A" "B") |
| 759 |
(test #t string-ci<=? "a" "B") |
| 760 |
(test #t string-ci<=? "A" "b") |
| 761 |
(test #t string-ci<=? "a" "b") |
| 762 |
(test #f string-ci<=? "9" "0") |
| 763 |
(test #t string-ci<=? "A" "A") |
| 764 |
(test #t string-ci<=? "A" "a") |
| 765 |
|
| 766 |
(test #f string-ci>=? "A" "B") |
| 767 |
(test #f string-ci>=? "a" "B") |
| 768 |
(test #f string-ci>=? "A" "b") |
| 769 |
(test #f string-ci>=? "a" "b") |
| 770 |
(test #t string-ci>=? "9" "0") |
| 771 |
(test #t string-ci>=? "A" "A") |
| 772 |
(test #t string-ci>=? "A" "a") |
| 773 |
(SECTION 6 8) |
| 774 |
(test #t vector? '#(0 (2 2 2 2) "Anna")) |
| 775 |
(test #t vector? '#()) |
| 776 |
(test '#(a b c) vector 'a 'b 'c) |
| 777 |
(test '#() vector) |
| 778 |
(test 3 vector-length '#(0 (2 2 2 2) "Anna")) |
| 779 |
(test 0 vector-length '#()) |
| 780 |
(test 8 vector-ref '#(1 1 2 3 5 8 13 21) 5) |
| 781 |
(test '#(0 ("Sue" "Sue") "Anna") 'vector-set |
| 782 |
(let ((vec (vector 0 '(2 2 2 2) "Anna"))) |
| 783 |
(vector-set! vec 1 '("Sue" "Sue")) |
| 784 |
vec)) |
| 785 |
(test '#(hi hi) make-vector 2 'hi) |
| 786 |
(test '#() make-vector 0) |
| 787 |
(test '#() make-vector 0 'a) |
| 788 |
(SECTION 6 9) |
| 789 |
(test #t procedure? car) |
| 790 |
(test #f procedure? 'car) |
| 791 |
(test #t procedure? (lambda (x) (* x x))) |
| 792 |
(test #f procedure? '(lambda (x) (* x x))) |
| 793 |
(test #t call-with-current-continuation procedure?) |
| 794 |
(test 7 apply + (list 3 4)) |
| 795 |
(test 7 apply (lambda (a b) (+ a b)) (list 3 4)) |
| 796 |
(test 17 apply + 10 (list 3 4)) |
| 797 |
(test '() apply list '()) |
| 798 |
(define compose (lambda (f g) (lambda args (f (apply g args))))) |
| 799 |
(test 30 (compose sqt *) 12 75) |
| 800 |
|
| 801 |
(test '(b e h) map cadr '((a b) (d e) (g h))) |
| 802 |
(test '(5 7 9) map + '(1 2 3) '(4 5 6)) |
| 803 |
(test '#(0 1 4 9 16) 'for-each |
| 804 |
(let ((v (make-vector 5))) |
| 805 |
(for-each (lambda (i) (vector-set! v i (* i i))) |
| 806 |
'(0 1 2 3 4)) |
| 807 |
v)) |
| 808 |
(test -3 call-with-current-continuation |
| 809 |
(lambda (exit) |
| 810 |
(for-each (lambda (x) (if (negative? x) (exit x))) |
| 811 |
'(54 0 37 -3 245 19)) |
| 812 |
#t)) |
| 813 |
(define list-length |
| 814 |
(lambda (obj) |
| 815 |
(call-with-current-continuation |
| 816 |
(lambda (return) |
| 817 |
(letrec ((r (lambda (obj) (cond ((null? obj) 0) |
| 818 |
((pair? obj) (+ (r (cdr obj)) 1)) |
| 819 |
(else (return #f)))))) |
| 820 |
(r obj)))))) |
| 821 |
(test 4 list-length '(1 2 3 4)) |
| 822 |
(test #f list-length '(a b . c)) |
| 823 |
(test '() map cadr '()) |
| 824 |
|
| 825 |
;;; This tests full conformance of call-with-current-continuation. It |
| 826 |
;;; is a separate test because some schemes do not support call/cc |
| 827 |
;;; other than escape procedures. I am indebted to |
| 828 |
;;; [email protected] (Raja Sooriamurthi) for fixing this |
| 829 |
;;; code. The function leaf-eq? compares the leaves of 2 arbitrary |
| 830 |
;;; trees constructed of conses. |
| 831 |
(define (next-leaf-generator obj eot) |
| 832 |
(letrec ((return #f) |
| 833 |
(cont (lambda (x) |
| 834 |
(recur obj) |
| 835 |
(set! cont (lambda (x) (return eot))) |
| 836 |
(cont #f))) |
| 837 |
(recur (lambda (obj) |
| 838 |
(if (pair? obj) |
| 839 |
(for-each recur obj) |
| 840 |
(call-with-current-continuation |
| 841 |
(lambda (c) |
| 842 |
(set! cont c) |
| 843 |
(return obj))))))) |
| 844 |
(lambda () (call-with-current-continuation |
| 845 |
(lambda (ret) (set! return ret) (cont #f)))))) |
| 846 |
(define (leaf-eq? x y) |
| 847 |
(let* ((eot (list 'eot)) |
| 848 |
(xf (next-leaf-generator x eot)) |
| 849 |
(yf (next-leaf-generator y eot))) |
| 850 |
(letrec ((loop (lambda (x y) |
| 851 |
(cond ((not (eq? x y)) #f) |
| 852 |
((eq? eot x) #t) |
| 853 |
(else (loop (xf) (yf))))))) |
| 854 |
(loop (xf) (yf))))) |
| 855 |
(define (test-cont) |
| 856 |
(newline) |
| 857 |
(display ";testing continuations; ") |
| 858 |
(newline) |
| 859 |
(SECTION 6 9) |
| 860 |
(test #t leaf-eq? '(a (b (c))) '((a) b c)) |
| 861 |
(test #f leaf-eq? '(a (b (c))) '((a) b c d)) |
| 862 |
(report-errs)) |
| 863 |
|
| 864 |
;;; Test Optional R4RS DELAY syntax and FORCE procedure |
| 865 |
(define (test-delay) |
| 866 |
(newline) |
| 867 |
(display ";testing DELAY and FORCE; ") |
| 868 |
(newline) |
| 869 |
(SECTION 6 9) |
| 870 |
(test 3 'delay (force (delay (+ 1 2)))) |
| 871 |
(test '(3 3) 'delay (let ((p (delay (+ 1 2)))) |
| 872 |
(list (force p) (force p)))) |
| 873 |
(test 2 'delay (letrec ((a-stream |
| 874 |
(letrec ((next (lambda (n) |
| 875 |
(cons n (delay (next (+ n 1))))))) |
| 876 |
(next 0))) |
| 877 |
(head car) |
| 878 |
(tail (lambda (stream) (force (cdr stream))))) |
| 879 |
(head (tail (tail a-stream))))) |
| 880 |
(letrec ((count 0) |
| 881 |
(p (delay (begin (set! count (+ count 1)) |
| 882 |
(if (> count x) |
| 883 |
count |
| 884 |
(force p))))) |
| 885 |
(x 5)) |
| 886 |
(test 6 force p) |
| 887 |
(set! x 10) |
| 888 |
(test 6 force p)) |
| 889 |
(test 3 'force |
| 890 |
(letrec ((p (delay (if c 3 (begin (set! c #t) (+ (force p) 1))))) |
| 891 |
(c #f)) |
| 892 |
(force p))) |
| 893 |
(report-errs)) |
| 894 |
|
| 895 |
(SECTION 6 10 1) |
| 896 |
(test #t input-port? (current-input-port)) |
| 897 |
(test #t output-port? (current-output-port)) |
| 898 |
(test #t call-with-input-file "test.scm" input-port?) |
| 899 |
(define this-file (open-input-file "test.scm")) |
| 900 |
(test #t input-port? this-file) |
| 901 |
(SECTION 6 10 2) |
| 902 |
(test #\; peek-char this-file) |
| 903 |
(test #\; read-char this-file) |
| 904 |
(test '(define cur-section '()) read this-file) |
| 905 |
(test #\( peek-char this-file) |
| 906 |
(test '(define errs '()) read this-file) |
| 907 |
(close-input-port this-file) |
| 908 |
(close-input-port this-file) |
| 909 |
(define (check-test-file name) |
| 910 |
(define test-file (open-input-file name)) |
| 911 |
(test #t 'input-port? |
| 912 |
(call-with-input-file |
| 913 |
name |
| 914 |
(lambda (test-file) |
| 915 |
(test load-test-obj read test-file) |
| 916 |
(test #t eof-object? (peek-char test-file)) |
| 917 |
(test #t eof-object? (read-char test-file)) |
| 918 |
(input-port? test-file)))) |
| 919 |
(test #\; read-char test-file) |
| 920 |
(test display-test-obj read test-file) |
| 921 |
(test load-test-obj read test-file) |
| 922 |
(close-input-port test-file)) |
| 923 |
(SECTION 6 10 3) |
| 924 |
(define write-test-obj |
| 925 |
'(#t #f #\a () 9739 -3 . #((test) "te \" \" st" "" test #() b c))) |
| 926 |
(define display-test-obj |
| 927 |
'(#t #f a () 9739 -3 . #((test) te " " st test #() b c))) |
| 928 |
(define load-test-obj |
| 929 |
(list 'define 'foo (list 'quote write-test-obj))) |
| 930 |
(test #t call-with-output-file |
| 931 |
"tmp1" |
| 932 |
(lambda (test-file) |
| 933 |
(write-char #\; test-file) |
| 934 |
(display write-test-obj test-file) |
| 935 |
(newline test-file) |
| 936 |
(write load-test-obj test-file) |
| 937 |
(output-port? test-file))) |
| 938 |
(check-test-file "tmp1") |
| 939 |
|
| 940 |
(define test-file (open-output-file "tmp2")) |
| 941 |
(write-char #\; test-file) |
| 942 |
(display write-test-obj test-file) |
| 943 |
(newline test-file) |
| 944 |
(write load-test-obj test-file) |
| 945 |
(test #t output-port? test-file) |
| 946 |
(close-output-port test-file) |
| 947 |
(check-test-file "tmp2") |
| 948 |
(define (test-sc4) |
| 949 |
(newline) |
| 950 |
(display ";testing scheme 4 functions; ") |
| 951 |
(newline) |
| 952 |
(SECTION 6 7) |
| 953 |
(test '(#\P #\space #\l) string->list "P l") |
| 954 |
(test '() string->list "") |
| 955 |
(test "1\\\"" list->string '(#\1 #\\ #\")) |
| 956 |
(test "" list->string '()) |
| 957 |
(SECTION 6 8) |
| 958 |
(test '(dah dah didah) vector->list '#(dah dah didah)) |
| 959 |
(test '() vector->list '#()) |
| 960 |
(test '#(dididit dah) list->vector '(dididit dah)) |
| 961 |
(test '#() list->vector '()) |
| 962 |
(SECTION 6 10 4) |
| 963 |
(load "tmp1") |
| 964 |
(test write-test-obj 'load foo) |
| 965 |
(report-errs)) |
| 966 |
|
| 967 |
(report-errs) |
| 968 |
(if (and (string->number "0.0") (inexact? (string->number "0.0"))) |
| 969 |
(test-inexact)) |
| 970 |
|
| 971 |
(let ((n (string->number "281474976710655"))) |
| 972 |
(if (and n (exact? n)) |
| 973 |
(test-bignum))) |
| 974 |
(newline) |
| 975 |
(display "To fully test continuations, Scheme 4, and DELAY/FORCE do:") |
| 976 |
(newline) |
| 977 |
(display "(test-cont) (test-sc4) (test-delay)") |
| 978 |
(newline) |
| 979 |
"last item in file" |