Fix a potential R7RS issue.

I was using the load procedure to load a program, but by a strict
reading of R7RS, load can only handle expressions and definitions, not
imports. So instead I'm defining each test as a library, and using the
environment procedure to load them at runtime.

1 files changed, 117 insertions, 115 deletions

diff --git a/csc/hash-map-test.csc b/csc/hash-map-test.csc
index 10edc26..6f83c30 100644
--- a/csc/hash-map-test.csc
+++ b/csc/hash-map-test.csc
@@ -1,153 +1,155 @@
-(import (scheme base)
-        (only (csc format)
-          sprintf)
-        (only (csc loop)
-          loop
-          return)
-        (only (csc sort) sort)
-        (only (csc testing)
-              assert-equal
-              assert-raises
-              test)
-        (csc hash-map))
+(define-library (csc hash-map-test)
+  (import (scheme base)
+          (only (csc format)
+            sprintf)
+          (only (csc loop)
+            loop
+            return)
+          (only (csc sort) sort)
+          (only (csc testing)
+                assert-equal
+                assert-raises
+                test)
+          (csc hash-map))
+  (begin
 
 
-(define transform-map
-  (list
-    (cons map? map->alist)
-    (cons list? (lambda (l) (sort (lambda (x y) (string<? (symbol->string (car x)) (symbol->string (car y)))) l)))))
+    (define transform-map
+      (list
+        (cons map? map->alist)
+        (cons list? (lambda (l) (sort (lambda (x y) (string<? (symbol->string (car x)) (symbol->string (car y)))) l)))))
 
 
-(test alist->map-singleton
-  (assert-equal
-    '((a . 1))
-    (alist->map compare-symbols '((a . 1)))
-    transform-map))
+    (test alist->map-singleton
+      (assert-equal
+        '((a . 1))
+        (alist->map compare-symbols '((a . 1)))
+        transform-map))
 
 
-(test alist->map-two
-  (assert-equal
-    '((a . 1) (b . 2))
-    (alist->map compare-symbols '((a . 1) (b . 2)))
-    transform-map))
+    (test alist->map-two
+      (assert-equal
+        '((a . 1) (b . 2))
+        (alist->map compare-symbols '((a . 1) (b . 2)))
+        transform-map))
 
 
-(test alist->map-longer
-  (assert-equal
-    '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))
-    (alist->map compare-symbols '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6)))
-    transform-map))
+    (test alist->map-longer
+      (assert-equal
+        '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))
+        (alist->map compare-symbols '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6)))
+        transform-map))
 
 
-(test alist->map-larger
-  (assert-equal
-    '((f . 5) (m . 1) (n . 7) (q . 3) (x . 8))
-    (alist->map compare-symbols '((m . 1) (n . 2) (q . 3) (f . 5) (n . 7) (x . 8)))
-    transform-map))
+    (test alist->map-larger
+      (assert-equal
+        '((f . 5) (m . 1) (n . 7) (q . 3) (x . 8))
+        (alist->map compare-symbols '((m . 1) (n . 2) (q . 3) (f . 5) (n . 7) (x . 8)))
+        transform-map))
 
 
-(test alist->map-in-order
-  (assert-equal
-    '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()))
-    (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
-    transform-map))
+    (test alist->map-in-order
+      (assert-equal
+        '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()))
+        (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
+        transform-map))
 
 
-(test alist->map-reversed
-  (assert-equal
-    '((h . ()) (g . ()) (f . ()) (e . ()) (d . ()) (c . ()) (b . ()) (a . ()))
-    (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
-    transform-map))
+    (test alist->map-reversed
+      (assert-equal
+        '((h . ()) (g . ()) (f . ()) (e . ()) (d . ()) (c . ()) (b . ()) (a . ()))
+        (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
+        transform-map))
 
 
-(test alist->map-overwrite
-  (assert-equal
-    '((a . 2))
-    (alist->map compare-symbols '((a . 1) (a . 2)))
-    transform-map))
+    (test alist->map-overwrite
+      (assert-equal
+        '((a . 2))
+        (alist->map compare-symbols '((a . 1) (a . 2)))
+        transform-map))
 
 
-(test alist->map-alternating
-  (assert-equal
-    '((h . ()) (g . ()) (i . ()) (f . ()) (j . ()) (e . ()) (k . ()) (d . ()) (l . ()) (c . ()))
-    (alist->map compare-symbols '((c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()) (i . ()) (j . ()) (k . ()) (l . ())))
-    transform-map))
+    (test alist->map-alternating
+      (assert-equal
+        '((h . ()) (g . ()) (i . ()) (f . ()) (j . ()) (e . ()) (k . ()) (d . ()) (l . ()) (c . ()))
+        (alist->map compare-symbols '((c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()) (i . ()) (j . ()) (k . ()) (l . ())))
+        transform-map))
 
 
-(define (test-map . bindings)
-  (alist->map compare-symbols bindings))
+    (define (test-map . bindings)
+      (alist->map compare-symbols bindings))
 
 
-(test lookup
-  (assert-equal
-    2
-    (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'b)))
+    (test lookup
+      (assert-equal
+        2
+        (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'b)))
 
 
-(test lookup-notfound
-  (assert-raises key-not-found-error?
-    (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'd)))
+    (test lookup-notfound
+      (assert-raises key-not-found-error?
+        (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'd)))
 
 
-(test lookup-default
-  (assert-equal
-    #f
-    (lookup (test-map '(a . #t) '(b . #t)) 'c #f)))
+    (test lookup-default
+      (assert-equal
+        #f
+        (lookup (test-map '(a . #t) '(b . #t)) 'c #f)))
 
 
-(test merge
-  (assert-equal
-    '((a . 1) (b . 2) (c . 3) (d . 4))
-    (merge
-      (test-map '(a . 1) '(b . 2))
-      (test-map '(c . 3) '(d . 4)))
-    transform-map))
+    (test merge
+      (assert-equal
+        '((a . 1) (b . 2) (c . 3) (d . 4))
+        (merge
+          (test-map '(a . 1) '(b . 2))
+          (test-map '(c . 3) '(d . 4)))
+        transform-map))
 
 
-(test delete
-  (assert-equal
-    '((a . 1) (b . 2) (d . 4))
-    (delete
-      (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
-      'c)
-    transform-map))
+    (test delete
+      (assert-equal
+        '((a . 1) (b . 2) (d . 4))
+        (delete
+          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
+          'c)
+        transform-map))
 
 
-(test delete-only
-  (assert-equal
-    '()
-    (delete
-      (test-map '(a . 1))
-      'a)
-    transform-map))
+    (test delete-only
+      (assert-equal
+        '()
+        (delete
+          (test-map '(a . 1))
+          'a)
+        transform-map))
 
 
-(test delete-first
-  (assert-equal
-    '((b . 2) (c . 3) (d . 4))
-    (delete
-      (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
-      'a)
-    transform-map))
+    (test delete-first
+      (assert-equal
+        '((b . 2) (c . 3) (d . 4))
+        (delete
+          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
+          'a)
+        transform-map))
 
 
-(test delete-last
-  (assert-equal
-    '((a . 1) (b . 2) (c . 3))
-    (delete
-      (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
-      'd)
-    transform-map))
+    (test delete-last
+      (assert-equal
+        '((a . 1) (b . 2) (c . 3))
+        (delete
+          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
+          'd)
+        transform-map))
 
 
-(test delete-many
-  (assert-equal
-    '()
-    (loop with m = (loop with m = (test-map)
-                         for i from 1 to 100
-                         do (set! m (insert m (string->symbol (sprintf "key{}" i)) i))
-                         finally (return m))
-          for i from 1 to 100
-          do (set! m (delete m (string->symbol (sprintf "key{}" i))))
-          finally (return m))
-    transform-map))
+    (test delete-many
+      (assert-equal
+        '()
+        (loop with m = (loop with m = (test-map)
+                             for i from 1 to 100
+                             do (set! m (insert m (string->symbol (sprintf "key{}" i)) i))
+                             finally (return m))
+              for i from 1 to 100
+              do (set! m (delete m (string->symbol (sprintf "key{}" i))))
+              finally (return m))
+        transform-map))))