diff --git a/lib/chibi/log-test.sld b/lib/chibi/log-test.sld
index 024e032b..9398c3f8 100644
--- a/lib/chibi/log-test.sld
+++ b/lib/chibi/log-test.sld
@@ -20,7 +20,7 @@
                (string-split (log->string expr ...) "\n"))
           "\n"))))
     (define (run-tests)
-      (test-begin "(chibi log)")
+      (test-begin "logging")
       (test "D four: 4"
           (log->string/no-dates
            (log-debug "four: " (+ 2 2))))
diff --git a/lib/chibi/show/c-test.sld b/lib/chibi/show/c-test.sld
index 76f0f0c9..19916830 100644
--- a/lib/chibi/show/c-test.sld
+++ b/lib/chibi/show/c-test.sld
@@ -4,7 +4,7 @@
   (export run-tests)
   (begin
     (define (run-tests)
-      (test-begin "(chibi show c)")
+      (test-begin "show c")
 
       (test "if (1) {
     2;
diff --git a/lib/chibi/syntax-case-test.sld b/lib/chibi/syntax-case-test.sld
index faf6debf..54ba1bc0 100644
--- a/lib/chibi/syntax-case-test.sld
+++ b/lib/chibi/syntax-case-test.sld
@@ -1,56 +1,56 @@
 (define-library (chibi syntax-case-test)
   (export run-tests)
   (import (chibi)
-	  (chibi syntax-case)
-	  (chibi test))
+          (chibi syntax-case)
+          (chibi test))
   (begin
     (define (run-tests)
-      (test-begin "Syntax Case")
+      (test-begin "syntax case")
 
       (test "syntax constant list"
-	    '(+ 1 2)
-	    #'(+ 1 2))
+          '(+ 1 2)
+        #'(+ 1 2))
 
       (test "pattern variable"
-	    'foo
-	    (syntax-case 'foo ()
-	      (x #'x)))
+          'foo
+        (syntax-case 'foo ()
+          (x #'x)))
 
       (test "syntax-case pair"
-	    '(a b)
-	    (syntax-case '(a . b) ()
-	      ((x . y) #'(x y))))
+          '(a b)
+        (syntax-case '(a . b) ()
+          ((x . y) #'(x y))))
 
       (test "syntax-case var"
-	    'a
-	    (syntax-case '(a . b) (b)
-	      ((b . y) #f)
-	      ((x . b) #'x)))
+          'a
+        (syntax-case '(a . b) (b)
+          ((b . y) #f)
+          ((x . b) #'x)))
 
       (test "syntax-case simple ellipsis"
-	    '(a b c)
-	    (syntax-case '(a b c) ()
-	      ((a ...) #'(a ...))))
+          '(a b c)
+        (syntax-case '(a b c) ()
+          ((a ...) #'(a ...))))
 
       (test "syntax-case ellipsis with tail"
-	    '(a b x c)
-	    (syntax-case '(a b c) ()
-	      ((a ... b) #'(a ... x b))))
+          '(a b x c)
+        (syntax-case '(a b c) ()
+          ((a ... b) #'(a ... x b))))
 
       (test "syntax-case ellipsis with dotted tail"
-	    '(a b x c y d)
-	    (syntax-case '(a b c . d) ()
-	      ((a ... b . c) #'(a ... x b y c))))
+          '(a b x c y d)
+        (syntax-case '(a b c . d) ()
+          ((a ... b . c) #'(a ... x b y c))))
 
       (test "syntax-case nested ellipsis"
-	    '((a b) (d e) c f)
-	    (syntax-case '((a b c) (d e f)) ()
-	      (((x ... y) ...) #'((x ...) ... y ...))))
+          '((a b) (d e) c f)
+        (syntax-case '((a b c) (d e f)) ()
+          (((x ... y) ...) #'((x ...) ... y ...))))
 
       (test "with-ellipsis"
-	    '((a b))
-	    (with-ellipsis :::
-	      (syntax-case '(a) ()
-		((... :::) #'((... b) :::)))))   
+          '((a b))
+        (with-ellipsis :::
+                       (syntax-case '(a) ()
+                         ((... :::) #'((... b) :::)))))
 
       (test-end))))
diff --git a/lib/scheme/bytevector-test.sld b/lib/scheme/bytevector-test.sld
index 464aebec..6f3cff7b 100644
--- a/lib/scheme/bytevector-test.sld
+++ b/lib/scheme/bytevector-test.sld
@@ -9,7 +9,7 @@
   (export run-tests)
   (begin
     (define (run-tests)
-      (test-begin "bytevector")
+      (test-begin "scheme bytevector")
       ;; (test 258 (bytevector-uint-ref #u8(0 1 2 0) 1 (endianness big) 2))
       ;; (test 513 (bytevector-uint-ref #u8(0 1 2 0) 1 (endianness little) 2))
       ;; (test -65281
diff --git a/lib/srfi/116/test.sld b/lib/srfi/116/test.sld
index 51c88e6f..347bde82 100644
--- a/lib/srfi/116/test.sld
+++ b/lib/srfi/116/test.sld
@@ -4,7 +4,7 @@
   (export run-tests)
   (begin
     (define (run-tests)
-      (test-group "ilists"
+      (test-group "srfi-116: ilists"
 
         (test-group "ilists/constructors"
           (define abc (ilist 'a 'b 'c))
diff --git a/lib/srfi/134/test.sld b/lib/srfi/134/test.sld
index 230a9284..3779e783 100644
--- a/lib/srfi/134/test.sld
+++ b/lib/srfi/134/test.sld
@@ -10,7 +10,7 @@
         ((_ binds mv-expr body ...)
          (let-values ((binds mv-expr)) body ...))))
     (define (run-tests)
-      (test-group "ideque"
+      (test-group "srfi-134: ideque"
 
         (test-group "ideque/constructors"
           (test '() (ideque->list (ideque)))
diff --git a/lib/srfi/146/hash-test.sld b/lib/srfi/146/hash-test.sld
index 1802732c..5d59ec4e 100644
--- a/lib/srfi/146/hash-test.sld
+++ b/lib/srfi/146/hash-test.sld
@@ -33,7 +33,7 @@
     (define comparator (make-default-comparator))
 
     (define (run-tests)
-      (test-begin "SRFI 146: Hashmaps")
+      (test-begin "srfi-146: hashmaps")
 
       (test-group "Predicates"
         (define hashmap0 (hashmap comparator))
@@ -438,4 +438,4 @@
             (test-assert "=?: unequal hashmaps"
               (not (=? comparator hashmap1 hashmap4))))))
 
-      (test-end "SRFI 146: Hashmaps"))))
+      (test-end "srfi-146: hashmaps"))))
diff --git a/lib/srfi/146/test.sld b/lib/srfi/146/test.sld
index 8c5ddf0f..8f269701 100644
--- a/lib/srfi/146/test.sld
+++ b/lib/srfi/146/test.sld
@@ -31,7 +31,7 @@
           (chibi test))
   (begin
     (define (run-tests)
-      (test-begin "SRFI 146")
+      (test-begin "srfi-146: mappings")
 
       (test-group "Predicates"
         (define mapping0 (mapping comparator))
@@ -521,6 +521,6 @@
             (test-assert "<?: case 3"
               (<? comparator mapping1 mapping5)))))
       
-      (test-end "SRFI 146"))
+      (test-end "srfi-146: mappings"))
 
     (define comparator (make-default-comparator))))
diff --git a/lib/srfi/158/test.sld b/lib/srfi/158/test.sld
index 58ba68c6..6efcca49 100644
--- a/lib/srfi/158/test.sld
+++ b/lib/srfi/158/test.sld
@@ -1,267 +1,267 @@
 (define-library (srfi 158 test)
   (import (scheme base)
-	  (scheme read)
-	  (srfi 1)
-	  (srfi 158)
-	  (chibi test))
+          (scheme read)
+          (srfi 1)
+          (srfi 158)
+          (chibi test))
   (export run-tests)
   (begin
     (define (with-input-from-string str thunk)
       (parameterize ((current-input-port (open-input-string str)))
-	(thunk)))
+        (thunk)))
     (define g
       (make-coroutine-generator
        (lambda (yield) (let loop ((i 0))
-			 (when (< i 3) (yield i) (loop (+ i 1)))))))
+                     (when (< i 3) (yield i) (loop (+ i 1)))))))
     (define (for-each-digit proc n)
       (when (> n 0)
-	(let-values (((div rem) (truncate/ n 10)))
-	  (proc rem)
-	  (for-each-digit proc div))))
+        (let-values (((div rem) (truncate/ n 10)))
+          (proc rem)
+          (for-each-digit proc div))))
     (define g1 (generator 1 2 3))
     (define g2 (generator 4 5 6 7))
     (define (proc . args) (values (apply + args) (apply + args)))
     (define (small? x) (< x 3))
     (define n 0)
     (define (run-tests)
-      (test-group "generators"
-		  (test-group "generators/constructors"
-			      (test '() (generator->list (generator)))
-			      (test '(1 2 3) (generator->list (generator 1 2 3)))
-			      (test '(1 2 3 1 2) (generator->list (circular-generator 1 2 3) 5))
-			      (test '(8 9 10) (generator->list (make-iota-generator 3 8)))
-			      (test '(8 10 12) (generator->list (make-iota-generator 3 8 2)))
-			      (test '(3 4 5 6) (generator->list (make-range-generator 3) 4))
-			      (test '(3 4 5 6 7) (generator->list (make-range-generator 3 8)))
-			      (test '(3 5 7) (generator->list (make-range-generator 3 8 2)))
+      (test-group "srfi-158: generators"
+        (test-group "generators/constructors"
+          (test '() (generator->list (generator)))
+          (test '(1 2 3) (generator->list (generator 1 2 3)))
+          (test '(1 2 3 1 2) (generator->list (circular-generator 1 2 3) 5))
+          (test '(8 9 10) (generator->list (make-iota-generator 3 8)))
+          (test '(8 10 12) (generator->list (make-iota-generator 3 8 2)))
+          (test '(3 4 5 6) (generator->list (make-range-generator 3) 4))
+          (test '(3 4 5 6 7) (generator->list (make-range-generator 3 8)))
+          (test '(3 5 7) (generator->list (make-range-generator 3 8 2)))
 
-			      (test '(0 1 2) (generator->list g))
-			      (test '(1 2 3 4 5) (generator->list (list->generator '(1 2 3 4 5))))
-			      (test '(1 2 3 4 5) (generator->list (vector->generator '#(1 2 3 4 5))))
-			      (test '#(0 0 1 2 4)
-				    (let ((v (make-vector 5 0)))
-				      (generator->vector! v 2 (generator 1 2 4))
-				      v))
-			      (test '(5 4 3 2 1) (generator->list (reverse-vector->generator '#(1 2 3 4 5))))
-			      (test '(#\a #\b #\c #\d #\e) (generator->list (string->generator "abcde")))
-			      (test '(10 20 30) (generator->list (bytevector->generator (bytevector 10 20 30))))
-			      (test '(5 4 3 2 1) (generator->list
-						  (make-for-each-generator for-each-digit
-									   12345)))
-			      (test '(0 2 4 6 8 10) (generator->list
-						     (make-unfold-generator
-						      (lambda (s) (> s 5))
-						      (lambda (s) (* s 2))
-						      (lambda (s) (+ s 1))
-						      0)))
-			      ) ; end "generators/constructors"
+          (test '(0 1 2) (generator->list g))
+          (test '(1 2 3 4 5) (generator->list (list->generator '(1 2 3 4 5))))
+          (test '(1 2 3 4 5) (generator->list (vector->generator '#(1 2 3 4 5))))
+          (test '#(0 0 1 2 4)
+              (let ((v (make-vector 5 0)))
+                (generator->vector! v 2 (generator 1 2 4))
+                v))
+          (test '(5 4 3 2 1) (generator->list (reverse-vector->generator '#(1 2 3 4 5))))
+          (test '(#\a #\b #\c #\d #\e) (generator->list (string->generator "abcde")))
+          (test '(10 20 30) (generator->list (bytevector->generator (bytevector 10 20 30))))
+          (test '(5 4 3 2 1) (generator->list
+                              (make-for-each-generator for-each-digit
+                                                       12345)))
+          (test '(0 2 4 6 8 10) (generator->list
+                                 (make-unfold-generator
+                                  (lambda (s) (> s 5))
+                                  (lambda (s) (* s 2))
+                                  (lambda (s) (+ s 1))
+                                  0)))
+          )                            ; end "generators/constructors"
 
-		  (test-group "generators/operators"
-			      (test '(a b 0 1) (generator->list (gcons* 'a 'b (make-range-generator 0 2))))
-			      (test '(0 1 2 0 1) (generator->list (gappend (make-range-generator 0 3)
-									   (make-range-generator 0 2))))
-			      (test '() (generator->list (gappend)))
-			      (test '(15 22 31) (generator->list (gcombine proc 10 g1 g2)))
-			      (test '(1 3 5 7 9) (generator->list (gfilter
-								   odd?
-								   (make-range-generator 1 11))))
-			      (test '(2 4 6 8 10) (generator->list (gremove
-								    odd?
-								    (make-range-generator 1 11))))
-			      (set! g (make-range-generator 1 5))
-			      (test '(1 2 3) (generator->list (gtake g 3)))
-			      (test '(4) (generator->list g))
-			      (test '(1 2) (generator->list (gtake (make-range-generator 1 3) 3)))
-			      (test '(1 2 0) (generator->list (gtake (make-range-generator 1 3) 3 0)))
-			      (test '(3 4) (generator->list (gdrop (make-range-generator 1 5) 2)))
-			      (set! g (make-range-generator 1 5))
-			      (test '(1 2) (generator->list (gtake-while small? g)))
-			      (set! g (make-range-generator 1 5))
-			      (test '(3 4) (generator->list (gdrop-while small? g)))
-			      (test '() (generator->list (gdrop-while (lambda args #t) (generator 1 2 3))))
-			      (test '(0.0 1.0 0 2) (generator->list (gdelete 1
-									     (generator 0.0 1.0 0 1 2))))
-			      (test '(0.0 0 2) (generator->list (gdelete 1
-									 (generator 0.0 1.0 0 1 2)
-									 =)))
-			      (test '(a c e) (generator->list (gindex (list->generator '(a b c d e f))
-								      (list->generator '(0 2 4)))))
-			      (test '(a d e) (generator->list (gselect (list->generator '(a b c d e f))
-								       (list->generator '(#t #f #f #t #t #f)))))
-			      (test '(1 2 3) (generator->list (gdelete-neighbor-dups
-							       (generator 1 1 2 3 3 3)
-							       =)))
-			      (test '(1) (generator->list (gdelete-neighbor-dups
-							   (generator 1 2 3)
-							   (lambda args #t))))
-			      (test '(1 2 3 a b c)
-				    (generator->list
-				     (gflatten (generator '(1 2 3) '(a b c)))))
-			      (test '((1 2 3) (4 5 6) (7 8))
-				    (generator->list (ggroup (generator 1 2 3 4 5 6 7 8) 3)))
-			      (test '((1 2 3) (4 5 6) (7 8 0))
-				    (generator->list (ggroup (generator 1 2 3 4 5 6 7 8) 3 0)))
-			      (test '(1 2 3)
-				    (generator->list (gmerge < (generator 1 2 3))))
-			      (test '(1 2 3 4 5 6)
-				    (generator->list (gmerge < (generator 1 2 3) (generator 4 5 6))))
-			      (test '(1 2 3 4 4 5 6)
-				    (generator->list (gmerge <
-							     (generator 1 2 4 6)
-							     (generator)
-							     (generator 3 4 5))))
-			      (test '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
-				    (generator->list (gmerge <
-							     (generator 1 10 11)
-							     (generator 2 9 12)
-							     (generator 3 8 13)
-							     (generator 4 7 14)
-							     (generator 5 6 15))))
-			      ;; check the tie-break rule
-			      (test '((1 a) (1 e) (1 b) (1 c) (1 d))
-				    (generator->list (gmerge (lambda (x y) (< (car x) (car y)))
-							     (generator '(1 a) '(1 e))
-							     (generator '(1 b))
-							     (generator '(1 c) '(1 d)))))
+        (test-group "generators/operators"
+          (test '(a b 0 1) (generator->list (gcons* 'a 'b (make-range-generator 0 2))))
+          (test '(0 1 2 0 1) (generator->list (gappend (make-range-generator 0 3)
+                                                       (make-range-generator 0 2))))
+          (test '() (generator->list (gappend)))
+          (test '(15 22 31) (generator->list (gcombine proc 10 g1 g2)))
+          (test '(1 3 5 7 9) (generator->list (gfilter
+                                               odd?
+                                               (make-range-generator 1 11))))
+          (test '(2 4 6 8 10) (generator->list (gremove
+                                                odd?
+                                                (make-range-generator 1 11))))
+          (set! g (make-range-generator 1 5))
+          (test '(1 2 3) (generator->list (gtake g 3)))
+          (test '(4) (generator->list g))
+          (test '(1 2) (generator->list (gtake (make-range-generator 1 3) 3)))
+          (test '(1 2 0) (generator->list (gtake (make-range-generator 1 3) 3 0)))
+          (test '(3 4) (generator->list (gdrop (make-range-generator 1 5) 2)))
+          (set! g (make-range-generator 1 5))
+          (test '(1 2) (generator->list (gtake-while small? g)))
+          (set! g (make-range-generator 1 5))
+          (test '(3 4) (generator->list (gdrop-while small? g)))
+          (test '() (generator->list (gdrop-while (lambda args #t) (generator 1 2 3))))
+          (test '(0.0 1.0 0 2) (generator->list (gdelete 1
+                                                         (generator 0.0 1.0 0 1 2))))
+          (test '(0.0 0 2) (generator->list (gdelete 1
+                                                     (generator 0.0 1.0 0 1 2)
+                                                     =)))
+          (test '(a c e) (generator->list (gindex (list->generator '(a b c d e f))
+                                                  (list->generator '(0 2 4)))))
+          (test '(a d e) (generator->list (gselect (list->generator '(a b c d e f))
+                                                   (list->generator '(#t #f #f #t #t #f)))))
+          (test '(1 2 3) (generator->list (gdelete-neighbor-dups
+                                           (generator 1 1 2 3 3 3)
+                                           =)))
+          (test '(1) (generator->list (gdelete-neighbor-dups
+                                       (generator 1 2 3)
+                                       (lambda args #t))))
+          (test '(1 2 3 a b c)
+              (generator->list
+               (gflatten (generator '(1 2 3) '(a b c)))))
+          (test '((1 2 3) (4 5 6) (7 8))
+              (generator->list (ggroup (generator 1 2 3 4 5 6 7 8) 3)))
+          (test '((1 2 3) (4 5 6) (7 8 0))
+              (generator->list (ggroup (generator 1 2 3 4 5 6 7 8) 3 0)))
+          (test '(1 2 3)
+              (generator->list (gmerge < (generator 1 2 3))))
+          (test '(1 2 3 4 5 6)
+              (generator->list (gmerge < (generator 1 2 3) (generator 4 5 6))))
+          (test '(1 2 3 4 4 5 6)
+              (generator->list (gmerge <
+                                       (generator 1 2 4 6)
+                                       (generator)
+                                       (generator 3 4 5))))
+          (test '(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+              (generator->list (gmerge <
+                                       (generator 1 10 11)
+                                       (generator 2 9 12)
+                                       (generator 3 8 13)
+                                       (generator 4 7 14)
+                                       (generator 5 6 15))))
+          ;; check the tie-break rule
+          (test '((1 a) (1 e) (1 b) (1 c) (1 d))
+              (generator->list (gmerge (lambda (x y) (< (car x) (car y)))
+                                       (generator '(1 a) '(1 e))
+                                       (generator '(1 b))
+                                       (generator '(1 c) '(1 d)))))
 
-			      (test '(-1 -2 -3 -4 -5)
-				    (generator->list (gmap - (generator 1 2 3 4 5))))
-			      (test '(7 9 11 13)
-				    (generator->list (gmap +
-							   (generator 1 2 3 4 5)
-							   (generator 6 7 8 9))))
-			      (test '(54 140 264)
-				    (generator->list (gmap *
-							   (generator 1 2 3 4 5)
-							   (generator 6 7 8)
-							   (generator 9 10 11 12 13))))
-			      (test '(a c e g i)
-				    (generator->list
-				     (gstate-filter
-				      (lambda (item state) (values (even? state) (+ 1 state)))
-				      0
-				      (generator 'a 'b 'c 'd 'e 'f 'g 'h 'i 'j))))
-			      ) ; end "generators/operators"
+          (test '(-1 -2 -3 -4 -5)
+              (generator->list (gmap - (generator 1 2 3 4 5))))
+          (test '(7 9 11 13)
+              (generator->list (gmap +
+                                     (generator 1 2 3 4 5)
+                                     (generator 6 7 8 9))))
+          (test '(54 140 264)
+              (generator->list (gmap *
+                                     (generator 1 2 3 4 5)
+                                     (generator 6 7 8)
+                                     (generator 9 10 11 12 13))))
+          (test '(a c e g i)
+              (generator->list
+               (gstate-filter
+                (lambda (item state) (values (even? state) (+ 1 state)))
+                0
+                (generator 'a 'b 'c 'd 'e 'f 'g 'h 'i 'j))))
+          )                             ; end "generators/operators"
 
 
-		  (test-group "generators/consumers"
-			      ;; no test for plain generator->list (used throughout)
-			      (test '(1 2 3) (generator->list (generator 1 2 3 4 5) 3))
-			      (test '(5 4 3 2 1) (generator->reverse-list (generator 1 2 3 4 5)))
-			      (test '#(1 2 3 4 5) (generator->vector (generator 1 2 3 4 5)))
-			      (test '#(1 2 3) (generator->vector (generator 1 2 3 4 5) 3))
-			      (test "abc" (generator->string (generator #\a #\b #\c)))
-			      (test '(e d c b a . z) (with-input-from-string "a b c d e"
-						       (lambda () (generator-fold cons 'z read))))
+        (test-group "generators/consumers"
+          ;; no test for plain generator->list (used throughout)
+          (test '(1 2 3) (generator->list (generator 1 2 3 4 5) 3))
+          (test '(5 4 3 2 1) (generator->reverse-list (generator 1 2 3 4 5)))
+          (test '#(1 2 3 4 5) (generator->vector (generator 1 2 3 4 5)))
+          (test '#(1 2 3) (generator->vector (generator 1 2 3 4 5) 3))
+          (test "abc" (generator->string (generator #\a #\b #\c)))
+          (test '(e d c b a . z) (with-input-from-string "a b c d e"
+                                   (lambda () (generator-fold cons 'z read))))
 
-			      (generator-for-each (lambda values (set! n (apply + values)))
-						  (generator 1) (generator 2) (generator 3))
-			      (test 6 n)
-			      (test '(6 15)
-				    (generator-map->list (lambda values (apply + values))
-							 (generator 1 4) (generator 2 5) (generator 3 6)))
-			      (test 3 (generator-find (lambda (x) (> x 2)) (make-range-generator 1 5)))
-			      (test 2 (generator-count odd? (make-range-generator 1 5)))
-			      (set! g (make-range-generator 2 5))
-			      (test #t (generator-any odd? g))
-			      (test '(4) (generator->list g))
-			      (set! g (make-range-generator 2 5))
-			      (test #f (generator-every odd? g))
-			      (test '(3 4) (generator->list g))
-			      (test '(#\a #\b #\c) (generator-unfold (make-for-each-generator string-for-each "abc") unfold))
+          (generator-for-each (lambda values (set! n (apply + values)))
+                              (generator 1) (generator 2) (generator 3))
+          (test 6 n)
+          (test '(6 15)
+              (generator-map->list (lambda values (apply + values))
+                                   (generator 1 4) (generator 2 5) (generator 3 6)))
+          (test 3 (generator-find (lambda (x) (> x 2)) (make-range-generator 1 5)))
+          (test 2 (generator-count odd? (make-range-generator 1 5)))
+          (set! g (make-range-generator 2 5))
+          (test #t (generator-any odd? g))
+          (test '(4) (generator->list g))
+          (set! g (make-range-generator 2 5))
+          (test #f (generator-every odd? g))
+          (test '(3 4) (generator->list g))
+          (test '(#\a #\b #\c) (generator-unfold (make-for-each-generator string-for-each "abc") unfold))
 
-			      ) ; end "generators/consumers"
+          )                             ; end "generators/consumers"
 
-		  ) ; end "generators"
+        )                               ; end "generators"
 
 
-      (test-group "accumulators"
-		  (test -8
-			(let ((a (make-accumulator * 1 -)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+      (test-group "srfi-158: accumulators"
+        (test -8
+            (let ((a (make-accumulator * 1 -)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test 3
-			(let ((a (count-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test 3
+            (let ((a (count-accumulator)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test '(1 2 4)
-			(let ((a (list-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test '(1 2 4)
+            (let ((a (list-accumulator)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test '(4 2 1)
-			(let ((a (reverse-list-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test '(4 2 1)
+            (let ((a (reverse-list-accumulator)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test '#(1 2 4)
-			(let ((a (vector-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test '#(1 2 4)
+            (let ((a (vector-accumulator)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test '#(0 0 1 2 4)
-			(let* ((v (vector 0 0 0 0 0))
-			       (a (vector-accumulator! v 2)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test '#(0 0 1 2 4)
+            (let* ((v (vector 0 0 0 0 0))
+                   (a (vector-accumulator! v 2)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test '#u8(0 0 1 2 4)
-			(let* ((v (bytevector 0 0 0 0 0))
-			       (a (bytevector-accumulator! v 2)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test '#u8(0 0 1 2 4)
+          (let* ((v (bytevector 0 0 0 0 0))
+                 (a (bytevector-accumulator! v 2)))
+            (a 1)
+            (a 2)
+            (a 4)
+            (a (eof-object))))
 
-		  (test '#(4 2 1)
-			(let ((a (reverse-vector-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test '#(4 2 1)
+            (let ((a (reverse-vector-accumulator)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test "abc"
-			(let ((a (string-accumulator)))
-			  (a #\a)
-			  (a #\b)
-			  (a #\c)
-			  (a (eof-object))))
+        (test "abc"
+            (let ((a (string-accumulator)))
+              (a #\a)
+              (a #\b)
+              (a #\c)
+              (a (eof-object))))
 
-		  (test #u8(1 2 4)
-			(let ((a (bytevector-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test #u8(1 2 4)
+          (let ((a (bytevector-accumulator)))
+            (a 1)
+            (a 2)
+            (a 4)
+            (a (eof-object))))
 
-		  (test 7
-			(let ((a (sum-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test 7
+            (let ((a (sum-accumulator)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  (test 8
-			(let ((a (product-accumulator)))
-			  (a 1)
-			  (a 2)
-			  (a 4)
-			  (a (eof-object))))
+        (test 8
+            (let ((a (product-accumulator)))
+              (a 1)
+              (a 2)
+              (a 4)
+              (a (eof-object))))
 
-		  ) ; end "accumulators"
+        )                               ; end "accumulators"
 
       )))
diff --git a/tests/lib-tests.scm b/tests/lib-tests.scm
index 276734c1..c21c8428 100644
--- a/tests/lib-tests.scm
+++ b/tests/lib-tests.scm
@@ -32,6 +32,7 @@
         (rename (srfi 151 test) (run-tests run-srfi-151-tests))
         (rename (srfi 158 test) (run-tests run-srfi-158-tests))
         (rename (srfi 160 test) (run-tests run-srfi-160-tests))
+        (rename (scheme bytevector-test) (run-tests run-scheme-bytevector-tests))
         (rename (chibi base64-test) (run-tests run-base64-tests))
         (rename (chibi bytevector-test) (run-tests run-bytevector-tests))
         (rename (chibi crypto md5-test) (run-tests run-md5-tests))
@@ -99,6 +100,7 @@
 (run-srfi-151-tests)
 (run-srfi-158-tests)
 (run-srfi-160-tests)
+(run-scheme-bytevector-tests)
 (run-base64-tests)
 (run-bytevector-tests)
 (run-doc-tests)