From e4407f4d53e97eda18fdb6964d73e740596259a0 Mon Sep 17 00:00:00 2001
From: VSteveHL <hzq1283014604@163.com>
Date: Tue, 15 Jul 2025 14:18:16 +0800
Subject: [PATCH 1/6] copy r7rs file from goldfish and rename them

---
 tests/resources/r7rs/liii/alist.scm.txt       |  52 ++
 tests/resources/r7rs/liii/argparse.scm.txt    | 139 ++++++
 .../resources/r7rs/liii/array-buffer.scm.txt  | 127 +++++
 tests/resources/r7rs/liii/base.scm.txt        | 115 +++++
 tests/resources/r7rs/liii/base64.scm.txt      | 136 ++++++
 tests/resources/r7rs/liii/bitwise.scm.txt     |  37 ++
 tests/resources/r7rs/liii/case.scm.txt        | 344 +++++++++++++
 tests/resources/r7rs/liii/check.scm.txt       |  51 ++
 tests/resources/r7rs/liii/chez.scm.txt        |  26 +
 tests/resources/r7rs/liii/comparator.scm.txt  |  35 ++
 tests/resources/r7rs/liii/cut.scm.txt         |  20 +
 tests/resources/r7rs/liii/datetime.scm.txt    | 193 ++++++++
 tests/resources/r7rs/liii/either.scm.txt      | 122 +++++
 tests/resources/r7rs/liii/error.scm.txt       |  59 +++
 tests/resources/r7rs/liii/hash-table.scm.txt  |  35 ++
 tests/resources/r7rs/liii/lang.scm.txt        | 153 ++++++
 tests/resources/r7rs/liii/list.scm.txt        | 151 ++++++
 tests/resources/r7rs/liii/logging.scm.txt     | 144 ++++++
 tests/resources/r7rs/liii/oop.scm.txt         | 440 +++++++++++++++++
 tests/resources/r7rs/liii/option.scm.txt      |  94 ++++
 tests/resources/r7rs/liii/os.scm.txt          | 137 ++++++
 tests/resources/r7rs/liii/path.scm.txt        | 341 +++++++++++++
 tests/resources/r7rs/liii/range.scm.txt       |  90 ++++
 tests/resources/r7rs/liii/rich-char.scm.txt   | 179 +++++++
 .../r7rs/liii/rich-hash-table.scm.txt         | 102 ++++
 tests/resources/r7rs/liii/rich-list.scm.txt   | 452 ++++++++++++++++++
 tests/resources/r7rs/liii/rich-string.scm.txt | 348 ++++++++++++++
 tests/resources/r7rs/liii/rich-vector.scm.txt | 446 +++++++++++++++++
 tests/resources/r7rs/liii/set.scm.txt         |  69 +++
 tests/resources/r7rs/liii/sort.scm.txt        |  22 +
 tests/resources/r7rs/liii/stack.scm.txt       |  60 +++
 tests/resources/r7rs/liii/string.scm.txt      |  64 +++
 tests/resources/r7rs/liii/sys.scm.txt         |  28 ++
 tests/resources/r7rs/liii/uuid.scm.txt        |  25 +
 tests/resources/r7rs/liii/vector.scm.txt      |  58 +++
 .../resources/r7rs/{ => scheme}/base.scm.txt  |   0
 .../resources/r7rs/{ => scheme}/boot.scm.txt  |   0
 .../r7rs/{ => scheme}/case-lambda.scm.txt     |   0
 .../resources/r7rs/{ => scheme}/char.scm.txt  |   0
 .../resources/r7rs/{ => scheme}/file.scm.txt  |   0
 .../r7rs/{ => scheme}/inexact.scm.txt         |   0
 .../r7rs/{ => scheme}/process-context.scm.txt |   0
 .../resources/r7rs/{ => scheme}/time.scm.txt  |   0
 tests/resources/r7rs/srfi/sicp.scm.txt        |  20 +
 tests/resources/r7rs/srfi/srfi-1.scm.txt      | 355 ++++++++++++++
 tests/resources/r7rs/srfi/srfi-113.scm.txt    |  29 ++
 tests/resources/r7rs/srfi/srfi-125.scm.txt    | 161 +++++++
 tests/resources/r7rs/srfi/srfi-128.scm.txt    | 376 +++++++++++++++
 tests/resources/r7rs/srfi/srfi-13.scm.txt     | 380 +++++++++++++++
 tests/resources/r7rs/srfi/srfi-132.scm.txt    | 188 ++++++++
 tests/resources/r7rs/srfi/srfi-133.scm.txt    | 183 +++++++
 tests/resources/r7rs/srfi/srfi-151.scm.txt    | 168 +++++++
 tests/resources/r7rs/srfi/srfi-16.scm.txt     |  20 +
 tests/resources/r7rs/srfi/srfi-2.scm.txt      |  11 +
 tests/resources/r7rs/srfi/srfi-216.scm.txt    |  33 ++
 tests/resources/r7rs/srfi/srfi-26.scm.txt     |  70 +++
 tests/resources/r7rs/srfi/srfi-39.scm.txt     |  35 ++
 tests/resources/r7rs/srfi/srfi-78.scm.txt     | 165 +++++++
 tests/resources/r7rs/srfi/srfi-8.scm.txt      |  28 ++
 tests/resources/r7rs/srfi/srfi-9.scm.txt      |   7 +
 60 files changed, 7123 insertions(+)
 create mode 100644 tests/resources/r7rs/liii/alist.scm.txt
 create mode 100644 tests/resources/r7rs/liii/argparse.scm.txt
 create mode 100644 tests/resources/r7rs/liii/array-buffer.scm.txt
 create mode 100644 tests/resources/r7rs/liii/base.scm.txt
 create mode 100644 tests/resources/r7rs/liii/base64.scm.txt
 create mode 100644 tests/resources/r7rs/liii/bitwise.scm.txt
 create mode 100644 tests/resources/r7rs/liii/case.scm.txt
 create mode 100644 tests/resources/r7rs/liii/check.scm.txt
 create mode 100644 tests/resources/r7rs/liii/chez.scm.txt
 create mode 100644 tests/resources/r7rs/liii/comparator.scm.txt
 create mode 100644 tests/resources/r7rs/liii/cut.scm.txt
 create mode 100644 tests/resources/r7rs/liii/datetime.scm.txt
 create mode 100644 tests/resources/r7rs/liii/either.scm.txt
 create mode 100644 tests/resources/r7rs/liii/error.scm.txt
 create mode 100644 tests/resources/r7rs/liii/hash-table.scm.txt
 create mode 100644 tests/resources/r7rs/liii/lang.scm.txt
 create mode 100644 tests/resources/r7rs/liii/list.scm.txt
 create mode 100644 tests/resources/r7rs/liii/logging.scm.txt
 create mode 100644 tests/resources/r7rs/liii/oop.scm.txt
 create mode 100644 tests/resources/r7rs/liii/option.scm.txt
 create mode 100644 tests/resources/r7rs/liii/os.scm.txt
 create mode 100644 tests/resources/r7rs/liii/path.scm.txt
 create mode 100644 tests/resources/r7rs/liii/range.scm.txt
 create mode 100644 tests/resources/r7rs/liii/rich-char.scm.txt
 create mode 100644 tests/resources/r7rs/liii/rich-hash-table.scm.txt
 create mode 100644 tests/resources/r7rs/liii/rich-list.scm.txt
 create mode 100644 tests/resources/r7rs/liii/rich-string.scm.txt
 create mode 100644 tests/resources/r7rs/liii/rich-vector.scm.txt
 create mode 100644 tests/resources/r7rs/liii/set.scm.txt
 create mode 100644 tests/resources/r7rs/liii/sort.scm.txt
 create mode 100644 tests/resources/r7rs/liii/stack.scm.txt
 create mode 100644 tests/resources/r7rs/liii/string.scm.txt
 create mode 100644 tests/resources/r7rs/liii/sys.scm.txt
 create mode 100644 tests/resources/r7rs/liii/uuid.scm.txt
 create mode 100644 tests/resources/r7rs/liii/vector.scm.txt
 rename tests/resources/r7rs/{ => scheme}/base.scm.txt (100%)
 rename tests/resources/r7rs/{ => scheme}/boot.scm.txt (100%)
 rename tests/resources/r7rs/{ => scheme}/case-lambda.scm.txt (100%)
 rename tests/resources/r7rs/{ => scheme}/char.scm.txt (100%)
 rename tests/resources/r7rs/{ => scheme}/file.scm.txt (100%)
 rename tests/resources/r7rs/{ => scheme}/inexact.scm.txt (100%)
 rename tests/resources/r7rs/{ => scheme}/process-context.scm.txt (100%)
 rename tests/resources/r7rs/{ => scheme}/time.scm.txt (100%)
 create mode 100644 tests/resources/r7rs/srfi/sicp.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-1.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-113.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-125.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-128.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-13.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-132.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-133.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-151.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-16.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-2.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-216.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-26.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-39.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-78.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-8.scm.txt
 create mode 100644 tests/resources/r7rs/srfi/srfi-9.scm.txt

diff --git a/tests/resources/r7rs/liii/alist.scm.txt b/tests/resources/r7rs/liii/alist.scm.txt
new file mode 100644
index 00000000..c6743a55
--- /dev/null
+++ b/tests/resources/r7rs/liii/alist.scm.txt
@@ -0,0 +1,52 @@
+;
+; BSD License by Peter Danenberg
+;
+
+(define-library (liii alist)
+(import (liii base)
+        (liii list)
+        (liii error)
+        (scheme case-lambda))
+(export alist? alist-cons alist-ref alist-ref/default vector->alist)
+(begin
+
+(define (alist? l)
+  (and (list? l)
+       (every pair? l)))
+
+(define alist-ref
+  (case-lambda
+    ((alist key)
+     (alist-ref
+       alist
+       key
+       (lambda () (key-error "alist-ref: key not found " key))))
+    ((alist key thunk)
+     (alist-ref alist key thunk eqv?))
+    ((alist key thunk =)
+     (let ((value (assoc key alist =)))
+       (if value
+           (cdr value)
+           (thunk))))))
+
+(define alist-ref/default
+  (case-lambda
+    ((alist key default)
+     (alist-ref alist key (lambda () default)))
+    ((alist key default =)
+     (alist-ref alist key (lambda () default) =))))
+
+; MIT License
+; Copyright guenchi (c) 2018 - 2019
+(define vector->alist
+  (typed-lambda ((x vector?))
+    (if (zero? (length x)) '()
+        (let loop ((x (vector->list x)) (n 0))
+             (cons (cons n (car x)) 
+                   (if (null? (cdr x))
+                       '()
+                       (loop (cdr x) (+ n 1))))))))
+    
+) ; end of begin
+) ; end of library
+
diff --git a/tests/resources/r7rs/liii/argparse.scm.txt b/tests/resources/r7rs/liii/argparse.scm.txt
new file mode 100644
index 00000000..e4d499aa
--- /dev/null
+++ b/tests/resources/r7rs/liii/argparse.scm.txt
@@ -0,0 +1,139 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii argparse)
+(import (liii base)
+        (liii error)
+        (liii list)
+        (liii string)
+        (liii hash-table)
+        (liii alist)
+        (liii sys))
+(export make-argument-parser)
+(begin
+
+(define (make-arg-record name type short-name default)
+  (list name type short-name default default))
+
+(define (convert-value value type)
+  (case type
+    ((number) 
+     (if (number? value)
+         value
+         (let ((num (string->number value)))
+           (if num 
+               num
+               (error "Invalid number format" value)))))
+    ((string) 
+     (if (string? value)
+         value
+         (error "Value is not a string")))
+    (else (error "Unsupported type" type))))
+
+(define (arg-type? type)
+  (unless (symbol? type)
+    (type-error "type of the argument must be symbol"))
+  (member type '(string number)))
+
+(define (%add-argument args-ht args)
+  (let* ((options (car args))
+         (name (alist-ref options 'name
+           (lambda () (value-error "name is required for an option"))))
+         (type (alist-ref/default options 'type 'string))
+         (short-name (alist-ref/default options 'short #f))
+         (default (alist-ref/default options 'default #f))
+         (arg-record (make-arg-record name type short-name default)))
+    (unless (string? name)
+      (type-error "name of the argument must be string"))
+    (unless (arg-type? type)
+      (value-error "Invalid type of the argument" type))
+    (unless (or (not short-name) (string? short-name))
+      (type-error "short name of the argument must be string if given"))
+    (hash-table-set! args-ht name arg-record)
+    (when short-name
+          (hash-table-set! args-ht short-name arg-record))))
+
+(define (%get-argument args-ht args)
+  (let ((found (hash-table-ref/default args-ht (car args) #f)))
+    (if found
+        (fifth found)
+        (error "Argument not found" (car args)))))
+
+(define (long-form? arg)
+  (and (string? arg) 
+       (>= (string-length arg) 3)
+       (string-starts? arg "--")))
+
+(define (short-form? arg)
+  (and (string? arg)
+       (>= (string-length arg) 2)
+       (char=? (string-ref arg 0) #\-)))
+
+(define (retrieve-args args)
+  (if (null? args)
+      (cddr (argv))
+      (car args)))
+
+(define (%parse-args args-ht prog-args)
+  (let loop ((args (retrieve-args prog-args)))
+    (if (null? args)
+        args-ht
+        (let ((arg (car args)))
+          (cond
+            ((long-form? arg)
+             (let* ((name (substring arg 2))
+                    (found (hash-table-ref args-ht name)))
+               (if found
+                   (if (null? (cdr args))
+                       (error "Missing value for argument" name)
+                       (begin
+                         (let ((value (convert-value (cadr args) (cadr found))))
+                           (set-car! (cddddr found) value))
+                         (loop (cddr args))))
+                   (value-error (string-append "Unknown option: --" name)))))
+            
+            ((short-form? arg)
+             (let* ((name (substring arg 1))
+                    (found (hash-table-ref args-ht name)))
+               (if found
+                   (if (null? (cdr args))
+                       (error "Missing value for argument" name)
+                       (begin
+                         (let ((value (convert-value (cadr args) (cadr found))))
+                           (set-car! (cddddr found) value))
+                         (loop (cddr args))))
+                   (value-error (string-append "Unknown option: -" name)))))
+            
+            (else (loop (cdr args))))))))
+
+(define (make-argument-parser)
+  (let ((args-ht (make-hash-table)))
+    (lambda (command . args)
+      (case command
+        ((add) (%add-argument args-ht args))
+        ((add-argument) (%add-argument args-ht args))
+        ((get) (%get-argument args-ht args))
+        ((get-argument) (%get-argument args-ht args))
+        ((parse) (%parse-args args-ht args))
+        ((parse-args) (%parse-args args-ht args))
+        (else
+          (if (and (null? args) (symbol? command))
+              (%get-argument args-ht (list (symbol->string command)))
+              (error "Unknown parser command" command)))))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/array-buffer.scm.txt b/tests/resources/r7rs/liii/array-buffer.scm.txt
new file mode 100644
index 00000000..d48f87b1
--- /dev/null
+++ b/tests/resources/r7rs/liii/array-buffer.scm.txt
@@ -0,0 +1,127 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii array-buffer)
+(import (liii lang) (liii error))
+(export array-buffer)
+(begin
+
+(define-case-class array-buffer
+  ((data vector?)
+   (size integer?)
+   (capacity integer?))
+
+(chained-define (@from-vector vec)
+  (let ((len (vector-length vec)))
+    (array-buffer (copy vec) len len)))
+
+(chained-define (@from-list lst)
+  (let ((len (length lst)))
+    (array-buffer (copy lst (make-vector len)) len len)))
+
+(typed-define (check-bound (n integer?))
+  (when (or (< n 0) (>= n size))
+    (index-error
+      ($ "access No." :+ n :+ " of array-buffer [0:" :+ size :+ ")" :get))))
+
+(define (%collect)
+  (copy data (make-vector size)))
+
+(define (%length) size)
+
+(define (%apply n)
+  (check-bound n)
+  (vector-ref data n))
+
+(chained-define (%set! n v)
+  (check-bound n)
+  (vector-set! data n v)
+  (%this))
+
+(define (%update! . args)
+  (apply %set! args))
+
+(chained-define (%extend! n)
+  (when (< capacity n)
+    (if (= capacity 0)
+      (set! capacity n)
+      (let loop ()
+        (when (< capacity n)
+          (set! capacity (* 2 capacity))
+          (loop))))
+    (set! data (copy data (make-vector capacity) 0 size)))
+  (%this))
+
+(define (%size-hint! . args) (apply %extend! args))
+
+(chained-define (%resize! n)
+  (%extend! n)
+  (set! size n)
+  (%this))
+
+(chained-define (%trim-to-size! n)
+  (%extend! n)
+  (set! size n)
+  (when (> capacity (* 2 size))
+    (set! data (copy data (make-vector size)))
+    (set! capacity size))
+  (%this))
+
+(chained-define (%add-one! x)
+  (%extend! (+ size 1))
+  (vector-set! data size x)
+  (set! size (+ size 1))
+  (%this))
+
+(chained-define (%clear!)
+  (set! size 0)
+  (%this))
+
+(chained-define (%clear/shrink!)
+  (set! size 0)
+  (set! capacity 1)
+  (set! data (make-vector 1))
+  (%this))
+
+(chained-define (%insert! index elem)
+  (%extend! (+ size 1))
+  (set! size (+ size 1))
+  (check-bound index)
+  (let loop ((p (- size 1)))
+    (when (> p index)
+      (vector-set! data p (vector-ref data (- p 1)))
+      (loop (- p 1))))
+  (vector-set! data index elem)
+  (%this))
+
+(typed-define (%equals (that case-class?))
+  (and (that :is-instance-of 'array-buffer)
+       ((%to-vector) :equals (that :to-vector))))
+
+(define (%to-vector)
+  (rich-vector (copy data (make-vector size))))
+
+(define (%to-list)
+  (vector->list data 0 size))
+
+(define (%to-rich-list)
+  (box (%to-list)))
+
+) ; end of array-buffer
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/base.scm.txt b/tests/resources/r7rs/liii/base.scm.txt
new file mode 100644
index 00000000..b84faad1
--- /dev/null
+++ b/tests/resources/r7rs/liii/base.scm.txt
@@ -0,0 +1,115 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii base)
+(import (scheme base)
+        (srfi srfi-2)
+        (srfi srfi-8))
+(export
+  ; (scheme base) defined by R7RS
+  let-values
+  ; R7RS 5: Program Structure
+  define-values define-record-type
+  ; R7RS 6.2: Numbers
+  square exact inexact max min floor s7-floor ceiling s7-ceiling truncate s7-truncate
+  round s7-round floor-quotient gcd lcm s7-lcm exact-integer-sqrt
+  numerator denominator
+  ; R7RS 6.3: Booleans
+  boolean=?
+  ; R7RS 6.4: list
+  pair? cons car cdr set-car! set-cdr! caar cadr cdar cddr
+  null? list? make-list list length append reverse list-tail
+  list-ref list-set! memq memv member assq assv assoc list-copy
+  ; R7RS 6.5: Symbol
+  symbol? symbol=? string->symbol symbol->string
+  ; R7RS 6.6: Characters
+  digit-value
+  ; R7RS 6.7: String
+  string-copy
+  ; R7RS 6.8 Vector
+  vector->string string->vector vector-copy vector-copy! vector-fill!
+  ; R7RS 6.9 Bytevectors
+  bytevector? make-bytevector bytevector bytevector-length bytevector-u8-ref
+  bytevector-u8-set! bytevector-copy bytevector-append
+  utf8->string string->utf8 u8-string-length u8-substring bytevector-advance-u8
+  ; Input and Output
+  call-with-port port? binary-port? textual-port? input-port-open? output-port-open?
+  open-binary-input-file open-binary-output-file close-port eof-object
+  ; Control flow
+  string-map vector-map string-for-each vector-for-each
+  ; Exception
+  raise guard read-error? file-error?
+  ; SRFI-2
+  and-let*
+  ; SRFI-8
+  receive
+  ; Extra routines
+  loose-car loose-cdr compose identity any?
+  ; Extra structure
+  let1  typed-lambda
+)
+(begin
+
+(define* (u8-substring str (start 0) (end #t))
+  (utf8->string (string->utf8 str start end)))
+
+(define (loose-car pair-or-empty)
+  (if (eq? '() pair-or-empty)
+      '()
+      (car pair-or-empty)))
+
+(define (loose-cdr pair-or-empty)
+  (if (eq? '() pair-or-empty)
+      '()
+      (cdr pair-or-empty)))
+
+(define identity (lambda (x) x))
+
+(define (compose . fs)
+  (if (null? fs)
+      (lambda (x) x)
+      (lambda (x)
+        ((car fs) ((apply compose (cdr fs)) x)))))
+  
+(define (any? x) #t)
+
+(define-macro (let1 name1 value1 . body)
+  `(let ((,name1 ,value1))
+     ,@body))
+
+; 0 clause BSD, from S7 repo stuff.scm
+(define-macro (typed-lambda args . body)
+  ; (typed-lambda ((var [type])...) ...)
+  (if (symbol? args)
+      (apply lambda args body)
+      (let ((new-args (copy args)))
+        (do ((p new-args (cdr p)))
+            ((not (pair? p)))
+          (if (pair? (car p))
+              (set-car! p (caar p))))
+        `(lambda ,new-args
+           ,@(map (lambda (arg)
+                    (if (pair? arg)
+                        `(unless (,(cadr arg) ,(car arg))
+                           (error 'type-error
+                             "~S is not ~S~%" ',(car arg) ',(cadr arg)))
+                        (values)))
+                  args)
+           ,@body))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/base64.scm.txt b/tests/resources/r7rs/liii/base64.scm.txt
new file mode 100644
index 00000000..e51e1550
--- /dev/null
+++ b/tests/resources/r7rs/liii/base64.scm.txt
@@ -0,0 +1,136 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii base64)
+(import (liii base)
+        (liii bitwise))
+(export
+  string-base64-encode bytevector-base64-encode base64-encode
+  string-base64-decode bytevector-base64-decode base64-decode
+)
+(begin
+(define-constant BYTE2BASE64_BV
+  (string->utf8 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"))
+
+(define-constant BASE64_PAD_BYTE
+  (char->integer #\=))
+
+(define bytevector-base64-encode
+  (typed-lambda ((bv bytevector?))
+    (define (encode b1 b2 b3)
+      (let* ((p1 b1)
+             (p2 (if b2 b2 0))
+             (p3 (if b3 b3 0))
+             (combined (bitwise-ior (ash p1 16) (ash p2 8) p3))
+             (c1 (bitwise-and (ash combined -18) #x3F))
+             (c2 (bitwise-and (ash combined -12) #x3F))
+             (c3 (bitwise-and (ash combined -6) #x3F))
+             (c4 (bitwise-and combined #x3F)))
+        (values
+          (BYTE2BASE64_BV c1)
+          (BYTE2BASE64_BV c2)
+          (if b2 (BYTE2BASE64_BV c3) BASE64_PAD_BYTE)
+          (if b3 (BYTE2BASE64_BV c4) BASE64_PAD_BYTE))))
+    
+    (let* ((input-N (bytevector-length bv))
+           (output-N (* 4 (ceiling (/ input-N 3))))
+           (output (make-bytevector output-N)))
+      (let loop ((i 0) (j 0))
+        (when (< i input-N)
+          (let* ((b1 (bv i))
+                 (b2 (if (< (+ i 1) input-N) (bv (+ i 1)) #f))
+                 (b3 (if (< (+ i 2) input-N) (bv (+ i 2)) #f)))
+            (receive (r1 r2 r3 r4) (encode b1 b2 b3)
+              (bytevector-u8-set! output j r1)
+              (bytevector-u8-set! output (+ j 1) r2)
+              (bytevector-u8-set! output (+ j 2) r3)
+              (bytevector-u8-set! output (+ j 3) r4)
+              (loop (+ i 3) (+ j 4))))))
+      output)))
+
+(define string-base64-encode
+  (typed-lambda ((str string?))
+    (utf8->string (bytevector-base64-encode (string->utf8 str)))))
+
+(define (base64-encode x)
+  (cond ((string? x)
+         (string-base64-encode x))
+        ((bytevector? x)
+         (bytevector-base64-encode x))
+        (else
+         (type-error "input must be string or bytevector"))))
+
+(define-constant BASE64_TO_BYTE_V
+  (let1 byte2base64-N (bytevector-length BYTE2BASE64_BV)
+    (let loop ((i 0) (v (make-vector 256 -1)))
+      (if (< i byte2base64-N)
+          (begin
+            (vector-set! v (BYTE2BASE64_BV i) i)
+            (loop (+ i 1) v))
+          v))))
+
+(define (bytevector-base64-decode bv)
+  (define (decode c1 c2 c3 c4)
+    (let* ((b1 (BASE64_TO_BYTE_V c1))
+           (b2 (BASE64_TO_BYTE_V c2))
+           (b3 (BASE64_TO_BYTE_V c3))
+           (b4 (BASE64_TO_BYTE_V c4)))
+      (if (or (negative? b1) (negative? b2)
+              (and (negative? b3) (not (equal? c3 BASE64_PAD_BYTE)))
+              (and (negative? b4) (not (equal? c4 BASE64_PAD_BYTE))))
+          (value-error "Invalid base64 input")
+          (values
+            (bitwise-ior (ash b1 2) (ash b2 -4))
+            (bitwise-and (bitwise-ior (ash b2 4) (ash b3 -2)) #xFF)
+            (bitwise-and (bitwise-ior (ash b3 6) b4) #xFF)
+            (if (negative? b3) 1 (if (negative? b4) 2 3))))))
+  
+  (let* ((input-N (bytevector-length bv))
+         (output-N (* input-N 3/4))
+         (output (make-bytevector output-N)))
+
+    (unless (zero? (modulo input-N 4))
+      (value-error "length of the input bytevector must be 4X"))
+    
+    (let loop ((i 0) (j 0))
+      (if (< i input-N)
+          (receive (r1 r2 r3 cnt)
+                   (decode (bv i) (bv (+ i 1)) (bv (+ i 2)) (bv (+ i 3)))
+            (bytevector-u8-set! output j r1)
+            (when (>= cnt 2)
+              (bytevector-u8-set! output (+ j 1) r2))
+            (when (>= cnt 3)
+              (bytevector-u8-set! output (+ j 2) r3))
+            (loop (+ i 4) (+ j cnt)))
+          (let ((final (make-bytevector j)))
+            (vector-copy! final 0 output 0 j)
+            final)))))
+
+(define string-base64-decode
+  (typed-lambda ((str string?))
+    (utf8->string (bytevector-base64-decode (string->utf8 str)))))
+
+(define (base64-decode x)
+  (cond ((string? x)
+         (string-base64-decode x))
+        ((bytevector? x)
+         (bytevector-base64-decode x))
+        (else
+         (type-error "input must be string or bytevector"))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/bitwise.scm.txt b/tests/resources/r7rs/liii/bitwise.scm.txt
new file mode 100644
index 00000000..370b82e7
--- /dev/null
+++ b/tests/resources/r7rs/liii/bitwise.scm.txt
@@ -0,0 +1,37 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii bitwise)
+(import (srfi srfi-151)
+        (liii error))
+(export
+  ; from (srfi srfi-151)
+  bitwise-not bitwise-and bitwise-ior bitwise-xor bitwise-eqv  bitwise-or bitwise-nor bitwise-nand
+  bit-count bitwise-orc1 bitwise-orc2 bitwise-andc1 bitwise-andc2
+  arithmetic-shift integer-length bitwise-if
+  bit-set? copy-bit bit-swap any-bit-set? every-bit-set? first-set-bit
+  bit-field bit-field-any? bit-field-every? bit-field-clear bit-field-set
+  ; S7 built-in
+  lognot logand logior logxor
+  ash
+)
+(begin
+
+(define bitwise-or bitwise-ior)
+
+) ; end of begin
+) ; end of library
+
diff --git a/tests/resources/r7rs/liii/case.scm.txt b/tests/resources/r7rs/liii/case.scm.txt
new file mode 100644
index 00000000..68e575c5
--- /dev/null
+++ b/tests/resources/r7rs/liii/case.scm.txt
@@ -0,0 +1,344 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii case)
+(import (liii base))
+(export case*)
+(begin
+
+; 0 clause BSD, from S7 repo case.scm
+(define case* 
+  (let ((case*-labels (lambda (label)
+      (let ((labels ((funclet ((funclet 'case*) 'case*-helper)) 'labels)))
+        (labels (symbol->string label))))) ; if ellipsis, this has been quoted by case*
+  
+  (case*-match? (lambda* (matchee pattern (e (curlet)))
+      (let ((matcher ((funclet ((funclet 'case*) 'case*-helper)) 'handle-sequence)))
+        (or (equivalent? matchee pattern)
+            (and (or (pair? matchee) 
+               (vector? matchee))
+           (begin
+             (fill! ((funclet ((funclet 'case*) 'case*-helper)) 'labels) #f) ; clear labels
+             ((matcher pattern e) matchee)))))))
+  (case*-helper
+   (with-let (unlet)
+     (define labels (make-hash-table))
+
+     (define (ellipsis? pat)
+       (and (undefined? pat)
+      (or (equal? pat #<...>)
+          (let ((str (object->string pat)))
+      (and (char-position #\: str)
+           (string=? "...>" (substring str (- (length str) 4))))))))
+       
+     (define (ellipsis-pair-position pos pat)
+       (and (pair? pat)
+      (if (ellipsis? (car pat))
+          pos
+          (ellipsis-pair-position (+ pos 1) (cdr pat)))))
+
+     (define (ellipsis-vector-position pat vlen)
+       (let loop ((pos 0))
+         (and (< pos vlen)
+        (if (ellipsis? (pat pos))
+      pos
+      (loop (+ pos 1))))))
+
+     (define (splice-out-ellipsis sel pat pos e)
+       (let ((sel-len (length sel))
+       (new-pat-len (- (length pat) 1))
+       (ellipsis-label (and (not (eq? (pat pos) #<...>))              
+          (let* ((str (object->string (pat pos)))
+                 (colon (char-position #\: str)))
+            (and colon
+                 (substring str 2 colon))))))
+         (let ((func (and (string? ellipsis-label)
+        (let ((comma (char-position #\, ellipsis-label)))
+          (and comma
+               (let ((str (substring ellipsis-label (+ comma 1))))
+           (set! ellipsis-label (substring ellipsis-label 0 comma))
+           (let ((func-val (symbol->value (string->symbol str) e)))
+             (if (undefined? func-val)
+                 (error 'unbound-variable "function ~S is undefined\n" func))
+             (if (not (procedure? func-val))
+                 (error 'wrong-type-arg "~S is not a function\n" func))
+             func-val)))))))
+     (if (pair? pat)
+         (cond ((= pos 0)               ; ellipsis at start of pattern
+          (if ellipsis-label
+        (set! (labels ellipsis-label) 
+              (list 'quote (copy sel (make-list (- sel-len new-pat-len))))))
+          (values (list-tail sel (- sel-len new-pat-len))
+            (cdr pat)
+            (or (not func)
+          (func (cadr (labels ellipsis-label)))))) ; value is (quote ...) and we want the original list here
+         
+         ((= pos new-pat-len)     ; ellipsis at end of pattern
+          (if ellipsis-label
+        (set! (labels ellipsis-label) 
+              (list 'quote (copy sel (make-list (- sel-len pos)) pos))))
+          (values (copy sel (make-list pos))
+            (copy pat (make-list pos))
+            (or (not func) 
+          (func (cadr (labels ellipsis-label))))))
+         
+         (else                    ; ellipsis somewhere in the middle
+          (let ((new-pat (make-list new-pat-len))
+          (new-sel (make-list new-pat-len)))
+            (if ellipsis-label
+          (set! (labels ellipsis-label) 
+          (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))))
+            (copy pat new-pat 0 pos)
+            (copy pat (list-tail new-pat pos) (+ pos 1))
+            (copy sel new-sel 0 pos)
+            (copy sel (list-tail new-sel pos) (- sel-len pos))
+            (values new-sel new-pat
+              (or (not func) 
+            (func (cadr (labels ellipsis-label))))))))
+         
+         (cond ((= pos 0)
+          (if ellipsis-label
+        (set! (labels ellipsis-label) 
+              (list 'quote (copy sel (make-list (- sel-len new-pat-len))))))
+          (values (subvector sel (max 0 (- sel-len new-pat-len)) sel-len) ; was new-pat-len (max 0 (- sel-len new-pat-len))
+            (subvector pat 1 (+ new-pat-len 1))                     ;     new-pat-len 1
+            (or (not func) 
+          (func (cadr (labels ellipsis-label))))))
+         
+         ((= pos new-pat-len)
+          (if ellipsis-label
+        (set! (labels ellipsis-label) 
+              (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))))
+          (values (subvector sel 0 new-pat-len)
+            (subvector pat 0 new-pat-len)
+            (or (not func) 
+          (func (cadr (labels ellipsis-label))))))
+         
+         (else
+          (let ((new-pat (make-vector new-pat-len))
+          (new-sel (make-vector new-pat-len)))
+            (if ellipsis-label
+          (set! (labels ellipsis-label) 
+          (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))))
+            (copy pat new-pat 0 pos)
+            (copy pat (subvector new-pat pos new-pat-len) (+ pos 1))       ; (- new-pat-len pos) pos)   copy: (+ pos 1))
+            (copy sel new-sel 0 pos)
+            (copy sel (subvector new-sel pos new-pat-len) (- sel-len pos))
+                                                                           ; (- new-pat-len pos) pos)  copy: (- sel-len pos))
+            (values new-sel new-pat
+              (or (not func) 
+            (cadr (func (labels ellipsis-label))))))))))))
+       
+     (define (handle-regex x) #f)
+     ;(define handle-regex
+     ;  (let ((rg ((*libc* 'regex.make))) ; is this safe?
+     ;  (local-regcomp (*libc* 'regcomp))
+     ;  (local-regerror (*libc* 'regerror))
+     ;  (local-regexec (*libc* 'regexec))
+     ;  (local-regfree (*libc* 'regfree)))
+     ;    (lambda (reg)
+     ;(lambda (x)
+     ;  (and (string? x)
+     ; (let ((res (local-regcomp rg (substring reg 1 (- (length reg) 1)) 0)))
+     ;   (unless (zero? res)
+     ;     (error 'regex-error "~S~%" (local-regerror res rg)))
+     ;   (set! res (local-regexec rg x 0 0))
+     ;   (local-regfree rg)
+     ;   (zero? res)))))))
+
+     (define (undefined->function undef e)   ; handle the pattern descriptor ("undef") of the form #< whatever >, "e" = caller's curlet
+       (let* ((str1 (object->string undef))
+        (str1-end (- (length str1) 1)))
+         (if (not (char=? (str1 str1-end) #\>))
+       (error 'wrong-type-arg "pattern descriptor does not end in '>': ~S\n" str1))
+         (let ((str (substring str1 2 str1-end)))
+     (if (= (length str) 0)                                           ; #<> = accept anything
+         (lambda (x) #t)
+         (let ((colon (char-position #\: str)))
+           (cond (colon                                               ; #<label:...> might be #<label:> or #<label:func>
+            (let ((label (substring str 0 colon))               ; str is label:...
+            (func (substring str (+ colon 1))))           ; func might be ""
+        (cond ((labels label)                             ; see if we already have saved something under this label
+               (lambda (sel)                              ;   if so, return function that will return an error
+           (error 'syntax-error "label ~S is defined twice: old: ~S, new: ~S~%" label (labels label) sel)))
+              
+              ;; otherwise the returned function needs to store the current sel-item under label in labels
+              ((zero? (length func))
+               (lambda (x)
+           (set! (labels label) x)                  ; #<label:>, set label, accept anything
+           #t))
+              
+              ((char=? (func 0) #\")                      ; labelled regex, #<label:"regexp">
+               (lambda (x)
+           (set! (labels label) x)
+           (handle-regex func)))
+              
+              (else                                       ; #<label:func>
+               (let ((func-val (symbol->value (string->symbol func) e)))
+           (if (undefined? func-val)
+               (error 'unbound-variable "function ~S is undefined\n" func)
+               (if (not (procedure? func-val))
+             (error 'wrong-type-arg "~S is not a function\n" func)
+             (lambda (x)                     ; set label and call func
+               (set! (labels label) x)
+               (func-val x)))))))))
+           
+           ;; if no colon either #<label> or #<func> or #<"regexp"> -- label means match its saved expr, func = call func
+           ((char=? (str 0) #\")
+            (handle-regex str))
+           
+           (else                                                ; #<label> or #<func>
+            (let ((saved (labels str)))
+        (if saved                                         ; #<label>
+            (lambda (x) (equivalent? x saved))
+            (symbol->value (string->symbol str) e)))))))))) ; #<func> using curlet=e passed in above
+     
+     (define (handle-pattern sel-item pat-item e)
+       (and (undefined? pat-item)      ; turn #<func> into func and call it on the current selector element
+      (not (eq? pat-item #<undefined>))
+      (let ((func (undefined->function pat-item e)))
+        (if (undefined? func)
+      (error 'unbound-variable "function ~S is undefined\n" pat-item))
+        (if (not (procedure? func))
+      (error 'wrong-type-arg "~S is not a function\n" func))
+        (func sel-item))))
+
+     (define (handle-sequence pat e)
+       (lambda (sel)
+         ;(format *stderr* "~S ~S~%" sel pat)
+         (and (eq? (type-of sel) (type-of pat))
+        (let ((func-ok #t))
+
+          (when (or (pair? pat)                           ; look for ellipsis
+        (vector? pat))
+      (if (pair? (cyclic-sequences pat))
+          (error 'wrong-type-arg "case* pattern is cyclic: ~S~%" pat))
+      (let ((pos (if (pair? pat)
+               (ellipsis-pair-position 0 pat)
+               (ellipsis-vector-position pat (length pat)))))
+        (when (and pos
+             (>= (length sel) (- (length pat) 1))) ; else pat without ellipsis is too long for sel
+          (let ((new-vars (list (splice-out-ellipsis sel pat pos e))))
+            (set! sel (car new-vars))
+            (set! pat (cadr new-vars))
+            (set! func-ok (caddr new-vars))))))
+
+          (and (= (length sel) (length pat))             ; march through selector and current target matching elements
+         func-ok
+         (call-with-exit
+          (lambda (return)
+            (for-each 
+             (lambda (sel-item pat-item)
+         (or (equivalent? sel-item pat-item) ; items match
+
+             (and (or (pair? pat-item)       ; recursive check (* (+ #<symbol?> 1) 2), pat-item: (+ #symbol?> 1)
+                (vector? pat-item))    ; pat-item, not sel-item here so pat-item can cover anything (a list for example)
+            ((handle-sequence pat-item e) sel-item))
+
+             (handle-pattern sel-item pat-item e)
+
+             (return #f)))                   ; else give up (selector does not match target)
+             sel pat)
+            
+            ;; dotted list, check final cdr
+            (unless (or (not (pair? sel)) 
+            (proper-list? sel))
+        (let ((sel-item (list-tail sel (abs (length sel))))
+              (pat-item (list-tail pat (abs (length pat)))))
+          (return (or (equivalent? sel-item pat-item)
+                (handle-pattern sel-item pat-item e)))))
+              
+            #t)))))))
+
+     (define (find-labelled-pattern tree)
+       ;; walk body looking for a labelled pattern
+       (or (undefined? tree)
+     (and (pair? tree)
+          (or (find-labelled-pattern (car tree))
+        (find-labelled-pattern (cdr tree))))
+     (and (vector? tree)
+          (let vector-walker ((pos 0))
+      (and (< pos (length tree))
+           (or (undefined? (tree pos))
+         (and (pair? (tree pos))
+              (find-labelled-pattern (tree pos)))
+         (and (vector? (tree pos))
+              (vector-walker (tree pos)))
+         (vector-walker (+ pos 1))))))))
+
+     (define (handle-body select body return e)
+       (if (null? body)
+     (return select))
+
+       (when (find-labelled-pattern body) ; if labelled, remake the body substituting the labelled-exprs for the labels
+         (set! body (let pair-builder ((tree body))
+          (cond ((undefined? tree)
+           (let ((label (let ((str (object->string tree)))
+              (substring str 2 (- (length str) 1)))))
+             (or (labels label) tree)))
+          
+          ((pair? tree)
+           (cons (pair-builder (car tree))
+           (pair-builder (cdr tree))))
+          
+          ((vector? tree)
+           (vector (map pair-builder tree)))
+          
+          (else tree)))))
+     
+       ;; evaluate the result (case* expands into a call on case*-helper; we need to evaluate the result expressions ourselves)
+       (return (eval (if (null? (cdr body))
+             (car body)
+             (if (eq? (car body) '=>)
+           (list (cadr body) select)
+           (cons 'begin body)))
+         e)))
+    
+     ;; case*-helper
+     (lambda (select clauses e)
+       (call-with-exit
+        (lambda (return)
+    (for-each
+     (lambda (clause)                                        ;((target...) body...)
+       (let ((targets (car clause))
+       (body (cdr clause)))
+         (fill! labels #f)                                   ; clear previous labels
+         (if (memq targets '(else #t))                       ; (else...) or (#t...)
+       (return (eval (cons 'begin body) e))
+       (for-each
+        (lambda (target)
+          (if (or (equivalent? target select)
+            (and (undefined? target)              ; #<...>
+           (not (eq? target #<undefined>))
+           (let ((func (undefined->function target e)))
+             ;(format *stderr* "func: ~S~%" func)
+             ;; (if (undefined? func) (error 'unbound-variable "function ~A is undefined\n" str))
+             ;; not the above check because we want to be able to pass patterns as selectors! (scase37 in s7test)
+             ;;    this seems like a mistake: #<symbol?> won't work? 
+             (and (procedure? func)
+            (func select))))
+            (and (sequence? target)
+           ((handle-sequence target e) select)))
+        (handle-body select body return e)))
+        targets))))
+     clauses)))))))
+    ;; case*
+    (#_macro (selector . clauses)
+      `(((#_funclet 'case*) 'case*-helper) ,selector ',clauses (#_curlet)))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/check.scm.txt b/tests/resources/r7rs/liii/check.scm.txt
new file mode 100644
index 00000000..f9efaf4f
--- /dev/null
+++ b/tests/resources/r7rs/liii/check.scm.txt
@@ -0,0 +1,51 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii check)
+(export test check check-set-mode! check:proc
+  check-catch check-report check-failed?
+  check-true check-false)
+(import (srfi srfi-78)
+        (rename (srfi srfi-78)
+                (check-report srfi-78-check-report)))
+(begin
+
+(define-macro (check-true body)
+  `(check ,body => #t))
+
+(define-macro (check-false body)
+  `(check ,body => #f))
+
+(define-macro (check-catch error-id body)
+  `(check
+    (catch ,error-id
+      (lambda () ,body)
+      (lambda args ,error-id))
+      => ,error-id))
+
+(define-macro (test left right)
+  `(check ,left => ,right))
+
+(define (check-report . msg)
+  (if (not (null? msg))
+    (begin
+      (display (car msg))))
+  (srfi-78-check-report)
+  (if (check-failed?) (exit -1)))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/chez.scm.txt b/tests/resources/r7rs/liii/chez.scm.txt
new file mode 100644
index 00000000..f58fe80c
--- /dev/null
+++ b/tests/resources/r7rs/liii/chez.scm.txt
@@ -0,0 +1,26 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii chez)
+(export atom?)
+(begin
+
+(define (atom? x)
+  (not (pair? x)))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/comparator.scm.txt b/tests/resources/r7rs/liii/comparator.scm.txt
new file mode 100644
index 00000000..393bb99c
--- /dev/null
+++ b/tests/resources/r7rs/liii/comparator.scm.txt
@@ -0,0 +1,35 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii comparator)
+(import (srfi srfi-128))
+(export
+  comparator? comparator-ordered? comparator-hashable?
+  make-comparator make-pair-comparator make-list-comparator
+  make-vector-comparator make-eq-comparator make-eqv-comparator make-equal-comparator
+  boolean-hash char-hash char-ci-hash string-hash string-ci-hash
+  symbol-hash number-hash
+  make-default-comparator default-hash
+  comparator-type-test-predicate comparator-equality-predicate
+  comparator-ordering-predicate comparator-hash-function
+  comparator-test-type comparator-check-type comparator-hash
+  =? <? >? <=? >=?
+)
+(begin
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/cut.scm.txt b/tests/resources/r7rs/liii/cut.scm.txt
new file mode 100644
index 00000000..f8b6e139
--- /dev/null
+++ b/tests/resources/r7rs/liii/cut.scm.txt
@@ -0,0 +1,20 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii cut)
+  (import (srfi srfi-26))
+  (export cut cute))
+
diff --git a/tests/resources/r7rs/liii/datetime.scm.txt b/tests/resources/r7rs/liii/datetime.scm.txt
new file mode 100644
index 00000000..526af674
--- /dev/null
+++ b/tests/resources/r7rs/liii/datetime.scm.txt
@@ -0,0 +1,193 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii datetime)
+(import (liii oop))
+(export datetime date years)
+(begin
+
+(define-object years
+
+(define (@leap? year)
+  (when (not (integer? year))
+    (type-error "years@leap? must accept integer"))
+  (or (and (zero? (modulo year 4)) 
+           (not (zero? (modulo year 100))))
+      (zero? (modulo year 400))))
+
+)
+
+(define-case-class datetime
+  ((year integer?)
+   (month integer?)
+   (day integer?)
+   (hour integer? 0)
+   (minute integer? 0)
+   (second integer? 0)
+   (micro-second integer? 0))
+
+(chained-define (@now)
+  (let ((time-vec (g_datetime-now)))
+    (datetime 
+      :year (vector-ref time-vec 0)
+      :month (vector-ref time-vec 1)
+      :day (vector-ref time-vec 2)
+      :hour (vector-ref time-vec 3)
+      :minute (vector-ref time-vec 4)
+      :second (vector-ref time-vec 5)
+      :micro-second (vector-ref time-vec 6))))
+
+(define (%to-string)
+  (define (pad2 n)  ; 补零到 2 位
+    (if (< n 10)
+        (string-append "0" (number->string n))
+        (number->string n)))
+  (define (pad6 n)  ; 补零到 6 位（微秒）
+    (let ((s (number->string n)))
+      (string-append (make-string (- 6 (string-length s)) #\0) s)))
+  
+  (let ((date-part (string-append (number->string year) "-"
+                                 (pad2 month) "-"
+                                 (pad2 day)))
+        (time-part (string-append (pad2 hour) ":"
+                                 (pad2 minute) ":"
+                                 (pad2 second))))
+    (if (zero? micro-second)
+        (string-append date-part " " time-part)
+        (string-append date-part " " time-part "." (pad6 micro-second)))))
+
+(define (%plus-days days-to-add)
+  
+  (define (days-in-month m y)
+    (cond ((member m '(4 6 9 11)) 30)
+          ((= m 2) (if (years :leap? y) 29 28))
+          (else 31)))
+  
+  (let loop ((y year)
+             (m month)
+             (d day)
+             (remaining-days days-to-add))
+    (cond
+      ;; No more days to add
+      ((zero? remaining-days)
+       (datetime :year y
+                 :month m
+                 :day d
+                 :hour hour
+                 :minute minute
+                 :second second
+                 :micro-second micro-second))
+      
+      ;; Adding days (positive)
+      ((> remaining-days 0)
+       (let ((days-in-current-month (days-in-month m y)))
+         (if (<= (+ d remaining-days) days-in-current-month)
+             ;; Simple case: result is within the same month
+             (loop y m (+ d remaining-days) 0)
+             ;; Complex case: need to move to next month
+             (let ((next-month (if (= m 12) 1 (+ m 1)))
+                   (next-year (if (= m 12) (+ y 1) y)))
+               (loop next-year 
+                     next-month 
+                     1 
+                     (- (+ remaining-days d) days-in-current-month 1))))))
+      
+      ;; Subtracting days (negative)
+      (else
+       (if (> d (abs remaining-days))
+           ;; Simple case: result is within the same month
+           (loop y m (+ d remaining-days) 0)
+           ;; Complex case: need to move to previous month
+           (let* ((prev-month (if (= m 1) 12 (- m 1)))
+                  (prev-year (if (= m 1) (- y 1) y))
+                  (days-in-prev-month (days-in-month prev-month prev-year)))
+             (loop prev-year 
+                   prev-month 
+                   days-in-prev-month 
+                   (+ remaining-days d))))))))
+
+(define (%plus-months months-to-add)
+  (define (days-in-month m y)
+    (cond ((member m '(4 6 9 11)) 30)
+          ((= m 2) (if (years :leap? y) 29 28))
+          (else 31)))
+  
+  ;; Calculate new year and month
+  (let* ((total-months (+ (+ (* year 12) month -1) months-to-add))
+         (new-year (quotient total-months 12))
+         (new-month (+ (remainder total-months 12) 1))
+         ;; Adjust day if necessary
+         (days-in-new-month (days-in-month new-month new-year))
+         (new-day (min day days-in-new-month)))
+    
+    (datetime :year new-year
+              :month new-month
+              :day new-day
+              :hour hour
+              :minute minute
+              :second second
+              :micro-second micro-second)))
+
+(define (%plus-years years-to-add)
+  (define (days-in-month m y)
+    (cond ((member m '(4 6 9 11)) 30)
+          ((= m 2) (if (years :leap? y) 29 28))
+          (else 31)))
+  
+  ;; Calculate new year
+  (let* ((new-year (+ year years-to-add))
+         ;; Adjust day if necessary (for Feb 29 in leap years)
+         (days-in-new-month (days-in-month month new-year))
+         (new-day (min day days-in-new-month)))
+    
+    (datetime :year new-year
+              :month month
+              :day new-day
+              :hour hour
+              :minute minute
+              :second second
+              :micro-second micro-second)))
+
+)
+
+(define-case-class date
+  ((year integer?)
+   (month integer?)
+   (day integer?))
+
+(chained-define (@now)
+  (let ((time-vec (g_date-now)))
+    (date 
+      :year (vector-ref time-vec 0)
+      :month (vector-ref time-vec 1)
+      :day (vector-ref time-vec 2))))
+
+(define (%to-string)
+  (define (pad2 n)  ; 补零到 2 位
+    (if (< n 10)
+        (string-append "0" (number->string n))
+        (number->string n)))
+  
+  (let ((date-part (string-append (number->string year) "-"
+                                  (pad2 month) "-"
+                                  (pad2 day))))
+       date-part))
+
+)
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/either.scm.txt b/tests/resources/r7rs/liii/either.scm.txt
new file mode 100644
index 00000000..cf4f42a1
--- /dev/null
+++ b/tests/resources/r7rs/liii/either.scm.txt
@@ -0,0 +1,122 @@
+;
+; Copyright (C) 2025 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii either)
+(import (liii option) (liii oop) (liii base))
+(export either left right)
+(begin
+
+(define-case-class either
+  ((type symbol?)
+   (value any?))
+
+(define (%left?)
+  (eq? type 'left))
+
+(define (%right?)
+  (eq? type 'right))
+
+(define (%get)
+  value)
+
+(define (%or-else default)
+  (unless (case-class? default) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %or-else '(default) 'default "case-class" (object->string default))))  
+  
+  (when (not (default :is-instance-of 'either))
+    (type-error "The first parameter of either%or-else must be a either case class"))
+
+  (if (%right?)
+      (%this)
+      default))
+
+(define (%get-or-else default)
+  (cond ((%right?) value)
+        ((and (procedure? default) (not (case-class? default)))
+         (default))
+        (else default)))
+
+(define (%filter-or-else pred zero)
+  (unless (procedure? pred) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %filter-or-else '(pred zero) 'pred "procedure" (object->string pred))))
+  
+  (unless (any? zero) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %filter-or-else '(pred zero) 'zero "any" (object->string zero))))  
+  (if (%right?)
+      (if (pred value)
+          (%this)
+          (left zero))
+      (%this)))
+
+(define (%contains x)
+  (and (%right?)
+       (class=? x value)))
+
+(define (%for-each f)
+  (when (%right?)
+    (f value)))
+
+(define (%to-option)
+  (if (%right?)
+      (option value)
+      (none)))
+
+(define (%map f . args)
+  (chain-apply args
+    (if (%right?)
+      (right (f value))
+      (%this))))
+
+(define (%flat-map f . args)
+  (chain-apply args
+    (if (%right?)
+      (f value)
+      (%this))))
+
+(define (%forall pred)
+  (unless (procedure? pred) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %forall '(pred) 'pred "procedure" (object->string pred))))
+  (if (%right?)
+      (pred value)
+      #t))
+
+(define (%exists pred)
+  (unless (procedure? pred) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %exists '(pred) 'pred "procedure" (object->string pred))))
+  (if (%right?)
+      (pred value)
+      #f))
+
+)
+
+(define (left v)
+  (either 'left v))
+
+(define (right v)
+  (either 'right v))
+
+) ; end of begin
+) ; end of define-library
diff --git a/tests/resources/r7rs/liii/error.scm.txt b/tests/resources/r7rs/liii/error.scm.txt
new file mode 100644
index 00000000..affc2def
--- /dev/null
+++ b/tests/resources/r7rs/liii/error.scm.txt
@@ -0,0 +1,59 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+; see https://docs.python.org/3/library/exceptions.html#exception-hierarchy
+(define-library (liii error)
+(export ???
+  os-error file-not-found-error not-a-directory-error file-exists-error
+  timeout-error type-error type-error? key-error value-error index-error)
+(begin
+
+(define (os-error . args)
+  (apply error (cons 'os-error args)))
+
+(define (file-not-found-error . args)
+  (apply error (cons 'file-not-found-error args)))
+
+(define (not-a-directory-error . args)
+  (apply error (cons 'not-a-directory-error args)))
+
+(define (file-exists-error . args)
+  (apply error (cons 'file-exists-error args)))
+
+(define (timeout-error . args)
+  (apply error (cons 'timeout-error args)))
+
+(define (type-error . args)
+  (apply error (cons 'type-error args)))
+
+(define (type-error? err)
+  (not (null? (member err `(type-error wrong-type-arg)))))
+
+(define (key-error . args)
+  (apply error (cons 'key-error args)))
+
+(define (value-error . args)
+  (apply error (cons 'value-error args)))
+
+(define (index-error . args)
+  (apply error (cons 'index-error args)))
+
+(define (??? . args)
+  (apply error (cons '??? args)))
+
+) ; begin
+) ; define-library
+
diff --git a/tests/resources/r7rs/liii/hash-table.scm.txt b/tests/resources/r7rs/liii/hash-table.scm.txt
new file mode 100644
index 00000000..dc2707ac
--- /dev/null
+++ b/tests/resources/r7rs/liii/hash-table.scm.txt
@@ -0,0 +1,35 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii hash-table)
+(import (srfi srfi-125)
+        (srfi srfi-128))
+(export
+  make-hash-table hash-table hash-table-unfold alist->hash-table
+  hash-table? hash-table-contains? hash-table-empty? hash-table=?
+  hash-table-mutable?
+  hash-table-ref hash-table-ref/default
+  hash-table-set! hash-table-delete! hash-table-intern! hash-table-update!
+  hash-table-update!/default hash-table-pop! hash-table-clear!
+  hash-table-size hash-table-keys hash-table-values hash-table-entries
+  hash-table-find hash-table-count
+  hash-table-for-each hash-table-map->list
+  hash-table->alist
+)
+(begin
+) ; end of begin
+) ; end of library
+
diff --git a/tests/resources/r7rs/liii/lang.scm.txt b/tests/resources/r7rs/liii/lang.scm.txt
new file mode 100644
index 00000000..f906ba57
--- /dev/null
+++ b/tests/resources/r7rs/liii/lang.scm.txt
@@ -0,0 +1,153 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii lang)
+                
+(import (only (liii base)
+              u8-string-length any? receive u8-substring)
+        (only (liii oop)
+              define-case-class display* @ typed-define case-class? chained-define
+              define-object define-class chain-apply object->string)
+        (only (liii sort) list-stable-sort vector-stable-sort)
+        (only (liii hash-table)
+              hash-table-update!/default hash-table-for-each hash-table-ref/default hash-table-contains? hash-table-delete!
+              hash-table-count)
+        (only (liii bitwise) bitwise-and bitwise-ior arithmetic-shift)
+        (liii error)
+        (liii list)
+        (liii option)
+        (liii either)
+        (liii rich-list)
+        (liii rich-char)
+        (liii rich-vector)
+        (liii rich-string)
+        (liii rich-hash-table))
+
+(export
+  @ typed-define define-case-class define-object define-class
+  case-class? class=? chained-define display* object->string
+  option none either left right
+  rich-integer rich-float rich-char rich-string
+  rich-vector rich-list array rich-hash-table
+  box $
+)
+(begin
+
+(define (class=? left right)
+  (cond
+    ((and (case-class? left) (case-class? right))
+     (left :equals right))
+    ((case-class? left)
+     (left :equals ($ right)))
+    ((case-class? right)
+     ($ left :equals right))
+    (else
+     (equal? left right))))
+
+(define (box x)
+  (cond ((integer? x) (rich-integer x))
+        ((rational? x) (rich-rational x))
+        ((float? x) (rich-float x))
+        ((char? x) (rich-char x))
+        ((string? x) (rich-string x))
+        ((list? x) (rich-list x))
+        ((vector? x) (rich-vector x))
+        ((hash-table? x) (rich-hash-table x))
+        (else (type-error "box: x must be integer?, rational?, float?, char?, string?, list?, vector?, hash-table?"))))
+
+(define ($ x . xs)
+  (if (null? xs) (box x) (apply (box x) xs)))
+
+(define-case-class rich-integer ((data integer?))
+
+(define (%get) data)
+
+(define (%to n) 
+  (unless (integer? n) 
+    (type-error 
+      (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+              %to '(n) 'n "integer" (object->string n))))
+  (if (< n data) 
+    (rich-list (list)) 
+    (rich-list (iota (+ (- n data) 1) data))))
+
+(define (%until n) 
+  (unless (integer? n) 
+    (type-error 
+      (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+              %until '(n) 'n "integer" (object->string n))))
+  (if (<= n data) 
+    (rich-list (list)) 
+    (rich-list (iota (+ (- n data)) data))))
+
+(define (%to-rich-char)
+  (rich-char data))
+
+(define (%to-string)
+  (number->string data))
+
+(define (@max-value) 9223372036854775807)
+
+(define (@min-value) -9223372036854775808)
+
+;;return exact integer
+(define (%sqrt)
+  (if (< data 0)
+      (value-error
+        (format #f "sqrt of negative integer is undefined!         ** Got ~a **" data))
+      (inexact->exact (floor (sqrt data)))))
+
+)
+
+(define-case-class rich-rational ((data rational?))
+
+(define (%get) data)
+
+(define (%abs) 
+  (if (< data 0)
+      (- 0 data)
+      data))
+  
+)
+
+(define-case-class rich-float ((data float?))
+                   
+(define (%get) data)
+
+(define (%abs) 
+  (if (< data 0)
+      (- 0 data)
+      data))
+  
+(define (%to-string)
+  (number->string data))
+
+(define (%sqrt)
+  (if (< data 0)
+      (value-error
+        (format #f "sqrt of negative float is undefined!         ** Got ~a **" data))
+      (sqrt data)))
+
+)
+
+
+(define array rich-vector)
+
+
+
+) ; end of begin
+) ; end of library
+
diff --git a/tests/resources/r7rs/liii/list.scm.txt b/tests/resources/r7rs/liii/list.scm.txt
new file mode 100644
index 00000000..c64f8d69
--- /dev/null
+++ b/tests/resources/r7rs/liii/list.scm.txt
@@ -0,0 +1,151 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii list)
+(export
+  ; S7 built-in
+  cons car cdr map for-each
+  ; SRFI 1: Constructors
+  circular-list iota list-copy xcons cons*
+  ; SRFI 1: Predicates
+  null-list? circular-list? proper-list? dotted-list?
+  ; SRFI 1: Selectors
+  first second third fourth fifth sixth seventh eighth ninth tenth
+  take drop take-right drop-right split-at
+  last-pair last
+  ; SRFI 1: Miscellaneous: length, append, concatenate, reverse, zip & count
+  zip count
+  ; SRFI 1: fold, unfold & map
+  fold fold-right reduce reduce-right
+  filter partition remove append-map
+  ; SRFI 1: Searching
+  find any every list-index
+  take-while drop-while
+  ; SRFI 1: Deleting
+  delete
+  ; SRFI 1: Association List
+  assoc assq assv alist-cons
+  ; Liii List extensions
+  flat-map
+  list-null? list-not-null? not-null-list?
+  length=? length>? length>=? flatten
+)
+(import (srfi srfi-1)
+        (srfi srfi-13)
+        (liii error)
+        (liii case)
+        (only (liii oop) define-case-class chain-apply))
+(begin
+
+(define (length=? x scheme-list)
+  (when (not (integer? x))
+    (type-error "length=?: first parameter x must be an integer"))
+  (when (< x 0)
+    (value-error "length=?: expected non-negative integer x but received ~d" x))
+  (cond ((and (= x 0) (null? scheme-list)) #t)
+        ((or (= x 0) (null? scheme-list)) #f)
+        (else (length=? (- x 1) (cdr scheme-list)))))
+
+(define (length>? lst len)
+  (let loop ((lst lst)
+             (cnt 0))
+    (cond ((null? lst) (< len cnt))
+          ((pair? lst) (loop (cdr lst) (+ cnt 1)))
+          (else (< len cnt)))))
+
+(define (length>=? lst len)
+  (let loop ((lst lst)
+             (cnt 0))
+    (cond ((null? lst) (<= len cnt))
+          ((pair? lst) (loop (cdr lst) (+ cnt 1)))
+          (else (<= len cnt)))))
+
+(define flat-map append-map)
+
+(define (not-null-list? l)
+  (cond ((pair? l)
+         (or (null? (cdr l)) (pair? (cdr l))))
+        ((null? l) #f)
+        (else
+         (error 'type-error "type mismatch"))))
+
+(define (list-null? l)
+  (and (not (pair? l)) (null? l)))
+
+(define (list-not-null? l)
+  (and (pair? l)
+       (or (null? (cdr l)) (pair? (cdr l)))))
+
+(define* (flatten lst (depth 1))
+  (define (flatten-depth-iter rest depth res-node)
+    (if (null? rest)
+        res-node
+        (let ((first (car rest))
+              (tail  (cdr rest)))
+          (cond ((and (null? first) (not (= 0 depth)))
+                 (flatten-depth-iter tail depth res-node))
+                ((or (= depth 0) (not (pair? first)))
+                 (set-cdr! res-node (cons first '()))
+                 (flatten-depth-iter tail depth (cdr res-node)))
+                (else
+                 (flatten-depth-iter
+                  tail
+                  depth
+                  (flatten-depth-iter
+                   first
+                   (- depth 1)
+                   res-node)))))))
+  (define (flatten-depth lst depth)
+    (let ((res (cons #f '())))
+      (flatten-depth-iter lst depth res)
+      (cdr res)))
+
+  (define (flatten-deepest-iter rest res-node)
+    (if (null? rest)
+      res-node
+      (let ((first (car rest))
+            (tail  (cdr rest)))
+        (cond ((pair? first)
+               (flatten-deepest-iter
+                tail
+                (flatten-deepest-iter
+                 first
+                 res-node)))
+              ((null? first)
+               (flatten-deepest-iter tail res-node))
+              (else
+               (set-cdr! res-node (cons first '()))
+               (flatten-deepest-iter tail (cdr res-node)))))))
+  (define (flatten-deepest lst)
+    (let ((res (cons #f '())))
+      (flatten-deepest-iter lst res)
+      (cdr res)))
+
+  (cond ((eq? depth 'deepest)
+         (flatten-deepest lst))
+        ((integer? depth)
+         (flatten-depth lst depth))
+        (else
+         (type-error
+          (string-append
+            "flatten: the second argument depth should be symbol "
+            "`deepest' or a integer, which will be uesd as depth,"
+            " but got a ~A") depth)))
+  ) ; end of (define* (flatten))
+
+) ; end of begin
+) ; end of library
+
diff --git a/tests/resources/r7rs/liii/logging.scm.txt b/tests/resources/r7rs/liii/logging.scm.txt
new file mode 100644
index 00000000..67fe04ae
--- /dev/null
+++ b/tests/resources/r7rs/liii/logging.scm.txt
@@ -0,0 +1,144 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii logging)
+(import (liii lang)
+        (liii path)
+        (liii datetime)
+        (liii error))
+(export logging)
+(begin
+
+(define-constant NOTSET 0)
+(define-constant DEBUG 10)
+(define-constant INFO 20)
+(define-constant WARNING 30)
+(define-constant ERROR 40)
+(define-constant CRITICAL 50)
+
+(define loggers-registry (make-hash-table))
+(define-class logging
+  ((name string? "default")
+   (log-path string? "")
+   (level integer? WARNING))
+  
+
+(define (%set-path! p)
+  (cond ((string? p)
+         (set! log-path p))
+        
+        ((path :is-type-of p)
+         (set! log-path (p :to-string)))
+        
+        (else
+         (type-error "path should be a string or path object"))))
+
+(define (%set-level! l)
+  (define (check-valid-level val)
+    (member val '(0 10 20 30 40 50)))
+  
+  (cond ((integer? l) 
+         (if (check-valid-level l)
+             (set! level l)
+             (value-error "invalid level number" l)))
+
+        ((rich-integer :is-type-of l) 
+         (if (check-valid-level (l :get))
+             (set! level (l :get))
+             (value-error "invalid level number" (l :get))))
+
+        (else 
+         (type-error "level should be an integer"))))
+
+(define (@apply p-name)
+  ;; Check if logger with this name already exists in registry
+  (let ((existing-logger (hash-table-ref loggers-registry p-name)))
+    (if (eq? existing-logger #f)
+        ;; If not, create a new logger and store in registry
+        (let ((new-logger (logging)))
+          (new-logger :set-name! p-name)
+          (hash-table-set! loggers-registry p-name new-logger)
+          new-logger)
+        ;; If exists, return existing logger
+        existing-logger)))
+
+(define (format-timestamp)
+  (let ((now (datetime :now)))
+    (now :to-string)))
+
+(define (print-log level-name . args)
+  (let* ((timestamp (format-timestamp))
+         (prefix (string-append timestamp " [" level-name "] " name ": "))
+         (message (apply string-append 
+                         (map (lambda (arg) 
+                                (if (string? arg) 
+                                    arg 
+                                    (arg :get)))
+                              args))))
+    (let ((line (string-append prefix message "\n")))
+      (if (string=? log-path "")
+          (display line)
+          (path-append-text log-path line)))))
+
+(define (%get-level)
+  (cond
+    ((= level 0) "NOTSET")
+    ((= level 10) "DEBUG")
+    ((= level 20) "INFO")
+    ((= level 30) "WARNING")
+    ((= level 40) "ERROR")
+    ((= level 50) "CRITICAL")))
+
+(define (%debug?)
+  (<= level DEBUG))
+
+(define (%info?)
+  (<= level INFO))
+
+(define (%warning?)
+  (<= level WARNING))
+
+(define (%error?)
+  (<= level ERROR))
+
+(define (%critical?)
+  (<= level CRITICAL))
+
+(define (%debug . args)
+  (when (%debug?)
+    (apply print-log "DEBUG" args)))
+
+(define (%info . args)
+  (when (%info?)
+    (apply print-log "INFO" args)))
+
+(define (%warning . args)
+  (when (%warning?)
+    (apply print-log "WARNING" args)))
+
+(define (%error . args)
+  (when (%error?)
+    (apply print-log "ERROR" args)))
+
+(define (%critical . args)
+  (when (%critical?)
+    (apply print-log "CRITICAL" args)))
+
+)
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/oop.scm.txt b/tests/resources/r7rs/liii/oop.scm.txt
new file mode 100644
index 00000000..254c16cc
--- /dev/null
+++ b/tests/resources/r7rs/liii/oop.scm.txt
@@ -0,0 +1,440 @@
+;
+; Copyright (C) 2025 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii oop)
+(import (srfi srfi-2) (srfi srfi-1) (liii string))
+(export
+  @ typed-define define-case-class define-object define-class
+  case-class? chained-define display* object->string
+  chain-apply
+)
+(begin
+
+(define-macro (@ . paras)
+  (letrec*
+    (
+      (slot? (lambda (x) (equal? '_ x)))
+      (exprs (filter (lambda (x) (not (slot? x))) paras))
+      (slots (filter slot? paras))
+
+      (exprs-sym-list (map (lambda (x) (gensym)) exprs))  
+      (slots-sym-list (map (lambda (x) (gensym)) slots))
+
+      (lets (map list exprs-sym-list exprs))
+
+      (parse
+        (lambda (exprs-sym-list slots-sym-list paras)
+          (cond
+            ((null? paras) paras)
+            ((not (list? paras)) paras)
+            ((slot? (car paras)) 
+              `(,(car slots-sym-list) 
+                ,@(parse exprs-sym-list (cdr slots-sym-list) (cdr paras))))
+            (else 
+              `(,(car exprs-sym-list) 
+                ,@(parse (cdr exprs-sym-list) slots-sym-list (cdr paras))))))))
+                
+  `(let ,lets 
+        (lambda ,slots-sym-list 
+                ,(parse exprs-sym-list slots-sym-list paras)))))
+
+(define-macro (typed-define name-and-params body . rest)
+  (let* ((name (car name-and-params))
+          (params (cdr name-and-params))
+          (param-names (map car params)))
+
+        `(define* 
+            (,name 
+            ,@(map  
+              (lambda (param)
+                (let  ((param-name (car param))
+                      (type-pred (cadr param))
+                      (default-value (cddr param)))
+                      (if (null? default-value)
+                          param-name
+                          `(,param-name ,(car default-value)))))
+              params))
+
+        ;; Runtime type check                    
+        ,@(map (lambda (param)
+                (let* ((param-name (car param))
+                      (type-pred (cadr param))
+                      ;;remove the '?' in 'type?'
+                      (type-name-str 
+                         (let ((s (symbol->string type-pred)))
+                           (if (and (positive? (string-length s))
+                                    (char=? (string-ref s (- (string-length s) 1)) #\?))
+                               (substring s 0 (- (string-length s) 1))
+                               s))))
+
+                  `(unless 
+                      (,type-pred ,param-name)
+                      (type-error 
+                          (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**"
+                                ,name
+                                ',param-names
+                                ',param-name
+                                ,type-name-str
+                                (object->string ,param-name))))))
+              params)
+       ,body
+       ,@rest)))
+
+(define-macro (define-case-class class-name fields . private-fields-and-methods)
+  (let* ((key-fields
+         (map (lambda (field) (string->symbol (string-append ":" (symbol->string (car field)))))
+              fields))
+        
+         (field-names (map car fields))
+         (field-count (length field-names))
+
+         (private-fields (filter (lambda (x)
+                                   (and (list? x)
+                                        (>= (length x) 2)
+                                        (symbol? (x 1))))
+                                 private-fields-and-methods))
+
+         (methods (filter (lambda (x)
+                            (and (list? x)
+                                 (>= (length x) 2)
+                                 (pair? (x 1))))
+                          private-fields-and-methods))
+         
+         (method-names
+           (map (lambda (method)
+                  (let* ((method-sym (caadr method))
+                         (method-name (symbol->string method-sym)))
+                    (cond
+                      ((string-starts? method-name "@")
+                       (string-remove-prefix method-name "@"))
+                      ((string-starts? method-name "%")
+                       (string-remove-prefix method-name "%"))
+                      (else method-name))))
+                methods))
+         
+         (conflicts-names
+          (filter (lambda (method-name)
+                    (let ((name (string->symbol method-name)))
+                      (member name field-names)))
+                  method-names))
+         
+         (check-conflicts-names (unless (null? conflicts-names)
+              (let ((conflict-str (apply string-append 
+                                        (map (lambda (c) (string-append " <" c ">"))
+                                             conflicts-names))))
+                (error 'syntax-error (string-append "In class ["
+                                          (symbol->string class-name)
+                                          "]: Method name" 
+                                          (if (= (length conflicts-names) 1) "" "s")
+                                          conflict-str
+                                          " conflicts with field name"
+                                          (if (= (length conflicts-names) 1) "" "s"))))))
+         
+         (instance-methods
+          (filter (lambda (method) (string-starts? (symbol->string (caadr method)) "%"))
+                  methods))
+         (instance-method-symbols (map caadr instance-methods))
+         (instance-messages
+          (map (lambda (method)
+                 (let ((name (string-remove-prefix (symbol->string method) "%")))
+                   (string->symbol (string-append ":" name))))
+               instance-method-symbols))
+         (static-methods
+          (filter (lambda (method) (string-starts? (symbol->string (caadr method)) "@"))
+                  methods))
+         (static-method-symbols (map caadr static-methods))
+         (static-messages
+          (map (lambda (method)
+                 (let ((name (string-remove-prefix (symbol->string method) "@")))
+                   (string->symbol (string-append ":" name))))
+               static-method-symbols))
+         ;(default-static-messages '(:is-type-of))
+         (internal-methods
+           (filter (lambda (method) (not (or (string-starts? (symbol->string (caadr method)) "%")
+                                             (string-starts? (symbol->string (caadr method)) "@"))))
+                   methods))
+         (this-symbol (gensym))
+         (f-make-case-class (string->symbol (string-append "make-case-class-" (symbol->string class-name)))))
+
+`(define (,class-name . args)
+
+(define (@is-type-of obj)
+  (and (case-class? obj)
+       (obj :is-instance-of ',class-name)))
+   
+,@static-methods
+
+(define (is-normal-function? msg)
+  (and  (symbol? msg) 
+        (char=? (string-ref (symbol->string msg) 0) #\:)))
+
+(define (static-dispatcher msg . args)
+    (cond
+     ((eq? msg :is-type-of) (apply @is-type-of args))
+     ,@(map (lambda (method expected) `((eq? msg ,expected) (apply ,method args)))
+            static-method-symbols static-messages)
+     (else (value-error "No such static method " msg))))
+
+(define* (,f-make-case-class 
+  ,@(map  
+    (lambda (param)
+      (let  ((param-name (car param))
+            (type-pred (cadr param))
+            (default-value (cddr param)))
+            (if (null? default-value)
+                param-name
+                `(,param-name ,(car default-value)))))
+    fields))
+  ,@(map (lambda (param)
+        (let* ((param-name (car param))
+              (type-pred (cadr param))
+              ;;remove the '?' in 'type?'
+              (type-name-str 
+                  (let ((s (symbol->string type-pred)))
+                    (if (and (positive? (string-length s))
+                            (char=? (string-ref s (- (string-length s) 1)) #\?))
+                        (substring s 0 (- (string-length s) 1))
+                        s))))
+
+          `(unless 
+              (,type-pred ,param-name)
+              (type-error 
+                  (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**"
+                        ,f-make-case-class
+                        ',field-names
+                        ',param-name
+                        ,type-name-str
+                        (object->string ,param-name))))))
+      fields)
+
+  (define ,this-symbol #f)
+  (define (%this . xs)
+    (if (null? xs)
+      ,this-symbol
+      (apply ,this-symbol xs)))
+
+  (define (%is-instance-of x)
+    (eq? x ',class-name))
+         
+  (define (%equals that)
+    (unless (case-class? that) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %equals '(that) 'that "case-class" (object->string that))))
+    (and (that :is-instance-of ',class-name)
+         ,@(map (lambda (field) `(equal? ,(car field) (that ',(car field))))
+                fields)))
+         
+  (define (%apply . args)
+    (cond ((null? args)
+           (value-error ,class-name "Apply on zero args is not implemented"))
+          ((equal? ((symbol->string (car args)) 0) #\:)
+           (value-error ,class-name "No such method: " (car args)))
+          (else (value-error ,class-name "No such field: " (car args)))))
+         
+  (define (%to-string)
+    (let ((field-strings
+           (list ,@(map (lambda (field key-field)
+                          `(string-append
+                            ,(symbol->string key-field) " "
+                            (object->string ,(car field))))
+                        fields key-fields))))
+      (let loop ((strings field-strings)
+                 (acc ""))
+        (if (null? strings)
+            (string-append "(" ,(symbol->string class-name) " " acc ")")
+            (loop (cdr strings)
+                  (if (zero? (string-length acc))
+                      (car strings)
+                      (string-append acc " " (car strings))))))))
+
+  ,@private-fields
+  ,@internal-methods
+  ,@instance-methods
+ 
+  (define (instance-dispatcher)
+    (lambda (msg . args)
+      (cond
+        ((eq? msg :is-instance-of) (apply %is-instance-of args))
+        ((eq? msg :equals) (apply %equals args))
+        ((eq? msg :to-string) (%to-string))
+        ((eq? msg :this) (apply %this args))
+        ,@(map (lambda (field key-field)
+            `((eq? msg ,key-field)
+              (,class-name
+              ,@(map (lambda (f) (if (eq? (car f) (car field)) '(car args) (car f)))
+                      fields))))
+          fields key-fields)
+        ((is-normal-function? msg)
+         (case msg
+           ,@(map (lambda (method expected)
+                    `((,expected) (apply ,method args)))
+                  instance-method-symbols instance-messages)
+           (else (value-error ,class-name "No such method: " msg))))
+        ,@(map (lambda (field) `((eq? msg ',(car field)) ,(car field))) fields)
+        (else (apply %apply (cons msg args))))))
+
+  (set! ,this-symbol (instance-dispatcher))
+  ,this-symbol
+) ; end of the internal typed define
+
+(if (null? args)
+    (,f-make-case-class)
+    (let ((msg (car args)))
+      (cond ((member msg (list ,@static-messages :is-type-of))
+             (apply static-dispatcher args))
+            ((and (zero? ,field-count) (member :apply (list ,@static-messages)))
+             (apply static-dispatcher (cons :apply args)))
+            (else
+             (apply ,f-make-case-class args)))))
+
+) ; end of define
+) ; end of let
+) ; end of define-macro
+
+(define-macro (define-object object-name . definitions)
+  (let* ((static-methods (filter (lambda (def)
+                               (and (list? def) (>= (length def) 3)
+                                    (eq? (car def) 'define)
+                                    (list? (cadr def))
+                                    (caadr def)
+                                    (symbol? (caadr def))
+                                    (let ((name-str (symbol->string (caadr def))))
+                                      (and (> (string-length name-str) 0)
+                                           (char=? (string-ref name-str 0) #\@)))))
+                              definitions))
+         (method-infos (map (lambda (def-form)
+                              (let* ((static-name-sym (caadr def-form))
+                                     (static-name-str (symbol->string static-name-sym))
+                                     (method-name-str (substring static-name-str 1 (string-length static-name-str)))
+                                     (dispatch-keyword (string->symbol (string-append ":" method-name-str))))
+                                (list dispatch-keyword static-name-sym)))
+                            static-methods))
+         (varlet-bindings (map (lambda (def-form)
+                                 (let ((defined-sym
+                                         (if (list? (cadr def-form))
+                                             (caadr def-form)
+                                             (cadr def-form))))
+                                   `(varlet (curlet) ',defined-sym ,defined-sym)))
+                               definitions)))
+
+    `(begin
+       (define (,object-name . msgs-and-args)
+         (let ((env (funclet ,object-name)))
+           (if (null? msgs-and-args)
+               (value-error (string-append "Object '" (symbol->string ',object-name) "' called with no arguments"))
+               (let ((msg (car msgs-and-args))
+                     (args (cdr msgs-and-args)))
+                 (cond
+                   ,@(map (lambda (info)
+                            (let ((dispatch-key (car info))
+                                  (static-method-sym (cadr info)))
+                              `((eq? msg ',dispatch-key) (apply (env ',static-method-sym) args))))
+                          method-infos)
+                   (else (value-error (string-append "No such static method '"
+                                                     (if (symbol? msg) (symbol->string msg) (object->string msg))
+                                                     "' in object '" (symbol->string ',object-name) "'"))))))))
+       (with-let (funclet ,object-name)
+         ,@definitions
+         ,@varlet-bindings
+         #t 
+         ))))
+
+(define-macro (define-class class-name private-fields . private-fields-and-methods)
+  (let* ((field-defs '())
+         (getter-defs '())
+         (setter-defs '())
+         
+         ;; generate define, getter, setter
+         (process-fields
+          (map (lambda (field-spec)
+                 (let* ((field-name (car field-spec))
+                        (type-pred (cadr field-spec))
+                        (default-value (if (>= (length field-spec) 3)
+                                          (caddr field-spec)
+                                          ''()))
+                        (getter-name (string->symbol 
+                                      (string-append "%get-" (symbol->string field-name))))
+                        (setter-name (string->symbol 
+                                      (string-append "%set-" (symbol->string field-name) "!"))))
+                   
+                   (set! field-defs 
+                         (cons `(define ,field-name ,default-value) field-defs))
+                   
+                   (set! getter-defs 
+                         (cons `(define (,getter-name) ,field-name) getter-defs))
+                   
+                   (set! setter-defs 
+                         (cons `(typed-define (,setter-name (x ,type-pred))
+                                  (set! ,field-name x))
+                               setter-defs))))
+               private-fields)))
+    
+    `(define-case-class ,class-name ()
+       ;; define
+       ,@(reverse field-defs)
+       
+       ;; Getter
+       ,@(reverse getter-defs)
+       
+       ;; Setter
+       ,@(reverse setter-defs)
+       
+       ;; else
+       ,@private-fields-and-methods)))
+
+(define (case-class? x)
+  (and-let* ((is-proc? (procedure? x))
+             (source (procedure-source x))
+             (source-at-least-3? (and (list? source) (>= (length source) 3)))
+             (body (source 2))
+             (body-at-least-3? (and (list? body) (>= (length body) 3)))
+             (is-cond? (eq? (car body) 'cond))
+             (pred1 ((body 1) 0))
+             (pred2 ((body 2) 0)))
+    (and (equal? pred1 '(eq? msg :is-instance-of))
+         (equal? pred2 '(eq? msg :equals)))))
+
+(define-macro (chained-define head . body)
+  (let ((xs (gensym))
+        (result (gensym)))
+    `(define ,(append head xs)
+       (let ((,result (begin ,@body)))
+         (if (null? ,xs)
+           ,result
+           (apply ,result ,xs))))))
+
+(define (chain-apply args r)
+  (if (null? args)
+      r
+      (apply r args)))
+
+(define (display* . params)
+  (define (%display x)
+    (if (case-class? x)
+        (display (x :to-string))
+        (display x)))
+  (for-each %display params))
+
+(define s7-object->string object->string)
+
+(define (object->string x)
+  (if (case-class? x)
+      (x :to-string)
+      (s7-object->string x)))
+
+) ; end of begin
+) ; end of define-library
diff --git a/tests/resources/r7rs/liii/option.scm.txt b/tests/resources/r7rs/liii/option.scm.txt
new file mode 100644
index 00000000..3b385298
--- /dev/null
+++ b/tests/resources/r7rs/liii/option.scm.txt
@@ -0,0 +1,94 @@
+;
+; Copyright (C) 2025 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii option)
+(import (liii oop) (liii base))
+(export option none)
+(begin
+
+(define-case-class option ((value any?))
+
+(define (%get)
+  (if (null? value)
+      (value-error "option is empty, cannot get value")
+      value))
+
+(define (%get-or-else default)
+  (cond ((not (null? value)) value)
+        ((and (procedure? default) (not (case-class? default)))
+         (default))
+        (else default)))
+
+(define (%or-else default . args)
+  (when (not (option :is-type-of default))
+    (type-error "The first parameter of option%or-else must be a option case class"))
+  
+  (chain-apply args
+    (if (null? value)
+        default
+        (option value))))
+
+(define (%equals that)
+  (class=? value (that 'value)))
+
+(define (%defined?) (not (null? value)))
+  
+(define (%empty?)
+  (null? value))
+
+(define (%forall f)
+  (if (null? value)
+      #f
+      (f value)))
+
+(define (%exists f)
+  (if (null? value)
+      #f
+      (f value)))
+
+(define (%contains elem)
+  (if (null? value)
+      #f
+      (equal? value elem)))
+
+(define (%for-each f)
+  (when (not (null? value))
+        (f value)))
+
+(define (%map f . args)
+  (chain-apply args
+    (if (null? value)
+        (option '())
+        (option (f value)))))
+
+(define (%flat-map f . args)
+  (chain-apply args
+    (if (null? value)
+        (option '())
+        (f value))))
+
+(define (%filter pred . args)
+  (chain-apply args
+    (if (or (null? value) (not (pred value)))
+        (option '())
+        (option value))))
+
+)
+
+(define (none) (option '()))
+
+) ; end of begin
+) ; end of define-library
diff --git a/tests/resources/r7rs/liii/os.scm.txt b/tests/resources/r7rs/liii/os.scm.txt
new file mode 100644
index 00000000..cc87f4f9
--- /dev/null
+++ b/tests/resources/r7rs/liii/os.scm.txt
@@ -0,0 +1,137 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii os)
+(export
+  os-arch os-type os-windows? os-linux? os-macos? os-temp-dir
+  os-sep pathsep
+  os-call ; system
+  mkdir chdir rmdir remove getenv putenv unsetenv getcwd listdir access getlogin getpid)
+(import (scheme process-context)
+        (liii base)
+        (liii error)
+        (liii string))
+(begin
+
+(define (os-arch)
+  (g_os-arch))
+
+(define (os-type)
+  (g_os-type))
+
+(define (os-linux?)
+  (let ((name (os-type)))
+    (and name (string=? name "Linux"))))
+
+(define (os-macos?)
+  (let ((name (os-type)))
+    (and name (string=? name "Darwin"))))
+
+(define (os-windows?)
+  (let ((name (os-type)))
+    (and name (string=? name "Windows"))))
+
+(define (os-sep)
+  (if (os-windows?)
+    #\\
+    #\/))
+
+(define (pathsep)
+  (if (os-windows?)
+    #\;
+    #\:))
+
+(define (%check-dir-andthen path f)
+  (cond ((not (file-exists? path))
+         (file-not-found-error
+           (string-append "No such file or directory: '" path "'")))
+        ((not (g_isdir path))
+         (not-a-directory-error
+           (string-append "Not a directory: '" path "'")))
+        (else (f path))))
+
+(define (os-call command)
+  (g_os-call command))
+
+(define (system command)
+  (g_system command))
+
+(define (access path mode)
+  (cond ((eq? mode 'F_OK) (g_access path 0))
+        ((eq? mode 'X_OK) (g_access path 128))
+        ((eq? mode 'W_OK) (g_access path 2))
+        ((eq? mode 'R_OK) (g_access path 1))
+        (else (error 'value-error "Allowed mode 'F_OK, 'X_OK,'W_OK, 'R_OK"))))
+
+(define* (getenv key (default #f))
+  (let ((val (get-environment-variable key)))
+    (if val
+        val
+        default)))
+
+(define (putenv key value)
+  (if (and (string? key) (string? value))
+      (g_setenv key value)
+      (error 'type-error "(putenv key value): key and value must be strings")))
+
+(define (unsetenv key)
+  (g_unsetenv key))
+
+(define (os-temp-dir)
+  (let1 temp-dir (g_os-temp-dir)
+    (string-remove-suffix temp-dir (string (os-sep)))))
+
+(define (mkdir path)
+  (if (file-exists? path)
+    (file-exists-error (string-append "File exists: '" path "'"))
+    (g_mkdir path)))
+
+(define (rmdir path)
+  (%check-dir-andthen path g_rmdir))
+
+(define (remove path)
+  (cond
+    ((not (string? path))
+     (error 'type-error "(remove path): path must be string"))
+    ((not (file-exists? path))
+     (error 'file-not-found-error (string-append "File not found: " path)))
+    ((g_isdir path)  ; 检查是否为目录
+     (error 'value-error "Cannot remove a directory (use 'rmdir' instead)"))
+    (else
+     (g_remove-file path))))
+
+(define (chdir path)
+  (if (file-exists? path)
+    (g_chdir path)
+    (file-not-found-error (string-append "No such file or directory: '" path "'"))))
+
+(define (listdir path)
+  (%check-dir-andthen path g_listdir))
+
+(define (getcwd)
+  (g_getcwd))
+
+(define (getlogin)
+  (if (os-windows?)
+      (getenv "USERNAME")
+      (g_getlogin)))
+
+(define (getpid)
+  (g_getpid))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/path.scm.txt b/tests/resources/r7rs/liii/path.scm.txt
new file mode 100644
index 00000000..8c20ceb6
--- /dev/null
+++ b/tests/resources/r7rs/liii/path.scm.txt
@@ -0,0 +1,341 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii path)
+(export
+  path-dir? path-file? path-exists?
+  path-getsize path-read-text path-read-bytes path-write-text path-append-text path-touch
+  path
+)
+(import (liii base) (liii lang) (liii error) (liii vector) (liii string) (liii list)
+        (liii os))
+(begin
+
+(define (path-dir? path)
+  (g_isdir path))
+
+(define (path-file? path)
+  (g_isfile path))
+
+(define (path-exists? path)
+  (file-exists? path))
+
+(define path-getsize
+  (typed-lambda ((path string?))
+    (if (not (file-exists? path))
+      (file-not-found-error
+        (string-append "No such file or directory: '" path "'"))
+      (g_path-getsize path))))
+
+(define path-read-text
+  (typed-lambda ((path string?))
+    (if (not (file-exists? path))
+      (file-not-found-error
+        (string-append "No such file or directory: '" path "'"))
+      (g_path-read-text path))))
+
+(define path-read-bytes
+  (typed-lambda ((path string?))
+    (if (not (file-exists? path))
+      (file-not-found-error
+        (string-append "No such file or directory: '" path "'"))
+      (g_path-read-bytes path))))
+
+(define path-write-text
+  (typed-lambda ((path string?) (content string?))
+    (g_path-write-text path content)))
+
+(define path-append-text
+  (typed-lambda ((path string?) (content string?))
+    (g_path-append-text path content)))
+
+(define (path-touch path)
+  (g_path-touch path))
+
+(define-case-class path ()
+  (define parts #("."))
+  (define type 'posix)
+  (define drive "")
+  
+  (define (%set-parts! v)
+    (if (rich-vector :is-type-of v)
+        (set! parts (v :collect))
+        (set! parts v)))
+  
+  (define (%set-type! s)
+    (set! type s))
+  
+  (define (%set-drive! s)
+    (set! drive s))
+  
+  (define (%get-parts) parts)
+  (define (%get-type) type)
+  (define (%get-drive) drive)
+  
+  (define (%copy)
+    (let1 p (path)
+      (p :set-parts! parts)
+      (p :set-type! type)
+      (p :set-drive! drive)
+      p))
+
+
+(chained-define (@of-drive ch)
+  (when (not (char? ch))
+    (type-error "path@of-drive must take char? as input"))
+    (let1 r (path)
+        (r :set-type! 'windows)
+        (r :set-drive! ($ ch :to-upper :make-string))
+        (r :set-parts! #())
+        r))
+
+(chained-define (@root)
+  (let1 r (path)
+        (r :set-parts! #("/"))
+        r))
+
+(chained-define (@from-parts x) 
+   (let1 r (path)
+     (r :set-parts! x)
+     r))
+
+(chained-define (@/ x) 
+   (if (path :is-type-of x)
+       (path :root :/ x)
+       (cond ((and (string-ends? x ":") (= (string-length x) 2))
+               (path :of-drive (x 0)))
+            
+             ((string=? x "/") (path :root))
+            
+             (else
+               (path :from-parts (vector-append (vector (string (os-sep))) (vector x)))))))
+
+(chained-define (@apply s)
+  (cond ((and (or (os-linux?) (os-macos?))
+              (string-starts? s "/"))
+         (path :/ (@apply ($ s :drop 1 :get))))
+        ((and (os-windows?)
+              (= (string-length s) 2)
+              (char=? (s 1) #\:))
+         (path :of-drive (s 0)))
+        ((and (os-windows?) (>= (string-length s) 3)
+              (char=? (s 1) #\:)
+              (char=? (s 2) #\\))
+         (path :of-drive (s 0)
+               :/ (@apply ($ s :drop 3 :get))))
+        (else
+         (let loop ((iter s))
+           (cond ((or (string-null? iter) (string=? iter "."))
+                  (path))
+                 
+                 ((not (char=? (iter 0) (os-sep)))
+                  (path :from-parts ($ iter :split (string (os-sep)))))
+                 
+                 (else
+                  (loop ($ iter :drop 1 :get))))))))
+
+(chained-define (@from-env name)
+  (path (getenv name)))
+
+(define (%name)
+  (if (string=? "." ($ parts :last))
+      ""
+      ($ parts :last)))
+
+(define (%stem)
+  (define last-part-str 
+    (if (> (vector-length parts) 0)
+        (vector-ref parts (- (vector-length parts) 1))
+        ""))
+  
+  (define (drop-suffix str)
+    (let* ((rich-str ($ str))
+           (rich-splits (rich-str :split "."))  ; 按点分割
+           (count (rich-splits :count)))  ; 获取分割数量
+      (cond ((<= count 1) str)  ; 无后缀或单一部分
+            ((string=? str ".") "")  ; 当前目录特殊处理
+            ((string=? str "..") "..") ; 上级目录特殊处理
+            ((and (string=? (rich-splits 0) "")  ; 以点开头
+                  (= count 2))  ; 且只有一个点（纯隐藏文件）
+             str)  ; 保留完整文件名
+            (else  ; 正常多后缀情况
+             (rich-splits :take (- count 1) :make-string ".")))))
+  
+  (drop-suffix (%name)))
+
+(define (%suffix)
+  (let* ((name (%name))
+         (rich-str ($ name))
+         (rich-splits (rich-str :split "."))
+         (count (rich-splits :count)))
+    (cond ((<= count 1) "")  ; 无后缀
+          ((string=? name ".") "")  ; 当前目录
+          ((string=? name "..") "") ; 上级目录
+          ((and (string=? (rich-splits 0) "")  ; 以点开头
+                (= count 2))  ; 且只有一个点（纯隐藏文件）
+           "")
+          (else 
+           (string-append "." (rich-splits :last))))))  ; 返回最后一部分
+
+(define (%equals that)
+  (if (path :is-type-of that)
+      (string=? (%to-string) (that :to-string))
+      #f))
+
+(define (%file?)
+  (path-file? (%to-string)))
+
+(define (%dir?)
+  (path-dir? (%to-string))) 
+
+(define (%absolute?)
+   (case type
+     ((posix) (string-starts? (parts 0) "/"))
+    
+     ((windows) (not ($ drive :empty?)))
+    
+     (else
+       (value-error
+         (string-append "path%absolute?: unknown type" (symbol->string type))))))
+
+(define (%relative)
+  (not (%absolute?)))
+
+(define (%exists?)
+  (path-exists? (%to-string)))
+
+(define (%to-string)
+  (case type
+    ((posix)
+     (let1 s ($ parts :make-string (string (os-sep)))
+        (if (and (> ($ s :length) 1) (string-starts? s (string (os-sep))))
+            (string-drop s 1)
+            s)))
+    ((windows)
+     (let1 s ($ parts :make-string "\\")
+       (if (string-null? drive)
+           s
+           (string-append drive ":\\" s))))
+    (else (value-error "path%to-string: unknown type" type))))
+
+(define (%read-text)
+  (path-read-text (%to-string)))
+
+(typed-define (%write-text (content string?))
+  (path-write-text (%to-string) content))
+
+(typed-define (%append-text (content string?))
+  (path-append-text (%to-string) content))
+
+(define (%list)
+  (box (listdir (%to-string))))
+
+(define (%list-path)
+  ((box (listdir (%to-string)))
+   :map (lambda (x) ((%this) :/ x))))
+
+(define (%touch)
+  (path-touch (%to-string)))
+
+(chained-define (%/ x)
+  (cond ((string? x)
+         (let1 new-path (%copy)
+            (new-path :set-parts! (vector-append parts (vector x)))
+            new-path))
+        
+        ((path :is-type-of x)
+         (cond ((x :absolute?)
+                (value-error "path to append must not be absolute path: " (x :to-string)))
+               ((string=? (x :to-string) ".")
+                (%this))
+               (else (let ((new-path (%copy))
+                           (x-parts (x :get-parts)))
+                       (if (os-windows?)
+                           (new-path :set-parts! x-parts)
+                           (new-path :set-parts! (vector-append (vector (string (os-sep))) x-parts)))
+                       new-path))))
+        
+        (else (type-error "only string?, path is allowed"))))
+
+(chained-define (%parent)   
+  (define (parts-drop-right parts x)
+     (let1 path-vec ($ parts :drop-right x)
+       (let1 new-path (%copy)
+         (if (path-vec :empty?)
+             (if (os-windows?)
+                 (new-path :set-parts! #(""))
+                 (new-path :set-parts! #(".")))
+             (new-path :set-parts! (path-vec :append #(""))))
+         new-path)))
+                
+  (cond
+    ((or (equal? #("/") parts) (equal? #(".") parts))
+     (%this))
+    ((or (os-macos?) (os-linux?))
+     (let1 last-part (($ parts) :take-right 1 :collect)
+           (if (equal? last-part #(""))
+               (parts-drop-right parts 2)
+               (parts-drop-right parts 1))))
+    ((os-windows?)
+     (if ($ parts :empty?)
+         (%this)
+         (let1 last-part (($ parts) :take-right 1 :collect)
+           (if (equal? last-part #(""))
+               (parts-drop-right parts 2)
+               (parts-drop-right parts 1)))))
+    
+    (else (??? "Unsupported platform"))))
+
+(define (%rmdir)
+  (rmdir (%to-string)))
+
+(define* (%unlink (missing-ok #f))  ; 使用define*定义可选参数
+  (let ((path-str (%to-string)))
+    (cond
+      ((file-exists? path-str)  ; 文件存在时总是删除
+       (remove path-str))
+      (missing-ok  ; 文件不存在时根据missing-ok决定
+       #t)         ; missing-ok为#t时静默返回#t
+      (else        ; missing-ok为#f时抛出错误
+       (error 'file-not-found-error 
+              (string-append "File not found: " path-str))))))
+
+
+(chained-define (@./ x)
+  (let1 p (path x)
+        (if (p :absolute?)
+            (value-error "path@./: only accecpt relative path")
+            (path x))))
+
+(chained-define (@cwd)
+  (path (getcwd)))
+
+(chained-define (@home)
+  (cond ((or (os-linux?) (os-macos?))
+         (path (getenv "HOME")))
+        ((os-windows?)
+         (path :of-drive ((getenv "HOMEDRIVE") 0)
+               :/ (path (getenv "HOMEPATH"))))
+        (else (value-error "path@home: unknown type"))))
+
+(chained-define (@temp-dir)
+  (path (os-temp-dir)))
+
+)
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/range.scm.txt b/tests/resources/r7rs/liii/range.scm.txt
new file mode 100644
index 00000000..e8725f8f
--- /dev/null
+++ b/tests/resources/r7rs/liii/range.scm.txt
@@ -0,0 +1,90 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii range)
+(import (liii oop) 
+        (liii rich-list)
+        (liii error)) 
+(export range)
+(begin
+
+(define-case-class range
+  ((start integer?) (end integer?) (step integer? 1) (inclusive? boolean? #f))
+
+(define* (@inclusive start end (step 1))
+  (range start end step #t))
+
+(define (check-step)
+  (when (zero? step)
+      (value-error "step can't be zero")))
+
+(define (in-range? x)
+  (or (and (> step 0) (if inclusive? (and (<= x end) (>= x start)) (and (< x end) (>= x start))))
+      (and (< step 0) (if inclusive? (and (>= x end) (<= x start)) (and (> x end) (<= x start))))))
+
+(define (not-in-range? x)
+  (or (and (> step 0) (or (> x end) (< x start)))
+      (and (< step 0) (or (< x end) (> x start)))
+      (and (= x end) (not inclusive?))))
+
+(define (%empty?)
+  (check-step)
+  (or (and (> start end) (> step 0))
+      (and (< start end) (< step 0))
+      (and (= start end) (not inclusive?))))
+
+(define (%map map-func)
+  (if (%empty?)
+      (rich-list :empty)
+      (let loop ((current start) (result '()))
+        (if (not-in-range? current)
+            (rich-list (reverse result))
+            (loop (+ current step)
+                  (cons (map-func current) result))))))
+
+(define (%for-each proc)
+  (when (not (%empty?))
+    (let loop ((current start))
+         (when (in-range? current)
+               (proc current)
+               (loop (+ current step))))))
+
+(define (%filter f)
+  (if (%empty?)
+      (rich-list :empty)
+      (let loop ((i start) (return '()))
+        (if (not-in-range? i)
+            (rich-list (reverse return))
+            (loop (+ i step)
+                  (if (f i)
+                      (cons i return)
+                       return))))))
+
+(define (%contains elem)
+  (check-step)
+  (if (%empty?)
+      #f
+      (if (in-range? elem) ;判断是否在范围内
+          (zero? (modulo (- elem start) (abs step)))
+          #f)))
+
+           
+           
+
+) ; define-case-cass
+) ; begin
+) ; define-library
+
diff --git a/tests/resources/r7rs/liii/rich-char.scm.txt b/tests/resources/r7rs/liii/rich-char.scm.txt
new file mode 100644
index 00000000..6a895aaa
--- /dev/null
+++ b/tests/resources/r7rs/liii/rich-char.scm.txt
@@ -0,0 +1,179 @@
+;
+; Copyright (C) 2025 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii rich-char)
+(import (liii oop) (liii bitwise) (liii base) (liii string))
+(export rich-char)
+(begin
+
+(define-case-class rich-char ((data any?))
+  
+(define code-point
+  (cond ((char? data)
+         (char->integer data))
+        ((integer? data)
+         (if (and (>= data 0) (<= data #x10FFFF))
+             data
+             (value-error "rich-char: code point out of range" data)))
+        (else
+         (type-error "rich-char: only accept char and integer"))))
+
+(define (%equals that)
+  (cond ((char? that)
+         (= code-point (char->integer that)))
+        ((rich-char :is-type-of that)
+         (= code-point (that :to-integer)))
+        (else #f)))
+
+(define (%ascii?)
+  (and (>= code-point 0) (<= code-point 127)))
+
+
+(define (%numeric?)
+  (if (and (>= code-point 0) (<= code-point 255))
+      (let ((ch (integer->char code-point)))
+        (char-numeric? ch))
+      #f))
+
+(define (%upper?)
+  (and (>= code-point #x41) (<= code-point #x5A)))
+
+(define (%lower?)
+  (and (>= code-point #x61) (<= code-point #x7A)))
+
+(define (%digit?)
+  (or
+   (and (>= code-point 48) (<= code-point 57))
+   (and (>= code-point #xFF10) (<= code-point #xFF19))
+   (and (>= code-point #x0660) (<= code-point #x0669))
+   (and (>= code-point #x06F0) (<= code-point #x06F9))
+   (and (>= code-point #x0966) (<= code-point #x096F))
+   (and (>= code-point #x09E6) (<= code-point #x09EF))
+   (and (>= code-point #x0A66) (<= code-point #x0A6F))
+   (and (>= code-point #x0AE6) (<= code-point #x0AEF))
+   (and (>= code-point #x0B66) (<= code-point #x0B6F))
+   (and (>= code-point #x0BE6) (<= code-point #x0BEF))
+   (and (>= code-point #x0C66) (<= code-point #x0C6F))
+   (and (>= code-point #x0CE6) (<= code-point #x0CEF))
+   (and (>= code-point #x0D66) (<= code-point #x0D6F))
+   (and (>= code-point #x0E50) (<= code-point #x0E59))
+   (and (>= code-point #x0ED0) (<= code-point #x0ED9))
+   (and (>= code-point #x0F20) (<= code-point #x0F29))
+   (and (>= code-point #x1040) (<= code-point #x1049))
+   (and (>= code-point #x17E0) (<= code-point #x17E9))
+   (and (>= code-point #x1810) (<= code-point #x1819))))
+  
+(define (%to-upper . args)
+  (chain-apply args
+    (rich-char
+      (if (and (>= code-point #x61) (<= code-point #x7A))
+          (bitwise-and code-point #b11011111)
+          code-point))))
+
+(define (%to-lower . args)
+  (chain-apply args
+    (rich-char
+      (if (and (>= code-point #x41) (<= code-point #x5A))
+          (bitwise-ior code-point #b00100000)
+          code-point))))
+
+(define (%to-bytevector)
+  (cond
+    ((<= code-point #x7F)
+     (bytevector code-point))
+
+    ((<= code-point #x7FF)
+     (let ((byte1 (bitwise-ior #b11000000 (bitwise-and (arithmetic-shift code-point -6) #b00011111)))
+           (byte2 (bitwise-ior #b10000000 (bitwise-and code-point #b00111111))))
+       (bytevector byte1 byte2)))
+
+    ((<= code-point #xFFFF)
+     (let ((byte1 (bitwise-ior #b11100000 (bitwise-and (arithmetic-shift code-point -12) #b00001111)))
+           (byte2 (bitwise-ior #b10000000 (bitwise-and (arithmetic-shift code-point -6) #b00111111)))
+           (byte3 (bitwise-ior #b10000000 (bitwise-and code-point #b00111111))))
+       (bytevector byte1 byte2 byte3)))
+
+    ((<= code-point #x10FFFF)
+     (let ((byte1 (bitwise-ior #b11110000 (bitwise-and (arithmetic-shift code-point -18) #b00000111)))
+           (byte2 (bitwise-ior #b10000000 (bitwise-and (arithmetic-shift code-point -12) #b00111111)))
+           (byte3 (bitwise-ior #b10000000 (bitwise-and (arithmetic-shift code-point -6) #b00111111)))
+           (byte4 (bitwise-ior #b10000000 (bitwise-and code-point #b00111111))))
+       (bytevector byte1 byte2 byte3 byte4)))
+
+    (else
+     (value-error "Invalid code point"))))
+
+(define (@from-bytevector x)
+  (define (utf8-byte-sequence->code-point byte-seq)
+    (let ((len (bytevector-length byte-seq)))
+      (cond
+        ((= len 1)
+         (bytevector-u8-ref byte-seq 0))
+        ((= len 2)
+         (let ((b1 (bytevector-u8-ref byte-seq 0))
+               (b2 (bytevector-u8-ref byte-seq 1)))
+           (bitwise-ior
+            (arithmetic-shift (bitwise-and b1 #x1F) 6)
+            (bitwise-and b2 #x3F))))
+        ((= len 3)
+         (let ((b1 (bytevector-u8-ref byte-seq 0))
+               (b2 (bytevector-u8-ref byte-seq 1))
+               (b3 (bytevector-u8-ref byte-seq 2)))
+           (bitwise-ior
+            (arithmetic-shift (bitwise-and b1 #x0F) 12)
+            (arithmetic-shift (bitwise-and b2 #x3F) 6)
+            (bitwise-and b3 #x3F))))
+        ((= len 4)
+         (let ((b1 (bytevector-u8-ref byte-seq 0))
+               (b2 (bytevector-u8-ref byte-seq 1))
+               (b3 (bytevector-u8-ref byte-seq 2))
+               (b4 (bytevector-u8-ref byte-seq 3)))
+           (bitwise-ior
+           (arithmetic-shift (bitwise-and b1 #x07) 18)
+           (arithmetic-shift (bitwise-and b2 #x3F) 12)
+           (arithmetic-shift (bitwise-and b3 #x3F) 6)
+           (bitwise-and b4 #x3F))))
+        (else
+         (value-error "Invalid UTF-8 byte sequence length")))))
+
+  (rich-char (utf8-byte-sequence->code-point x)))
+
+(define (%to-string)
+  (if (%ascii?)
+      (object->string (integer->char code-point))
+      (string-append "#\\" (utf8->string (%to-bytevector)))))
+
+(define (@from-string x)
+  (when (not (string-starts? x "#\\"))
+    (value-error "char@from-string: the input must start with #\\"))
+  (if (= 1 ($ x :drop 2 :length))
+      (rich-char :from-bytevector (string->utf8 ($ x :drop 2 :get)))
+      (value-error "rich-char: must be u8 string which length equals 1")))
+
+(define (%make-string)
+  (utf8->string (%to-bytevector)))
+
+(define (@from-integer x . args)
+  (chain-apply args
+    (rich-char x)))
+
+(define (%to-integer)
+  code-point)
+
+)
+
+) ; end of begin
+) ; end of define-library
\ No newline at end of file
diff --git a/tests/resources/r7rs/liii/rich-hash-table.scm.txt b/tests/resources/r7rs/liii/rich-hash-table.scm.txt
new file mode 100644
index 00000000..1bf0262a
--- /dev/null
+++ b/tests/resources/r7rs/liii/rich-hash-table.scm.txt
@@ -0,0 +1,102 @@
+;
+; Copyright (C) 2025 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii rich-hash-table)
+(import (liii hash-table) (liii oop) (srfi srfi-8))
+(export rich-hash-table)
+(begin
+
+(define-case-class rich-hash-table ((data hash-table?))
+  (define (%collect) data)
+
+(chained-define (@empty)
+  (rich-hash-table (make-hash-table)))
+
+(define (%find pred?)
+  (define iter (make-iterator data))
+  (let loop ((kv (iter)))
+    (cond 
+        ((eof-object? kv) (none))
+        ((and (pair? kv) (pred? (car kv) (cdr kv))) (option kv))
+        (else (loop (iter))))))
+
+(define (%get k)
+  (option (hash-table-ref/default data k '())))
+
+(define (%remove k)
+  (rich-hash-table
+   (let ((new (make-hash-table)))
+     (hash-table-for-each
+      (lambda (key val)
+       (unless (equal? key k)
+        (hash-table-set! new key val)))
+       data)
+      new)))
+
+(chained-define (%remove! k)
+  (hash-table-delete! data k)
+  %this)
+
+(define (%contains k)
+  (hash-table-contains? data k))
+
+(define (%forall pred?)
+  (let ((all-kv (map identity data)))
+    (let loop ((kvs all-kv))  
+      (if (null? kvs)
+          #t  
+          (let ((kv (car kvs)))
+            (if (pred? (car kv) (cdr kv))
+                (loop (cdr kvs))  
+                #f))))))  
+
+(define (%exists pred?)
+  (define iter (make-iterator data))
+  (let loop ((kv (iter)))
+    (cond 
+        ((eof-object? kv) #f)
+        ((and (pair? kv) (pred? (car kv) (cdr kv))) #t)
+        (else (loop (iter))))))
+
+(define (%map f . args)
+  (chain-apply args
+    (let ((r (make-hash-table)))
+      (hash-table-for-each
+         (lambda (k v)
+           (receive (k1 v1) (f k v)
+             (hash-table-set! r k1 v1)))
+         data)
+      (rich-hash-table r))))
+
+(define (%count pred)
+  (hash-table-count pred data))
+
+(define (%for-each proc)
+  (hash-table-for-each proc data))
+
+(define (%filter f . args)
+  (chain-apply args
+    (let ((r (make-hash-table)))
+      (hash-table-for-each
+         (lambda (k v)
+           (when (f k v) (hash-table-set! r k v)))
+         data)
+      (rich-hash-table r))))
+
+) ; end of define-case-class
+
+) ; end of begin
+) ; end of define-library
diff --git a/tests/resources/r7rs/liii/rich-list.scm.txt b/tests/resources/r7rs/liii/rich-list.scm.txt
new file mode 100644
index 00000000..b7bb84f6
--- /dev/null
+++ b/tests/resources/r7rs/liii/rich-list.scm.txt
@@ -0,0 +1,452 @@
+(define-library (liii rich-list)
+(import (liii list)
+        (liii oop)
+        (liii sort)
+        (liii hash-table)
+        (liii string)
+        (liii option)
+        (srfi srfi-8))
+(export rich-list)
+(begin
+
+
+(define-case-class rich-list ((data list?))
+
+(define (@range start end . step-and-args)
+  (chain-apply (if (null? step-and-args) 
+                   step-and-args 
+                   (if (number? (car step-and-args))
+                       (cdr step-and-args)
+                       step-and-args))
+    (let ((step-size 
+            (if (null? step-and-args) 
+                1
+                (if (number? (car step-and-args))
+                    (car step-and-args)
+                    1))))
+      (cond
+        ((and (positive? step-size) (>= start end))
+         (rich-list '()))
+        ((and (negative? step-size) (<= start end))
+         (rich-list '()))
+        ((zero? step-size)
+         (value-error "Step size cannot be zero"))
+        (else
+         (let ((cnt (ceiling (/ (- end start) step-size))))
+           (rich-list (iota cnt start step-size))))))))
+
+(define (@empty . args)
+  (chain-apply args
+    (rich-list (list ))))
+
+(define (@concat lst1 lst2 . args)
+  (chain-apply args
+    (rich-list (append (lst1 :collect) (lst2 :collect)))))
+
+(define (@fill n elem)
+  (cond
+    ((< n 0)
+      (value-error "n cannot be negative"))
+    ((= n 0)
+      (rich-list '()))
+    (else
+      (rich-list (make-list n elem)))))
+
+(define (%collect) data)
+
+(define (%apply n)
+  (list-ref data n))
+
+(define (%find pred)
+  (let loop ((lst data))
+    (cond
+      ((null? lst) (none))
+      ((pred (car lst)) (option (car lst)))
+      (else (loop (cdr lst))))))
+
+(define (%find-last pred)
+  (let ((reversed-list (reverse data)))  ; 先反转列表
+    (let loop ((lst reversed-list))
+      (cond
+        ((null? lst) (none))  ; 遍历完未找到
+        ((pred (car lst)) (option (car lst)))  ; 找到第一个匹配项（即原列表最后一个）
+        (else (loop (cdr lst)))))))  ; 继续查找
+
+(define (%head)
+  (if (null? data)
+      (error 'out-of-range "rich-list%head: list is empty")
+      (car data)))
+
+(define (%head-option)
+  (if (null? data)
+      (none)
+      (option (car data))))
+
+
+(define (%last)
+  (if (null? data)
+      (index-error "rich-list%last: empty list")
+      (car (reverse data))))
+
+(define (%last-option)
+  (if (null? data)
+      (none)
+      (option (car (reverse data)))))
+
+(define (%slice from until . args)
+  (chain-apply args
+    (let* ((len (length data))
+          (start (max 0 (min from len)))
+          (end (max 0 (min until len))))
+      (if (< start end)
+          (rich-list (take (drop data start) (- end start)))
+          (rich-list '())))))
+
+(define (%empty?)
+  (null? data))
+
+(define (%equals that)
+  (let* ((l1 data)
+         (l2 (that 'data))
+         (len1 (length l1))
+         (len2 (length l2)))
+    (if (not (eq? len1 len2))
+        #f
+        (let loop ((left l1) (right l2))
+          (cond ((null? left) #t)
+                ((not (class=? (car left) (car right))) #f)
+                (else (loop (cdr left) (cdr right))))))))
+
+(define (%forall pred)
+  (every pred data))
+
+(define (%exists pred)
+  (any pred data))
+
+(define (%contains elem)
+  (%exists (lambda (x) (equal? x elem))))
+
+(define (%map x . args)
+  (chain-apply args
+    (rich-list (map x data))))
+
+(define (%flat-map x . args)
+  (chain-apply args
+    (rich-list (flat-map x data))))
+
+(define (%filter x . args)
+  (chain-apply args
+    (rich-list (filter x data))))
+
+(define (%for-each x)
+  (for-each x data))
+
+(define (%reverse . args)
+  (chain-apply args
+    (rich-list (reverse data))))
+    
+(define (%take x . args)
+  (chain-apply args
+    (begin 
+      (define (scala-take data n)
+        (unless (list? data) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-take '(data n) 'data "list" (object->string data))))
+        (unless (integer? n) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-take '(data n) 'n "integer" (object->string n))))
+      
+        (cond ((< n 0) '())
+              ((>= n (length data)) data)
+              (else (take data n))))
+    
+      (rich-list (scala-take data x)))))
+
+(define (%drop x . args)
+  (chain-apply args
+    (begin 
+      (define (scala-drop data n)
+        (unless (list? data) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-drop '(data n) 'data "list" (object->string data))))
+        (unless (integer? n) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-drop '(data n) 'n "integer" (object->string n))))
+      
+        (cond ((< n 0) data)
+              ((>= n (length data)) '())
+              (else (drop data n))))
+    
+      (rich-list (scala-drop data x)))))
+
+(define (%take-right x . args)
+  (chain-apply args
+    (begin 
+      (define (scala-take-right data n)
+        (unless (list? data) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-take-right '(data n) 'data "list" (object->string data))))
+        (unless (integer? n) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-take-right '(data n) 'n "integer" (object->string n))))
+      
+        (cond ((< n 0) '())
+              ((>= n (length data)) data)
+              (else (take-right data n))))
+    
+      (rich-list (scala-take-right data x)))))
+
+(define (%drop-right x . args)
+  (chain-apply args
+    (begin 
+      (define (scala-drop-right data n)
+        (unless (list? data) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-drop-right '(data n) 'data "list" (object->string data))))
+        (unless (integer? n) 
+            (type-error 
+               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                              scala-drop-right '(data n) 'n "integer" (object->string n))))
+      
+        (cond ((< n 0) data)
+              ((>= n (length data)) '())
+              (else (drop-right data n))))
+    
+      (rich-list (scala-drop-right data x)))))
+
+(define (%count . xs)
+  (cond ((null? xs) (length data))
+        ((length=? 1 xs) (count (car xs) data))
+        (else (error 'wrong-number-of-args "rich-list%count" xs))))
+
+(define (%length)
+  (length data))
+
+(define (%fold initial f)
+  (fold f initial data))
+
+(define (%fold-right initial f)
+  (fold-right f initial data))
+
+(define (%sort-with less-p . args)
+  (chain-apply args
+    (let ((sorted-data (list-stable-sort less-p data)))
+        (rich-list sorted-data))))
+
+(define (%sort-by f . args)
+  (chain-apply args
+    (let ((sorted-data (list-stable-sort (lambda (x y) (< (f x) (f y))) data)))
+    (rich-list sorted-data))))
+
+(define (%group-by func)
+  (let ((group (make-hash-table)))
+    (for-each
+      (lambda (elem) 
+        (let ((key (func elem)))
+          (hash-table-update!/default
+            group
+            key
+            (lambda (current-list) (cons elem current-list))
+            '())))
+      data)
+    (hash-table-for-each 
+      (lambda (k v) (hash-table-set! group k (reverse v))) 
+      group)
+  (rich-hash-table group)))
+
+(define (%sliding size . step-arg)
+  (unless (integer? size) (type-error "rich-list%sliding: size must be an integer " size))
+  (unless (> size 0) (value-error "rich-list%sliding: size must be a positive integer " size))
+
+  (let ((N (length data)))
+    (if (null? data)
+        #()
+        (let* ((is-single-arg-case (null? step-arg))
+               (step (if is-single-arg-case 1 (car step-arg))))
+
+          (when (and (not is-single-arg-case)
+                     (or (not (integer? step)) (<= step 0)))
+            (if (not (integer? step))
+                (type-error "rich-list%sliding: step must be an integer " step)
+                (value-error "rich-list%sliding: step must be a positive integer " step)))
+          
+          (if (and is-single-arg-case (< N size))
+              (vector data)
+              (let collect-windows ((current-list-segment data) (result-windows '()))
+                (cond
+                  ((null? current-list-segment) (list->vector (reverse result-windows)))
+                  ((and is-single-arg-case (< (length current-list-segment) size))
+                   (list->vector (reverse result-windows)))
+                  (else
+                   (let* ((elements-to-take (if is-single-arg-case
+                                                size
+                                                (min size (length current-list-segment))))
+                          (current-window (take current-list-segment elements-to-take))
+                          (next-list-segment (if (>= step (length current-list-segment))
+                                                 '()
+                                                 (drop current-list-segment step))))
+                     (collect-windows next-list-segment
+                                      (cons current-window result-windows)))))))))))
+
+(define (%zip l . args)
+  (chain-apply args
+    (rich-list (apply map cons (list data l)))))
+
+(define (%zip-with-index . args)
+  (chain-apply args
+    (let loop ((lst data) (idx 0) (result '()))
+      (if (null? lst)
+          (rich-list (reverse result))  
+          (loop (cdr lst) 
+                (+ idx 1) 
+                (cons (cons idx (car lst)) result))))))
+
+(define (%distinct . args)
+  (chain-apply args
+    (let loop
+      ((result '()) 
+      (data data) 
+      (ht (make-hash-table)))
+      (cond
+        ((null? data) (rich-list (reverse result)))  
+        (else
+         (let ((elem (car data)))
+           (if (eq? (hash-table-ref ht elem) #f) 
+               (begin
+                 (hash-table-set! ht elem #t)  
+                 (loop (cons elem result) (cdr data) ht))
+               (loop result (cdr data) ht))))))))
+
+(define (%reduce f)
+  (if (null? data)
+      (value-error "rich-list%reduce: empty list is not allowed to reduce")
+      (reduce f '() data)))
+
+(define (%reduce-option f)
+  (if (null? data)
+      (none)
+      (option (reduce f '() data))))
+
+(define (%take-while pred . args)
+  (chain-apply args
+    (let ((result (take-while pred data)))
+      (rich-list result))))
+
+(define (%drop-while pred . args)
+  (chain-apply args
+    (let ((result (drop-while pred data)))
+      (rich-list result))))
+
+(define (%index-where pred)
+  (list-index pred data))
+
+(define (%max-by f)
+  (unless (procedure? f) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %max-by '(f) 'f "procedure" (object->string f))))              
+  (if (null? data)
+      (value-error "rich-list%max-by: empty list is not allowed")
+      (let loop ((rest (cdr data))
+                 (max-elem (car data))
+                 (max-val (let ((val (f (car data))))
+                           (unless (real? val)
+                             (type-error "rich-list%max-by: procedure must return real number but got"
+                                        (object->string val)))
+                           val)))
+        (if (null? rest)
+            max-elem
+            (let* ((current (car rest))
+                   (current-val (let ((val (f current)))
+                                 (unless (real? val)
+                                   (type-error "rich-list%max-by: procedure must return real number but got"
+                                              (object->string val)))
+                                 val)))
+              (if (> current-val max-val)
+                  (loop (cdr rest) current current-val)
+                  (loop (cdr rest) max-elem max-val)))))))
+
+(define (%min-by f)
+  (unless (procedure? f) 
+      (type-error 
+        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
+                    %min-by '(f) 'f "procedure" (object->string f))))              
+  (if (null? data)
+      (value-error "rich-list%min-by: empty list is not allowed")
+      (let loop ((rest (cdr data))
+                 (min-elem (car data))
+                 (min-val (let ((val (f (car data))))
+                            (unless (real? val)
+                              (type-error "rich-list%min-by: procedure must return real number but got"
+                                         (object->string val)))
+                            val)))
+        (if (null? rest)
+            min-elem
+            (let* ((current (car rest))
+                   (current-val (let ((val (f current)))
+                                  (unless (real? val)
+                                    (type-error "rich-list%min-by: procedure must return real number but got"
+                                               (object->string val)))
+                                  val)))
+              (if (< current-val min-val)
+                  (loop (cdr rest) current current-val)
+                  (loop (cdr rest) min-elem min-val)))))))
+
+(define (%append l)
+  (rich-list (append data l)))
+
+(define (%max-by-option f)
+  (if (null? data)
+      (none)
+      (option (%max-by f))))
+
+(define (%min-by-option f)
+  (if (null? data)
+      (none)
+      (option (%min-by f))))
+
+(define (%to-string)
+  (object->string data))
+
+(define (%make-string . xs)
+  (define (parse-args xs)
+    (cond
+      ((null? xs) (values "" "" ""))
+      ((length=? 1 xs)
+       (let ((sep (car xs)))
+         (if (string? sep)
+             (values "" sep "")
+             (type-error "rich-list%make-string: separator must be a string" sep))))
+      ((length=? 2 xs)
+       (error 'wrong-number-of-args "rich-list%make-string: expected 0, 1, or 3 arguments, but got 2" xs))
+      ((length=? 3 xs)
+       (let ((start (car xs))
+             (sep (cadr xs))
+             (end (caddr xs)))
+         (if (and (string? start) (string? sep) (string? end))
+             (values start sep end)
+             (error 'type-error "rich-list%make-string: prefix, separator, and suffix must be strings" xs))))
+      (else (error 'wrong-number-of-args "rich-list%make-string: expected 0, 1, or 3 arguments" xs))))
+
+  (receive (start sep end) (parse-args xs)
+    (let ((as-string (lambda (x) (if (string? x) x (object->string x)))))
+      (string-append start (string-join (map as-string data) sep) end))))
+
+(define (%to-vector)
+  (list->vector data))
+
+(define (%to-rich-vector)
+  (rich-vector (list->vector data)))
+
+) ; end of define-case-class rich-list
+
+
+) ; end of begin
+) ; end of define-library
diff --git a/tests/resources/r7rs/liii/rich-string.scm.txt b/tests/resources/r7rs/liii/rich-string.scm.txt
new file mode 100644
index 00000000..16d311eb
--- /dev/null
+++ b/tests/resources/r7rs/liii/rich-string.scm.txt
@@ -0,0 +1,348 @@
+;
+; Copyright (C) 2025 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii rich-string)
+(import (liii string)
+        (liii oop)
+        (liii base)
+        (liii rich-char)
+        (liii rich-vector)
+        (liii vector))
+(export rich-string)
+(begin
+
+(define-case-class rich-string
+  ((data string?))
+  
+(define N (u8-string-length data))
+
+(define (@empty . args)
+  (chain-apply args (rich-string "")))
+
+(define (@value-of v . args)
+  (chain-apply args
+    (cond ((char? v) (rich-string (string v)))
+          ((number? v) (rich-string (number->string v)))
+          ((symbol? v) (rich-string (symbol->string v)))
+          ((string? v) (rich-string v))
+          ((rich-char :is-type-of v)
+           (rich-string (v :make-string)))
+          (else (type-error "Expected types are char, rich-char, number, symbol or string")))))
+
+(define (%get) data)
+
+(define (%length)
+  N)
+
+(define (%char-at index)
+  (when (not (integer? index))
+    (type-error "rich-string%char-at: index must be integer" index))
+
+  (let* ((start index)
+         (end (+ index 1))
+         (byte-seq (string->utf8 data start end)))
+    (rich-char :from-bytevector byte-seq)))
+
+(define (%apply i)
+  (%char-at i))
+
+(define (%find pred) ((%to-rich-vector) :find pred))
+
+(define (%find-last pred) ((%to-rich-vector) :find-last pred))
+
+(define (%head)
+  (if (string-null? data)
+      (index-error "rich-string%head: string is empty")
+      ($ data 0)))
+
+(define (%head-option)
+  (if (string-null? data)
+      (none)
+      (option ($ data 0))))
+
+(define (%last)
+  (if (string-null? data)
+      (index-error "rich-string%last: string is empty")
+      ($ data (- N 1))))
+
+(define (%last-option)
+  (if (string-null? data)
+      (none)
+      (option ($ data (- N 1)))))
+
+(define (%slice from until . args)
+  (chain-apply args
+    (let* ((start (max 0 from))
+           (end (min N until)))
+      (cond ((and (zero? start) (= end N))
+             (%this))
+            ((>= start end)
+             (rich-string :empty))
+            (else
+             (rich-string (u8-substring data start end)))))))
+
+(define (%take n . args)
+  (chain-apply args
+    (%slice 0 n)))
+
+(define (%take-right n . args)
+  (chain-apply args
+    (%slice (- N n) N)))
+
+(define (%drop n . args)
+  (chain-apply args
+    (%slice n N)))
+
+(define (%drop-right n . args)
+  (chain-apply args
+    (%slice 0 (- N n))))
+
+(define (%empty?)
+  (string-null? data))
+
+(define (%starts-with prefix)
+  (string-starts? data prefix))
+
+(define (%ends-with suffix)
+  (string-ends? data suffix))
+
+(define (%forall pred)
+  ((%to-rich-vector) :forall pred))
+
+(define (%exists pred)
+  ((%to-rich-vector) :exists pred))
+
+(define (%contains elem)
+  (cond ((rich-string :is-type-of elem)
+         (string-contains data (elem :get)))
+    
+        ((string? elem)
+         (string-contains data elem))
+        
+        ((rich-char :is-type-of elem)
+         (string-contains data (elem :make-string)))
+        
+        ((char? elem)
+         (string-contains data (string elem)))
+        
+        (else (type-error "elem must be char or string"))))
+
+(define* (%index-of str/char (start-index 0))
+  (define (bytes-match? data-bv data-pos str-bv str-size data-size)
+    (let loop ((i 0))
+      (if (>= i str-size)
+          #t
+          (and (< (+ data-pos i) data-size)
+               (= (bytevector-u8-ref data-bv (+ data-pos i))
+                  (bytevector-u8-ref str-bv i))
+               (loop (+ i 1))))))
+
+  (define (char-index->byte-pos bv size char-index)
+    (let loop ((i 0) (pos 0))
+      (if (>= i char-index)
+          pos
+          (loop (+ i 1) (bytevector-advance-u8 bv pos size)))))
+  
+  (define* (inner-index-of str start-index)
+    (if (or (string-null? data) (string-null? str))
+        -1
+        (let* ((data-bv (string->utf8 data))
+               (str-bv (string->utf8 str))
+               (data-size (bytevector-length data-bv))
+               (str-size (bytevector-length str-bv)))
+          (if (or (negative? start-index)
+                  (>= start-index N))
+              -1
+              (let ((start-byte-pos (char-index->byte-pos data-bv data-size start-index)))
+                (let search ((byte-pos start-byte-pos) (current-char-index start-index))
+                  (cond
+                    ((> (+ byte-pos str-size) data-size) -1)
+                    ((bytes-match? data-bv byte-pos str-bv str-size data-size)
+                     current-char-index)
+                    (else
+                     (search (bytevector-advance-u8 data-bv byte-pos data-size)
+                             (+ current-char-index 1))))))))))
+
+  (unless (integer? start-index)
+    (type-error "rich-string%index-of: the second parameter must be integer"))
+  
+  (let ((positive-start-index (max 0 start-index)))
+    (cond ((string? str/char)
+           (inner-index-of str/char positive-start-index))
+          ((rich-string :is-type-of str/char)
+           (inner-index-of (str/char :get) positive-start-index))
+          ((char? str/char)
+           (inner-index-of (string str/char) positive-start-index))
+          ((rich-char :is-type-of str/char)
+           (inner-index-of (str/char :make-string) positive-start-index))
+          (else (type-error "rich-string%index-of: first parameter must be string/rich-string/char/rich-char")))))
+
+(define (%map f . args)
+  (chain-apply args
+    (rich-string ((%to-rich-vector)
+                  :map f
+                  :map (lambda (x) (x :make-string))
+                  :make-string))))
+
+(define (%filter pred . args)
+  (chain-apply args
+    (rich-string ((%to-rich-vector)
+                  :filter pred
+                  :map (lambda (x) (x :make-string))
+                  :make-string))))
+
+(define (%reverse . args)
+  (chain-apply args
+    (rich-string ((%to-rich-vector)
+                  :reverse
+                  :map (lambda (x) (x :make-string))
+                  :make-string))))
+
+(define (%for-each f)
+  ((%to-rich-vector) :for-each f))
+
+(define (%count pred?)
+  ((%to-rich-vector) :count pred?))
+
+(define (%index-where pred)
+  (let ((bytes (string->utf8 data))
+        (len (bytevector-length (string->utf8 data))))
+    (let loop ((byte-pos 0) (char-index 0))
+      (cond
+        ((>= byte-pos len) -1)
+        (else
+         (let* ((next-pos (bytevector-advance-u8 bytes byte-pos len))
+                (char-bytes (bytevector-copy bytes byte-pos next-pos))
+                (char (rich-char :from-bytevector char-bytes)))
+           (if (pred char)
+               char-index
+               (loop next-pos (+ char-index 1)))))))))
+
+(define (%take-while pred . args)
+  (chain-apply args
+    (let ((stop-index (%index-where (lambda (c) (not (pred c))))))
+      (if (= stop-index -1)
+          (%this)
+          (%slice 0 stop-index)))))
+
+(define (%drop-while pred . args)
+  (chain-apply args
+    (let ((index (%index-where (lambda (c) (not (pred c))))))
+      (if (= index -1)
+          (rich-string "")
+          (%slice index N)))))
+
+(define (%to-string)
+  data)
+
+(define (%to-vector)
+  (if (string-null? data)
+      (vector)
+      (let* ((bv (string->utf8 data))
+             (bv-size (length bv))
+             (result (make-vector N)))
+        (let loop ((i 0) (j 0))
+          (if (>= i N)
+              result
+              (let* ((next-j (bytevector-advance-u8 bv j bv-size))
+                     (ch (rich-char :from-bytevector (bytevector-copy bv j next-j))))
+                (vector-set! result i ch)
+                (loop (+ i 1) next-j)))))))
+
+(define (%to-rich-vector)
+  (rich-vector (%to-vector)))
+
+(define (%+ s . args)
+  (chain-apply args
+    (cond
+      ((string? s)
+       (rich-string (string-append data s)))
+      ((rich-string :is-type-of s)
+       (rich-string (string-append data (s :get))))
+      ((number? s)
+       (rich-string (string-append data (number->string s))))
+      (else
+        (type-error (string-append (object->string s) "is not string or rich-string or number"))))))
+
+(define (%strip-left . args)
+  (chain-apply args
+    (rich-string (string-trim data))))
+
+(define (%strip-right . args)
+  (chain-apply args
+    (rich-string (string-trim-right data))))
+
+(define (%strip-both . args)
+  (chain-apply args
+    (rich-string (string-trim-both data))))
+
+(define (%strip-prefix prefix . args)
+  (chain-apply args
+    (rich-string (string-remove-prefix data prefix))))
+
+(define (%strip-suffix suffix . args)
+  (chain-apply args
+    (rich-string (string-remove-suffix data suffix))))
+
+(define (%replace-first old new . args)
+  (chain-apply args
+    (let ((next-pos (%index-of old)))
+      (if (= next-pos -1)
+          (%this)
+          ((%slice 0 next-pos)
+           :+ new
+           :+ (%drop (+ next-pos ($ old :length))))))))
+
+(define (%replace old new . args)
+  (define (replace-helper str old new start)
+    (let ((next-pos ((rich-string str) :index-of old start)))
+      (if (= next-pos -1)
+          str
+          (replace-helper ((rich-string str) :replace-first old new :get)
+                          old new next-pos))))
+  (chain-apply args
+    (rich-string (replace-helper data old new 0))))
+
+(define* (%pad-left len (char #\space) . args)
+  (let ((result (rich-string (string-pad data len char))))
+    (if (null? args)
+        result
+        (apply result args))))
+
+(define* (%pad-right len (char #\space) . args)
+  (let ((result (rich-string (string-pad-right data len char))))
+    (if (null? args)
+        result
+        (apply result args))))
+
+(define (%split sep)
+  (let ((str-len N)
+        (sep-len (u8-string-length sep)))
+    
+    (define (split-helper start acc)
+      (let ((next-pos (%index-of sep start)))
+        (if (= next-pos -1)
+            (cons (%drop start :get) acc)
+            (split-helper (+ next-pos sep-len) (cons (%slice start next-pos :get) acc)))))
+    
+    (if (zero? sep-len)
+        ((%to-rich-vector) :map (lambda (c) (c :make-string)))
+        (rich-vector (reverse-list->vector (split-helper 0 '()))))))
+
+)
+
+)
+)
diff --git a/tests/resources/r7rs/liii/rich-vector.scm.txt b/tests/resources/r7rs/liii/rich-vector.scm.txt
new file mode 100644
index 00000000..ad6e4526
--- /dev/null
+++ b/tests/resources/r7rs/liii/rich-vector.scm.txt
@@ -0,0 +1,446 @@
+;
+; Copyright (C) 2025 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii rich-vector)
+(import (liii string) (liii hash-table) (liii sort) (liii list) (liii vector) (liii oop) (srfi srfi-8))
+(export rich-vector)
+(begin
+
+(define-case-class rich-vector ((data vector?))
+
+(define (@range start end . step)
+  (let ((step-size (if (null? step) 1 (car step))))
+    (cond
+      ((and (positive? step-size) (>= start end))
+       (rich-vector #()))
+      ((and (negative? step-size) (<= start end))
+       (rich-vector #()))
+      ((zero? step-size)
+       (value-error "Step size cannot be zero"))
+      (else
+       (let ((cnt (ceiling (/ (- end start) step-size))))
+         (rich-vector (list->vector (iota cnt start step-size))))))))
+
+(define (@empty . args)
+  (chain-apply args
+    (rich-vector #())))
+
+(define (@fill n elem . args)
+  (unless (integer? n)
+    (type-error "n must be integer" n))
+  (when (< n 0)
+    (value-error "n must be non-negative" n))
+  (chain-apply args
+    (rich-vector (make-vector n elem))))
+
+(define (%collect) data)
+
+(define (%length)
+  (vector-length data))
+
+(define (%size)
+  (vector-length data))
+
+(define (%apply i)
+  (when (or (< i 0) (>= i (vector-length data)))
+    (index-error "rich-vector%apply: out of range with index" i))
+  (vector-ref data i))
+
+(define (%index-of x)
+  (or (vector-index (lambda (y) (class=? x y)) data)
+      -1))
+
+(define (%last-index-of x)
+  (or (vector-index-right (lambda (y) (class=? x y)) data)
+      -1))
+
+(define (%find p)
+  (let loop ((i 0))
+    (cond
+     ((>= i (vector-length data)) (none))
+     ((p (vector-ref data i)) (option (vector-ref data i)))
+     (else (loop (+ i 1))))))
+
+(define (%find-last pred)
+  (let loop ((i (- (vector-length data) 1)))
+    (cond
+      ((< i 0) (none))  ; 遍历完所有元素未找到
+      ((pred (vector-ref data i)) (option (vector-ref data i)))  ; 找到符合条件的元素
+      (else (loop (- i 1))))))  ; 继续向前查找
+
+(define (%head)
+  (if (> (vector-length data) 0)
+      (vector-ref data 0)
+      (error 'out-of-range "out-of-range")))
+
+(define (%head-option)
+  (if (> (vector-length data) 0)
+      (option (vector-ref data 0))
+      (none)))
+
+(define (%last)
+  (let ((len (vector-length data)))
+    (if (> len 0)
+      (vector-ref data (- len 1))
+      (index-error "rich-vector%last: empty vector"))))
+
+(define (%last-option)
+  (let ((len (vector-length data)))
+    (if (> len 0)
+      (option (vector-ref data (- len 1)))
+      (none))))
+
+(define (%slice from until . args)
+  (chain-apply args
+    (let* ((len (vector-length data))
+           (start (max 0 from))
+           (end (min len until)))
+      (if (< start end)
+          (rich-vector (vector-copy data start end))
+          (rich-vector :empty)))))
+
+(define (%empty?)
+  (= (length data) 0))
+
+(define (%equals that)
+  (and (that :is-instance-of 'rich-vector)
+       (vector= class=? data (that 'data))))
+
+(define (%forall p)
+  (vector-every p data))
+
+(define (%exists p)
+  (vector-any p data))
+
+(define (%contains elem)
+  (%exists (lambda (x) (equal? x elem))))
+
+(define (%map x . args)
+  (chain-apply args
+    (rich-vector (vector-map x data))))
+
+(define (%flat-map f . args)
+  (chain-apply args
+    (rich-vector (%map f :reduce vector-append))))
+
+(define (%filter x . args)
+  (chain-apply args
+    (rich-vector (vector-filter x data))))
+
+(define (%for-each x)
+  (vector-for-each x data))
+
+(define (%reverse . args)
+  (chain-apply args
+    (rich-vector (reverse data))))
+
+(define (%count . xs)
+  (cond ((null? xs) (vector-length data))
+        ((length=? 1 xs) (count (car xs) (vector->list data)))
+        (else (error 'wrong-number-of-args "rich-vector%count" xs))))
+
+(define (%take n . args)
+  (define (scala-take data n)
+    (cond
+      ((< n 0) (vector))
+      ((>= n (vector-length data)) data)
+      (else
+        (let ((new-vec (make-vector n)))
+          (do ((i 0 (+ i 1)))
+              ((>= i n) new-vec)
+            (vector-set! new-vec i (vector-ref data i)))))))
+  
+  (chain-apply args
+    (rich-vector (scala-take data n))))
+
+(define (%take-right n . args)
+  (define (scala-take-right data n)
+    (let ((len (vector-length data)))
+      (cond
+        ((< n 0) (vector))
+        ((>= n len) data)
+        (else
+          (let ((new-vec (make-vector n)))
+            (do ((i (- len n) (+ i 1))
+                 (j 0 (+ j 1)))
+                ((>= j n) new-vec)
+              (vector-set! new-vec j (vector-ref data i))))))))
+
+  (chain-apply args
+    (rich-vector (scala-take-right data n))))
+
+(define (%drop n . args)
+  (define (scala-drop data n)
+    (cond
+      ((< n 0) data)
+      ((>= n (vector-length data)) (vector))
+      (else (vector-copy data n))))
+  (chain-apply args
+    (rich-vector (scala-drop data n))))
+
+(define (%drop-right n . args)
+  (define (scala-drop-right data n)
+    (cond
+      ((< n 0) data)
+      ((>= n (vector-length data)) (vector))
+      (else (vector-copy data 0 (- (vector-length data) n)))))
+  
+  (chain-apply args
+    (rich-vector (scala-drop-right data n))))
+
+(define (%drop-while pred . args)
+  (chain-apply args
+    (let ((len (vector-length data)))
+      (let loop ((i 0))
+        (cond
+          ((>= i len) (rich-vector :empty))  ; 所有元素都被丢弃
+          ((pred (vector-ref data i)) (loop (+ i 1)))  ; 继续丢弃
+          (else (rich-vector (vector-copy data i)))))))) ; 返回剩余部分
+
+(define (%fold initial f)
+  (vector-fold f initial data))
+
+(define (%fold-right initial f)
+  (vector-fold-right f initial data))
+
+(define (%count . xs)
+  (cond ((null? xs) (vector-length data))
+        ((length=? 1 xs) (count (car xs) (vector->list data)))
+        (else (error 'wrong-number-of-args "rich-vector%count" xs))))
+
+(define (%sort-with less-p . args)
+  (chain-apply args
+    (rich-vector (vector-stable-sort less-p data))))
+
+(define (%sort-by f . args)
+  (chain-apply args
+    (let ((sorted-data (vector-stable-sort (lambda (x y) (< (f x) (f y))) data)))
+      (rich-vector sorted-data))))
+
+(define (%group-by func)
+  (let ((group (make-hash-table)))
+    (for-each
+      (lambda (elem) 
+        (let ((key (func elem)))
+          (hash-table-update!/default
+            group
+            key
+            (lambda (current-list) (cons elem current-list))
+            '())))
+      (vector->list data))
+    (hash-table-for-each 
+      (lambda (k v) (hash-table-set! group k (reverse-list->vector v))) 
+      group)
+    (rich-hash-table group)))
+
+(define (%sliding size . step-arg)
+  (unless (integer? size) (type-error "rich-vector%sliding: size must be an integer " size))
+  (unless (> size 0) (value-error "rich-vector%sliding: size must be a positive integer " size))
+
+  (let ((N (vector-length data)))
+    (if (zero? N)
+        #()
+        (let* ((is-single-arg-case (null? step-arg))
+               (step (if is-single-arg-case 1 (car step-arg))))
+
+          ;; Validate step if provided
+          (when (and (not is-single-arg-case)
+                     (or (not (integer? step)) (<= step 0)))
+            (if (not (integer? step))
+                (type-error "rich-vector%sliding: step must be an integer " step)
+                (value-error "rich-vector%sliding: step must be a positive integer " step)))
+          
+          ;; single-argument version when N < size
+          (if (and is-single-arg-case (< N size))
+              (vector data)
+              (let collect-windows ((current-idx 0) (result-windows '()))
+                (cond
+                  ;; Stop if current_idx is out of bounds
+                  ((>= current-idx N) (list->vector (reverse result-windows)))
+                  ;; For single-arg case
+                  ((and is-single-arg-case (> (+ current-idx size) N))
+                   (list->vector (reverse result-windows)))
+                  (else
+                   (let* ((window-end (if is-single-arg-case
+                                          (+ current-idx size)      ;; Single-arg: always takes full 'size'
+                                          (min (+ current-idx size) N))) ;; Two-arg: can be partial
+                          (current-window (vector-copy data current-idx window-end)))
+                     (collect-windows (+ current-idx step) (cons current-window result-windows)))))))))))
+
+(define (%zip-with-index . args)
+  (chain-apply args
+    (let* ((n (vector-length data))
+           (result (make-vector n)))
+      (let loop ((idx 0))
+        (if (>= idx n)
+            (rich-vector result)
+            (begin
+              (vector-set! 
+                  result 
+                  idx 
+                  (cons idx (vector-ref data idx)))
+              (loop (+ idx 1))))))))
+
+(define (%distinct . args)
+  (chain-apply args
+    (let ((ht (make-hash-table))
+          (length (vector-length data)))
+      (let loop ((result '())
+                (index 0))
+        (if (>= index length)
+            (rich-vector (list->vector (reverse result)))
+            (let ((elem (vector-ref data index)))
+              (if (eq? (hash-table-ref ht elem) #f)
+                  (begin
+                    (hash-table-set! ht elem #t)
+                    (loop (cons elem result) (+ index 1)))
+                   (loop result (+ index 1)))))))))
+
+(define (%reduce f)
+  (let ((len (vector-length data)))
+    (if (zero? len)
+        (value-error "rich-vector%reduce: empty vector is not allowed to reduce")
+        (let loop ((acc (vector-ref data 0))
+                   (i 1))
+          (if (>= i len)
+              acc
+              (loop (f acc (vector-ref data i)) (+ i 1)))))))
+
+(define (%index-where pred)
+  (or (vector-index pred data)
+      -1))
+
+(define (%last-index-where pred)
+  (or (vector-index-right pred data)
+      -1))
+
+(define (%take-while pred . args)
+  (chain-apply args
+    (let* ((vec data)
+           (len (vector-length vec))
+           (idx (vector-index (lambda (x) (not (pred x))) vec)))
+      (rich-vector (vector-copy vec 0 (or idx len))))))
+
+(define (%max-by f)
+  (when (not (procedure? f))
+    (type-error "rich-vector%max-by: f must be a procedure"))
+  
+  (let ((vec data)
+        (len (length data)))
+    (if (zero? len)
+        (value-error "rich-vector%max-by: empty list is not allowed")
+        (let loop ((i 1)
+                   (max-elem (vector-ref vec 0))
+                   (max-val (f (vector-ref vec 0))))
+          (if (>= i len)
+              max-elem
+              (let* ((current-elem (vector-ref vec i))
+                     (current-val (f current-elem)))
+                (unless (number? current-val)
+                  (type-error "f must return a number"))
+                (if (< current-val max-val)
+                    (loop (+ i 1) max-elem max-val)
+                    (loop (+ i 1) current-elem current-val))))))))
+
+(define (%min-by f)
+  (when (not (procedure? f))
+    (type-error "rich-vector%min-by: f must be a procedure"))
+
+  (let ((vec data)
+        (len (length data)))
+    (if (zero? len)
+        (value-error "rich-vector%min-by: empty list is not allowed")
+        (let loop ((i 1)
+                   (min-elem (vector-ref vec 0))
+                   (min-val (f (vector-ref vec 0))))
+          (if (>= i len)
+              min-elem
+              (let* ((current-elem (vector-ref vec i))
+                     (current-val (f current-elem)))
+                (unless (number? current-val)
+                  (type-error "f must return a number"))
+                (if (> current-val min-val)
+                    (loop (+ i 1) min-elem min-val)
+                    (loop (+ i 1) current-elem current-val))))))))
+
+(define (%max-by-option f)
+  (when (not (procedure? f))
+    (type-error "rich-vector%max-by-option: f must be a procedure"))
+
+  (if (zero? (vector-length data))
+      (none)
+      (option (%max-by f))))
+
+(define (%min-by-option f)
+  (when (not (procedure? f))
+    (type-error "rich-vector%min-by-option: f must be a procedure"))
+
+  (if (zero? (vector-length data))
+      (none)
+      (option (%min-by f))))
+
+(define (%to-string)
+  ((%map object->string)
+   :make-string "#(" " " ")"))
+
+(define (%make-string . xs)
+  (define (parse-args xs)
+    (cond
+      ((null? xs) (values "" "" ""))
+      ((length=? 1 xs)
+       (let ((sep (car xs)))
+         (if (string? sep)
+             (values "" sep "")
+             (type-error "rich-vector%make-string: separator must be a string" sep))))
+      ((length=? 2 xs)
+       (error 'wrong-number-of-args "rich-vector%make-string: expected 0, 1, or 3 arguments, but got 2" xs))
+      ((length=? 3 xs)
+       (let ((start (car xs))
+             (sep (cadr xs))
+             (end (caddr xs)))
+         (if (and (string? start) (string? sep) (string? end))
+             (values start sep end)
+             (type-error "rich-vector%make-string: prefix, separator, and suffix must be strings" xs))))
+      (else (error 'wrong-number-of-args "rich-vector%make-string: expected 0, 1, or 3 arguments" xs))))
+
+  (receive (start sep end) (parse-args xs)
+    (let* ((as-string (lambda (x) (if (string? x) x (object->string x))))
+           (middle (string-join (map as-string (vector->list data)) sep)))
+      (string-append start middle end))))
+
+(define (%to-list)
+  (vector->list data))
+
+(define (%to-rich-list)
+  (rich-list (vector->list data)))
+
+(define (%set! i x)
+  (when (or (< i 0) (>= i (length data)))
+    (index-error "rich-vector%set! out of range at index" i))
+  (vector-set! data i x))
+
+(define (%append v)
+  (when (not (or (vector? v) (rich-vector :is-type-of v)))
+    (type-error "rich-vector%append: input is not vector or rich-vector"))
+  
+  (if (vector? v)
+      (rich-vector (vector-append data v))
+      (rich-vector (vector-append data (v :collect)))))
+
+) ; end of define-case-class
+
+) ; end of begin
+) ; end of define-library
diff --git a/tests/resources/r7rs/liii/set.scm.txt b/tests/resources/r7rs/liii/set.scm.txt
new file mode 100644
index 00000000..c351f20e
--- /dev/null
+++ b/tests/resources/r7rs/liii/set.scm.txt
@@ -0,0 +1,69 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii set)
+(import (liii lang)(liii hash-table)(srfi srfi-128))
+(export hash-set)
+(begin
+
+
+(define-case-class hash-set ((data hash-table?))
+
+;; Factory methods
+(chained-define (@empty) 
+  (hash-set (make-hash-table)))
+                   
+;; Basic operations
+(define (%size) (hash-table-size data))
+
+(define (%empty?) (hash-table-empty? data))
+
+(define (%contains element)
+  (hash-table-contains? data element))
+
+;; Modification operations
+(chained-define (%add-one! element)
+  (hash-table-set! data element #t)
+  (%this))
+
+(chained-define (%remove! element)
+  (hash-table-delete! data element)
+  (%this))
+
+(chained-define (%add-one element)
+  (let ((ht (make-hash-table)))
+    (hash-table-for-each
+      (lambda (k v) (hash-table-set! ht k v))
+      data)
+    (hash-table-set! ht element #t)
+    (hash-set ht)))
+
+(chained-define (%remove element)
+  (let ((ht (make-hash-table)))
+    (hash-table-for-each
+      (lambda (k v) (hash-table-set! ht k v))
+      data)
+    (hash-table-delete! ht element)
+    (hash-set ht)))
+
+(chained-define (%clear!)
+  (hash-table-clear! data)
+  (%this))
+
+) ; end of define-case-class
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/sort.scm.txt b/tests/resources/r7rs/liii/sort.scm.txt
new file mode 100644
index 00000000..50beef81
--- /dev/null
+++ b/tests/resources/r7rs/liii/sort.scm.txt
@@ -0,0 +1,22 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii sort)
+(export list-sorted? vector-sorted?
+        list-merge  list-sort  list-stable-sort  vector-merge  vector-sort  vector-stable-sort
+        list-merge! list-sort! list-stable-sort! vector-merge! vector-sort! vector-stable-sort!)
+(import (srfi srfi-132)))
+
diff --git a/tests/resources/r7rs/liii/stack.scm.txt b/tests/resources/r7rs/liii/stack.scm.txt
new file mode 100644
index 00000000..cecab660
--- /dev/null
+++ b/tests/resources/r7rs/liii/stack.scm.txt
@@ -0,0 +1,60 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii stack)
+(import (liii rich-list) (liii oop))
+(export stack)
+(begin
+
+(define-case-class stack ((data list?))
+                   
+(define (%length) (length data))
+
+(define (%size) (length data))
+
+(define (%top)
+  (if (null? data)
+      (error 'out-of-range)
+      (car data)))
+
+(define (%to-list) data)
+
+(define (%to-rich-list) (rich-list data))
+
+(define (@empty) (stack (list )))
+
+(chained-define (%pop)
+  (if (null? data)
+      (error 'out-of-range "Cannot pop from an empty stack")
+      (stack (cdr data))))
+
+(chained-define (%pop!)
+  (if (null? data)
+      (error 'out-of-range)
+      (stack (set! data (cdr data))))
+  (%this))
+
+(chained-define (%push element)
+  (stack (cons element data)))
+
+(chained-define (%push! element) 
+                (stack (set! data (cons element data))) 
+                (%this))
+
+) ; end of define-case-class
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/string.scm.txt b/tests/resources/r7rs/liii/string.scm.txt
new file mode 100644
index 00000000..7cc37c9a
--- /dev/null
+++ b/tests/resources/r7rs/liii/string.scm.txt
@@ -0,0 +1,64 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii string)
+(export
+  ; S7 built-in
+  string? string-ref string-length
+  ; from (scheme base)
+  string-copy string-for-each string-map
+  ; from (srfi srfi-13)
+  string-null? string-join
+  string-every string-any
+  string-take string-take-right string-drop string-drop-right
+  string-pad string-pad-right
+  string-trim string-trim-right string-trim-both
+  string-index string-index-right
+  string-contains string-count
+  string-upcase string-downcase
+  string-fold string-fold-right string-for-each-index
+  string-reverse
+  string-tokenize
+  ; Liii extras
+  string-starts? string-ends?
+  string-remove-prefix string-remove-suffix
+)
+(import (srfi srfi-13)
+        (liii base)
+        (liii error))
+(begin
+
+(define (string-starts? str prefix)
+  (string-prefix? prefix str))
+
+(define (string-ends? str suffix)
+  (string-suffix? suffix str))
+
+(define string-remove-prefix
+  (typed-lambda ((str string?) (prefix string?))
+    (if (string-prefix? prefix str)
+        (substring str (string-length prefix))
+        str)))
+
+(define string-remove-suffix
+  (typed-lambda ((str string?) (suffix string?))
+    (if (string-suffix? suffix str)
+        (substring str 0 (- (string-length str) (string-length suffix)))
+        (string-copy str))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/sys.scm.txt b/tests/resources/r7rs/liii/sys.scm.txt
new file mode 100644
index 00000000..4f0efad1
--- /dev/null
+++ b/tests/resources/r7rs/liii/sys.scm.txt
@@ -0,0 +1,28 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii sys)
+(export argv executable)
+(import (scheme process-context))
+(begin
+
+(define (argv) (command-line))
+
+(define (executable) (g_executable))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/uuid.scm.txt b/tests/resources/r7rs/liii/uuid.scm.txt
new file mode 100644
index 00000000..daff1986
--- /dev/null
+++ b/tests/resources/r7rs/liii/uuid.scm.txt
@@ -0,0 +1,25 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii uuid)
+(export uuid4)
+(begin
+
+(define (uuid4) (g_uuid4))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/liii/vector.scm.txt b/tests/resources/r7rs/liii/vector.scm.txt
new file mode 100644
index 00000000..bcff52ad
--- /dev/null
+++ b/tests/resources/r7rs/liii/vector.scm.txt
@@ -0,0 +1,58 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (liii vector)
+(import (srfi srfi-133)
+        (srfi srfi-13)
+        (liii base))
+(export
+  ; S7 Scheme built-in
+  make-vector vector vector-length vector-ref vector-set! vector->list list->vector
+  ; from (scheme base)
+  vector-copy vector-fill! vector-copy! vector->string string->vector
+  vector-map vector-for-each
+  ; from (srfi srfi-133)
+  vector-empty?
+  vector-fold vector-fold-right
+  vector-count
+  vector-any vector-every vector-copy vector-copy!
+  vector-index vector-index-right vector-skip vector-skip-right vector-partition
+  vector-swap! vector-reverse! vector-cumulate reverse-list->vector
+  vector=
+  ; Liii Extras
+  vector-filter
+)
+(begin
+
+(define (vector-filter pred vec)
+  (let* ((result-list (vector-fold (lambda (elem acc)
+                                     (if (pred elem)
+                                         (cons elem acc)
+                                         acc))
+                                   '()
+                                   vec))
+         (result-length (length result-list))
+         (result-vec (make-vector result-length)))
+    (let loop ((i (- result-length 1)) (lst result-list))
+      (if (null? lst)
+          result-vec
+          (begin
+            (vector-set! result-vec i (car lst))
+            (loop (- i 1) (cdr lst)))))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/base.scm.txt b/tests/resources/r7rs/scheme/base.scm.txt
similarity index 100%
rename from tests/resources/r7rs/base.scm.txt
rename to tests/resources/r7rs/scheme/base.scm.txt
diff --git a/tests/resources/r7rs/boot.scm.txt b/tests/resources/r7rs/scheme/boot.scm.txt
similarity index 100%
rename from tests/resources/r7rs/boot.scm.txt
rename to tests/resources/r7rs/scheme/boot.scm.txt
diff --git a/tests/resources/r7rs/case-lambda.scm.txt b/tests/resources/r7rs/scheme/case-lambda.scm.txt
similarity index 100%
rename from tests/resources/r7rs/case-lambda.scm.txt
rename to tests/resources/r7rs/scheme/case-lambda.scm.txt
diff --git a/tests/resources/r7rs/char.scm.txt b/tests/resources/r7rs/scheme/char.scm.txt
similarity index 100%
rename from tests/resources/r7rs/char.scm.txt
rename to tests/resources/r7rs/scheme/char.scm.txt
diff --git a/tests/resources/r7rs/file.scm.txt b/tests/resources/r7rs/scheme/file.scm.txt
similarity index 100%
rename from tests/resources/r7rs/file.scm.txt
rename to tests/resources/r7rs/scheme/file.scm.txt
diff --git a/tests/resources/r7rs/inexact.scm.txt b/tests/resources/r7rs/scheme/inexact.scm.txt
similarity index 100%
rename from tests/resources/r7rs/inexact.scm.txt
rename to tests/resources/r7rs/scheme/inexact.scm.txt
diff --git a/tests/resources/r7rs/process-context.scm.txt b/tests/resources/r7rs/scheme/process-context.scm.txt
similarity index 100%
rename from tests/resources/r7rs/process-context.scm.txt
rename to tests/resources/r7rs/scheme/process-context.scm.txt
diff --git a/tests/resources/r7rs/time.scm.txt b/tests/resources/r7rs/scheme/time.scm.txt
similarity index 100%
rename from tests/resources/r7rs/time.scm.txt
rename to tests/resources/r7rs/scheme/time.scm.txt
diff --git a/tests/resources/r7rs/srfi/sicp.scm.txt b/tests/resources/r7rs/srfi/sicp.scm.txt
new file mode 100644
index 00000000..03715b7f
--- /dev/null
+++ b/tests/resources/r7rs/srfi/sicp.scm.txt
@@ -0,0 +1,20 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi sicp)
+(export true false nil runtime)
+(import (srfi srfi-216)))
+
diff --git a/tests/resources/r7rs/srfi/srfi-1.scm.txt b/tests/resources/r7rs/srfi/srfi-1.scm.txt
new file mode 100644
index 00000000..3c64546c
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-1.scm.txt
@@ -0,0 +1,355 @@
+;;; SRFI-1 list-processing library                      -*- Scheme -*-
+;;; Reference implementation
+;;;
+;;; SPDX-License-Identifier: MIT
+;;;
+;;; Copyright (c) 1998, 1999 by Olin Shivers. You may do as you please with
+;;; this code as long as you do not remove this copyright notice or
+;;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
+;;;     -Olin
+;;;
+;;; Copyright (c) 2024 The Goldfish Scheme Authors
+;;; Follow the same License as the original one
+
+(define-library (srfi srfi-1)
+(import (liii error)
+        (liii base))
+(export
+  ; SRFI 1: Constructors
+  circular-list iota list-copy xcons cons*
+  ; SRFI 1: Predicates
+  circular-list? null-list? proper-list? dotted-list?
+  ; SRFI 1: Selectors
+  first second third fourth fifth
+  sixth seventh eighth ninth tenth
+  take drop take-right drop-right fold fold-right split-at
+  reduce reduce-right append-map filter partition remove find
+  delete delete-duplicates
+  ; SRFI 1: Miscellaneous: length, append, concatenate, reverse, zip & count
+  zip count
+  ; SRFI 1: Association List
+  assoc assq assv alist-cons
+  take-while drop-while list-index any every
+  last-pair last)
+(begin
+
+(define (xcons a b)
+         (cons b a))
+
+(define (cons* a . b)
+  (if (null? b)
+      a
+      (cons a (apply cons* b))))
+
+; 0 clause BSD, from S7 repo stuff.scm
+(define* (iota count (start 0) (step 1))
+  (when (not (integer? count))
+    (type-error "iota: count must be an integer"))
+  (when (< count 0)
+    (value-error "iota: count must be non-negative but received ~d" count))
+  (do ((i count (- i 1))
+       (val (+ start (* (- count 1) step)) (- val step))
+       (result '() (cons val result)))
+      ((zero? i) result)))
+
+(define (proper-list? x)
+  (let loop ((x x) (lag x))
+    (if (pair? x)
+        (let ((x (cdr x)))
+          (if (pair? x)
+              (let ((x   (cdr x))
+                    (lag (cdr lag)))
+                (and (not (eq? x lag)) (loop x lag)))
+              (null? x)))
+        (null? x))))
+
+(define (dotted-list? x)
+  (let loop ((x x) (lag x))
+    (if (pair? x)
+        (let ((x (cdr x)))
+          (if (pair? x)
+              (let ((x   (cdr x))
+                    (lag (cdr lag)))
+                (and (not (eq? x lag)) (loop x lag)))
+              (not (null? x))))
+        (not (null? x)))))
+
+(define (null-list? l)
+  (cond ((pair? l) #f)
+        ((null? l) #t)
+        (else
+         (error 'wrong-type-arg "null-list?: argument out of domain" l))))
+
+(define first car)
+
+(define second cadr)
+
+(define third caddr)
+
+(define (fourth x) (list-ref x 3))
+
+(define (fifth x) (list-ref x 4))
+
+(define (sixth x) (list-ref x 5))
+
+(define (seventh x) (list-ref x 6))
+
+(define (eighth x) (list-ref x 7))
+
+(define (ninth x) (list-ref x 8))
+
+(define (tenth x) (list-ref x 9))
+
+(define (take l k)
+  (let loop ((l l) (k k))
+    (if (zero? k)
+        '()
+        (cons (car l)
+              (loop (cdr l) (- k 1))))))
+
+(define drop list-tail)
+
+(define (take-right l k)
+  (let loop ((lag l)
+             (lead (drop l k)))
+    (if (pair? lead)
+        (loop (cdr lag) (cdr lead))
+        lag)))
+
+(define (drop-right l k)
+  (let loop ((lag l) (lead (drop l k)))
+    (if (pair? lead)
+        (cons (car lag) (loop (cdr lag) (cdr lead)))
+        '())))
+
+(define (split-at lst i)
+  (when (< i 0)
+    (value-error "require a index greater than 0, but got ~A -- split-at" i))
+  (let ((result (cons #f '())))
+    (do ((j i (- j 1))
+         (rest lst (cdr rest))
+         (node result (cdr node)))
+        ((zero? j)
+         (values (cdr result) rest))
+      (when (not (pair? rest))
+        (value-error "lst length cannot be greater than i, where lst is ~A, but i is ~A-- split-at" lst i))
+      (set-cdr! node (cons (car rest) '())))))
+
+
+(define (last-pair l)
+  (if (pair? (cdr l))
+      (last-pair (cdr l))
+      l))
+
+(define (last l)
+  (car (last-pair l)))
+
+(define (count pred list1 . lists)
+  (let lp ((lis list1) (i 0))
+    (if (null-list? lis) i
+        (lp (cdr lis) (if (pred (car lis)) (+ i 1) i)))))
+
+(define (zip . lists)
+  (apply map list lists))
+
+(define (fold f initial . lists)
+  (unless (procedure? f)
+    (error 'type-error "expected procedure, got ~S" f))
+  
+  (cond
+    ((null? lists) initial)
+    
+    ((and (pair? lists) (null? (cdr lists)) (list? (car lists)))
+     (let loop ((acc initial) (lst (car lists)))
+       (if (null? lst)
+           acc
+           (loop (f (car lst) acc) (cdr lst)))))
+    
+    (else
+     (let loop ((acc initial) (lsts lists))
+       (if (any null? lsts)
+           acc
+           (let* ((cars (map car lsts))
+                  (cdrs (map cdr lsts)))
+             (loop (apply f (append cars (list acc))) cdrs)))))))
+
+(define (fold-right f initial . lists)
+  (unless (procedure? f)
+    (error 'type-error "expected procedure, got ~S" f))
+  
+  (cond
+    ((null? lists) initial)
+    ((and (pair? lists) (null? (cdr lists)) (list? (car lists)))
+     (let loop ((lst (car lists)))
+       (if (null? lst)
+           initial
+           (f (car lst) (loop (cdr lst))))))
+    (else
+     (let loop ((lsts lists))
+       (if (any null? lsts)
+           initial
+           (let* ((cars (map car lsts))
+                  (cdrs (map cdr lsts)))
+             (apply f (append cars (list (loop cdrs))))))))))
+
+(define (reduce f initial l)
+  (if (null-list? l) initial
+      (fold f (car l) (cdr l))))
+
+(define (reduce-right f initial l)
+  (if (null-list? l) initial
+      (let recur ((head (car l)) (l (cdr l)))
+        (if (pair? l)
+            (f head (recur (car l) (cdr l)))
+            head))))
+
+(define (append-map proc . lists)
+  (unless (procedure? proc)
+    (error 'type-error "expected procedure, got ~S" proc))
+  (for-each 
+    (lambda (lst)
+      (unless (list? lst)
+        (error 'type-error "expected list, got ~S" lst)))
+    lists)
+  (apply append (apply map proc lists)))
+
+(define (filter pred l)
+  (let recur ((l l))
+    (if (null-list? l) l
+        (let ((head (car l))
+              (tail (cdr l)))
+          (if (pred head)
+              (let ((new-tail (recur tail)))
+                (if (eq? tail new-tail) l
+                    (cons head new-tail)))
+              (recur tail))))))
+
+(define (partition pred l)
+  (let loop ((lst l) (satisfies '()) (dissatisfies '()))
+    (cond ((null? lst)
+           (cons satisfies dissatisfies))
+          ((pred (car lst))
+           (loop (cdr lst) (cons (car lst) satisfies) dissatisfies))
+          (else
+           (loop (cdr lst) satisfies (cons (car lst) dissatisfies))))))
+
+(define (remove pred l)
+  (filter (lambda (x) (not (pred x))) l))
+
+(define (find pred l)
+  (cond ((null? l) #f)
+        ((pred (car l)) (car l)) 
+        (else (find pred (cdr l)))))
+
+(define (take-while pred lst)
+  (if (null? lst) 
+      '()
+      (if (pred (car lst))
+          (cons (car lst) (take-while pred (cdr lst)))
+          '())))
+
+(define (drop-while pred l)
+  (if (null? l)
+      '()
+      (if (pred (car l))
+          (drop-while pred (cdr l))
+          l)))
+
+(define (list-index pred l)
+    (let loop ((index 0) (l l))
+      (if (null? l)
+          #f
+          (if (pred (car l))
+              index
+              (loop (+ index 1) (cdr l))))))
+
+(define (any pred? l)
+  (cond ((null? l) #f)
+        ((pred? (car l)) #t)
+        (else (any pred? (cdr l)))))
+
+(define (every pred? l)
+  (cond ((null? l) #t)
+        ((not (pred? (car l))) #f)
+        (else (every pred? (cdr l)))))
+
+(define (%extract-maybe-equal maybe-equal)
+  (let ((my-equal (if (null-list? maybe-equal)
+                      equal?
+                      (car maybe-equal))))
+    (if (procedure? my-equal)
+        my-equal
+        (error 'wrong-type-arg "maybe-equal must be procedure"))))
+
+(define (delete x l . maybe-equal)
+  (let ((my-equal (%extract-maybe-equal maybe-equal)))
+    (filter (lambda (y) (not (my-equal x y))) l)))
+
+;; Check if equality function is supported by s7 hash-table
+(define (%can-use-hash-table? eq-func)
+  (memq eq-func '(eq? eqv? equal? equivalent? = string=? string-ci=? char=? char-ci=?)))
+
+;; Fast hash-table based deduplication using s7's native hash-table
+(define (%delete-duplicates-hash lis eq-func)
+  (let ((seen (make-hash-table 8 eq-func))
+        (result '()))
+    (for-each 
+      (lambda (x)
+        (unless (hash-table-ref seen x)
+          (hash-table-set! seen x #t)
+          (set! result (cons x result))))
+      lis)
+    (reverse result)))
+
+;; origin
+(define (%delete-duplicates-scan lis my-equal)
+  (let loop ((remaining lis) (seen '()) (result '()))
+    (cond
+      ((null? remaining)
+       (reverse result))
+      ((member (car remaining) seen my-equal)
+       (loop (cdr remaining) seen result))
+      (else
+       (loop (cdr remaining)
+             (cons (car remaining) seen)
+             (cons (car remaining) result))))))
+
+;;; right-duplicate deletion
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; delete-duplicates delete-duplicates!
+;;;
+;;; Hybrid strategy: Use hash table O(n) for supported functions and 
+;;; optimized scan O(n²) for other functions
+;;; 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(define (delete-duplicates lis . maybe-equal)
+  (let ((my-equal (%extract-maybe-equal maybe-equal)))
+    (cond
+      ((null? lis) lis)
+      ((%can-use-hash-table? my-equal)
+       (%delete-duplicates-hash lis my-equal))
+      (else
+       (%delete-duplicates-scan lis my-equal)))))
+
+(define (alist-cons key value alist)
+  (cons (cons key value) alist))
+
+(define (circular-list val1 . vals)
+  (let ((ans (cons val1 vals)))
+    (set-cdr! (last-pair ans) ans)
+    ans))
+
+(define (circular-list? x)
+  (let loop ((x x) (lag x))
+    (and (pair? x)
+         (let ((x (cdr x)))
+           (and (pair? x)
+                (let ((x   (cdr x))
+                      (lag (cdr lag)))
+                  (or (eq? x lag) (loop x lag))))))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-113.scm.txt b/tests/resources/r7rs/srfi/srfi-113.scm.txt
new file mode 100644
index 00000000..b857d6e8
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-113.scm.txt
@@ -0,0 +1,29 @@
+; Copyright (C) John Cowan (2015). All Rights Reserved.
+;
+; Permission is hereby granted, free of charge, to any person obtaining a copy of
+; this software and associated documentation files (the "Software"), to deal in
+; the Software without restriction, including without limitation the rights to
+; use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+; of the Software, and to permit persons to whom the Software is furnished to do
+; so, subject to the following conditions:
+;
+; The above copyright notice and this permission notice shall be included in all
+; copies or substantial portions of the Software.
+;
+; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+; SOFTWARE.
+;
+
+(define-library (srfi srfi-113)
+(import (scheme base))
+(export set?)
+(begin
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-125.scm.txt b/tests/resources/r7rs/srfi/srfi-125.scm.txt
new file mode 100644
index 00000000..d1b18934
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-125.scm.txt
@@ -0,0 +1,161 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-125)
+(import (srfi srfi-1)
+        (liii base)
+        (liii error))
+(export
+  make-hash-table hash-table hash-table-unfold alist->hash-table
+  hash-table? hash-table-contains? hash-table-empty? hash-table=?
+  hash-table-mutable?
+  hash-table-ref hash-table-ref/default
+  hash-table-set! hash-table-delete! hash-table-intern! hash-table-update!
+  hash-table-update!/default hash-table-pop! hash-table-clear!
+  hash-table-size hash-table-keys hash-table-values hash-table-entries
+  hash-table-find hash-table-count
+  hash-table-for-each hash-table-map->list
+  hash-table->alist
+)
+(begin
+
+(define (assert-hash-table-type ht f)
+  (when (not (hash-table? ht))
+    (error 'type-error f "this parameter must be typed as hash-table")))
+
+(define s7-hash-table-set! hash-table-set!)
+(define s7-make-hash-table make-hash-table)
+(define s7-hash-table-entries hash-table-entries)
+
+(define (make-hash-table . args)
+  (cond ((null? args) (s7-make-hash-table))
+        ((comparator? (car args))
+         (let* ((equiv (comparator-equality-predicate (car args)))
+                (hash-func (comparator-hash-function (car args))))
+           (s7-make-hash-table 8 (cons equiv hash-func) (cons #t #t))))
+        (else (type-error "make-hash-table"))))
+
+(define alist->hash-table
+  (typed-lambda ((lst list?))
+    (when (odd? (length lst))
+      (value-error "The length of lst must be even!"))
+    (let1 ht (make-hash-table)
+      (let loop ((rest lst))
+        (if (null? rest)
+            ht
+            (begin
+              (hash-table-set! ht (car rest) (cadr rest))
+              (loop (cddr rest))))))))
+
+(define (hash-table-contains? ht key)
+  (not (not (hash-table-ref ht key))))
+
+(define (hash-table-empty? ht)
+  (zero? (hash-table-size ht)))
+
+(define (hash-table=? ht1 ht2)
+  (equal? ht1 ht2))
+
+(define (hash-table-ref/default ht key default)
+  (or (hash-table-ref ht key)
+      (if (procedure? default) (default) default)))
+
+(define (hash-table-set! ht . rest)
+  (assert-hash-table-type ht hash-table-set!)
+  (let1 len (length rest)
+    (when (or (odd? len) (zero? len))
+      (error 'wrong-number-of-args len "but must be even and non-zero"))
+    
+    (s7-hash-table-set! ht (car rest) (cadr rest))
+    (when (> len 2)
+          (apply hash-table-set! (cons ht (cddr rest))))))
+
+(define (hash-table-delete! ht key . keys)
+  (assert-hash-table-type ht hash-table-delete!)
+  (let1 all-keys (cons key keys)
+    (length
+      (filter
+        (lambda (x)
+          (if (hash-table-contains? ht x)
+              (begin
+                (s7-hash-table-set! ht x #f)
+                #t)
+              #f))
+        all-keys))))
+
+(define (hash-table-update! ht key value)
+  (hash-table-set! ht key value))
+
+(define (hash-table-update!/default ht key updater default)
+  (hash-table-set! ht key (updater (hash-table-ref/default ht key default))))
+
+(define (hash-table-clear! ht)
+  (for-each
+    (lambda (key)
+      (hash-table-set! ht key #f))
+    (hash-table-keys ht)))
+
+(define hash-table-size s7-hash-table-entries)
+
+(define (hash-table-keys ht)
+  (map car ht))
+
+(define (hash-table-values ht)
+  (map cdr ht))
+
+(define hash-table-entries
+  (typed-lambda ((ht hash-table?))
+    (let ((ks (hash-table-keys ht))
+          (vs (hash-table-values ht)))
+      (values ks vs))))
+
+(define (hash-table-find proc ht failure)
+  (let ((keys (hash-table-keys ht)))
+    (let loop ((keys keys))
+      (if (null? keys)
+          (if (procedure? failure)
+              (failure)
+              failure)
+          (let* ((key (car keys))
+                 (value (hash-table-ref ht key)))
+            (if (proc key value)
+                value
+                (loop (cdr keys))))))))
+
+(define hash-table-count
+  (typed-lambda ((pred? procedure?) (ht hash-table?))
+    (count (lambda (x) (pred? (car x) (cdr x)))
+           (map values ht))))
+
+(define hash-table-for-each
+  (typed-lambda ((proc procedure?) (ht hash-table?))
+    (for-each (lambda (x) (proc (car x) (cdr x)))
+              ht)))
+
+(define hash-table-map->list
+  (typed-lambda ((proc procedure?) (ht hash-table?))
+    (map (lambda (x) (proc (car x) (cdr x)))
+         ht)))
+
+(define hash-table->alist
+  (typed-lambda ((ht hash-table?))
+    (append-map
+      (lambda (x) (list (car x) (cdr x)))
+      (map values ht))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-128.scm.txt b/tests/resources/r7rs/srfi/srfi-128.scm.txt
new file mode 100644
index 00000000..8a932dd3
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-128.scm.txt
@@ -0,0 +1,376 @@
+;;; SPDX-License-Identifier: MIT
+;;;
+;;; Copyright (C) John Cowan (2015). All Rights Reserved.
+;;; 
+;;; Permission is hereby granted, free of charge, to any person
+;;; obtaining a copy of this software and associated documentation
+;;; files (the "Software"), to deal in the Software without
+;;; restriction, including without limitation the rights to use,
+;;; copy, modify, merge, publish, distribute, sublicense, and/or
+;;; sell copies of the Software, and to permit persons to whom the
+;;; Software is furnished to do so, subject to the following
+;;; conditions:
+;;; 
+;;; The above copyright notice and this permission notice shall be
+;;; included in all copies or substantial portions of the Software.
+;;; 
+;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+;;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+;;; OTHER DEALINGS IN THE SOFTWARE. 
+
+;;;; Main part of the SRFI 114 reference implementation
+
+;;; "There are two ways of constructing a software design: One way is to
+;;; make it so simple that there are obviously no deficiencies, and the
+;;; other way is to make it so complicated that there are no *obvious*
+;;; deficiencies." --Tony Hoare
+
+(define-library (srfi srfi-128)
+(import (scheme base)
+        (liii error))
+(export
+  comparator? comparator-ordered? comparator-hashable?
+  make-comparator make-pair-comparator make-list-comparator
+  make-vector-comparator make-eq-comparator make-eqv-comparator make-equal-comparator
+  boolean-hash char-hash char-ci-hash string-hash string-ci-hash
+  symbol-hash number-hash
+  make-default-comparator default-hash
+  comparator-type-test-predicate comparator-equality-predicate
+  comparator-ordering-predicate comparator-hash-function
+  comparator-test-type comparator-check-type comparator-hash
+  =? <? >? <=? >=?
+)
+(begin
+
+(define-record-type comparator
+  (make-raw-comparator type-test equality ordering hash ordering? hash?)
+  comparator?
+  (type-test comparator-type-test-predicate)
+  (equality comparator-equality-predicate)
+  (ordering comparator-ordering-predicate)
+  (hash comparator-hash-function)
+  (ordering? comparator-ordered?)
+  (hash? comparator-hashable?))
+
+;; Invoke the test type
+(define (comparator-test-type comparator obj)
+  ((comparator-type-test-predicate comparator) obj))
+
+(define (comparator-check-type comparator obj)
+  (if (comparator-test-type comparator obj)
+    #t
+    (type-error "comparator type check failed" comparator obj)))
+
+(define (comparator-hash comparator obj)
+  ((comparator-hash-function comparator) obj))
+
+(define (binary=? comparator a b)
+  ((comparator-equality-predicate comparator) a b))
+
+(define (binary<? comparator a b)
+  ((comparator-ordering-predicate comparator) a b))
+
+(define (binary>? comparator a b)
+  (binary<? comparator b a))
+
+(define (binary<=? comparator a b)
+  (not (binary>? comparator a b)))
+
+(define (binary>=? comparator a b)
+  (not (binary<? comparator a b)))
+
+(define (%salt%)
+  16064047)
+
+(define (hash-bound)
+  33554432)
+
+(define (make-hasher)
+  (let ((result (%salt%)))
+    (case-lambda
+     (() result)
+     ((n) (set! result (+ (modulo (* result 33) (hash-bound)) n))
+          result))))
+
+(define (make-comparator type-test equality ordering hash)
+  (make-raw-comparator
+    (if (eq? type-test #t) (lambda (x) #t) type-test)
+    (if (eq? equality #t) (lambda (x y) (eqv? (ordering x y) 0)) equality)
+    (if ordering ordering (lambda (x y) (error "ordering not supported")))
+    (if hash hash (lambda (x y) (error "hashing not supported")))
+    (if ordering #t #f)
+    (if hash #t #f)))
+
+(define (make-eq-comparator)
+  (make-comparator #t eq? #f default-hash))
+
+(define (make-eqv-comparator)
+  (make-comparator #t eqv? #f default-hash))
+
+(define (make-equal-comparator)
+  (make-comparator #t equal? #f default-hash))
+
+(define (make-pair-type-test car-comparator cdr-comparator)
+  (lambda (obj)
+    (and (pair? obj)
+         (comparator-test-type car-comparator (car obj))
+         (comparator-test-type cdr-comparator (cdr obj)))))
+
+(define (make-pair=? car-comparator cdr-comparator)
+   (lambda (a b)
+     (and ((comparator-equality-predicate car-comparator) (car a) (car b))
+          ((comparator-equality-predicate cdr-comparator) (cdr a) (cdr b)))))
+
+(define (make-pair<? car-comparator cdr-comparator)
+   (lambda (a b)
+      (if (=? car-comparator (car a) (car b))
+        (<? cdr-comparator (cdr a) (cdr b))
+        (<? car-comparator (car a) (car b)))))
+
+(define (make-pair-hash car-comparator cdr-comparator)
+   (lambda (obj)
+     (let ((acc (make-hasher)))
+       (acc (comparator-hash car-comparator (car obj)))
+       (acc (comparator-hash cdr-comparator (cdr obj)))
+       (acc))))
+
+(define (make-pair-comparator car-comparator cdr-comparator)
+   (make-comparator
+     (make-pair-type-test car-comparator cdr-comparator)
+     (make-pair=? car-comparator cdr-comparator)
+     (make-pair<? car-comparator cdr-comparator)
+     (make-pair-hash car-comparator cdr-comparator)))
+
+;; Cheap test for listness
+(define (norp? obj) (or (null? obj) (pair? obj)))
+
+(define (make-list-comparator element-comparator type-test empty? head tail)
+   (make-comparator
+     (make-list-type-test element-comparator type-test empty? head tail)
+     (make-list=? element-comparator type-test empty? head tail)
+     (make-list<? element-comparator type-test empty? head tail)
+     (make-list-hash element-comparator type-test empty? head tail)))
+
+(define (make-list-type-test element-comparator type-test empty? head tail)
+  (lambda (obj)
+    (and
+      (type-test obj)
+      (let ((elem-type-test (comparator-type-test-predicate element-comparator)))
+        (let loop ((obj obj))
+          (cond
+            ((empty? obj) #t)
+            ((not (elem-type-test (head obj))) #f)
+            (else (loop (tail obj)))))))))
+
+(define (make-list=? element-comparator type-test empty? head tail)
+  (lambda (a b)
+    (let ((elem=? (comparator-equality-predicate element-comparator)))
+      (let loop ((a a) (b b))
+        (cond
+          ((and (empty? a) (empty? b) #t))
+          ((empty? a) #f)
+          ((empty? b) #f)
+          ((elem=? (head a) (head b)) (loop (tail a) (tail b)))
+          (else #f))))))
+
+(define (make-list<? element-comparator type-test empty? head tail)
+  (lambda (a b)
+    (let ((elem=? (comparator-equality-predicate element-comparator))
+          (elem<? (comparator-ordering-predicate element-comparator)))
+      (let loop ((a a) (b b))
+        (cond
+          ((and (empty? a) (empty? b) #f))
+          ((empty? a) #t)
+          ((empty? b) #f)
+          ((elem=? (head a) (head b)) (loop (tail a) (tail b)))
+          ((elem<? (head a) (head b)) #t)
+          (else #f))))))
+
+(define (make-list-hash element-comparator type-test empty? head tail)
+  (lambda (obj)
+    (let ((elem-hash (comparator-hash-function element-comparator))
+          (acc (make-hasher)))
+      (let loop ((obj obj))
+        (cond
+          ((empty? obj) (acc))
+          (else (acc (elem-hash (head obj))) (loop (tail obj))))))))
+
+(define (make-vector-comparator element-comparator type-test length ref)
+  (make-comparator
+    (make-vector-type-test element-comparator type-test length ref)
+    (make-vector=? element-comparator type-test length ref)
+    (make-vector<? element-comparator type-test length ref)
+    (make-vector-hash element-comparator type-test length ref)))
+
+(define (make-vector-type-test element-comparator type-test length ref)
+  (lambda (obj)
+    (and
+      (type-test obj)
+      (let ((elem-type-test (comparator-type-test-predicate element-comparator))
+            (len (length obj)))
+        (let loop ((n 0))
+          (cond
+            ((= n len) #t)
+            ((not (elem-type-test (ref obj n))) #f)
+            (else (loop (+ n 1)))))))))
+
+(define (make-vector=? element-comparator type-test length ref)
+   (lambda (a b)
+     (and
+       (= (length a) (length b))
+       (let ((elem=? (comparator-equality-predicate element-comparator))
+             (len (length b)))
+         (let loop ((n 0))
+           (cond
+             ((= n len) #t)
+             ((elem=? (ref a n) (ref b n)) (loop (+ n 1)))
+             (else #f)))))))
+
+(define (make-vector<? element-comparator type-test length ref)
+   (lambda (a b)
+     (cond
+       ((< (length a) (length b)) #t)
+       ((> (length a) (length b)) #f)
+        (else
+         (let ((elem=? (comparator-equality-predicate element-comparator))
+             (elem<? (comparator-ordering-predicate element-comparator))
+             (len (length a)))
+         (let loop ((n 0))
+           (cond
+             ((= n len) #f)
+             ((elem=? (ref a n) (ref b n)) (loop (+ n 1)))
+             ((elem<? (ref a n) (ref b n)) #t)
+             (else #f))))))))
+
+(define (make-vector-hash element-comparator type-test length ref)
+  (lambda (obj)
+    (let ((elem-hash (comparator-hash-function element-comparator))
+          (acc (make-hasher))
+          (len (length obj)))
+      (let loop ((n 0))
+        (cond
+          ((= n len) (acc))
+          (else (acc (elem-hash (ref obj n))) (loop (+ n 1))))))))
+
+(define (object-type obj)
+  (cond
+    ((null? obj) 0)
+    ((pair? obj) 1)
+    ((boolean? obj) 2)
+    ((char? obj) 3)
+    ((string? obj) 4)
+    ((symbol? obj) 5)
+    ((number? obj) 6)
+    ((vector? obj) 7)
+    ((bytevector? obj) 8)
+    (else 65535)))
+
+(define (boolean<? a b)
+  ;; #f < #t but not otherwise
+  (and (not a) b))
+
+(define (complex<? a b)
+  (if (= (real-part a) (real-part b))
+    (< (imag-part a) (imag-part b))
+    (< (real-part a) (real-part b))))
+
+(define (symbol<? a b)
+  (string<? (symbol->string a) (symbol->string b)))
+
+(define boolean-hash hash-code)
+(define char-hash hash-code)
+(define char-ci-hash hash-code)
+(define string-hash hash-code)
+(define string-ci-hash hash-code)
+(define symbol-hash hash-code)
+(define number-hash hash-code)
+(define default-hash hash-code)
+
+(define (dispatch-ordering type a b)
+  (case type
+    ((0) 0) ; All empty lists are equal
+    ((1) ((make-pair<? (make-default-comparator) (make-default-comparator)) a b))
+    ((2) (boolean<? a b))
+    ((3) (char<? a b))
+    ((4) (string<? a b))
+    ((5) (symbol<? a b))
+    ((6) (complex<? a b))
+    ((7) ((make-vector<? (make-default-comparator) vector? vector-length vector-ref)
+          a b))
+    ((8) ((make-vector<? (make-comparator exact-integer? = < default-hash)
+                         bytevector? bytevector-length bytevector-u8-ref)
+          a b))
+    ; Add more here
+    (else (binary<? (registered-comparator type) a b))))
+
+(define (default-ordering a b)
+  (let ((a-type (object-type a))
+        (b-type (object-type b)))
+    (cond
+      ((< a-type b-type) #t)
+      ((> a-type b-type) #f)
+      (else (dispatch-ordering a-type a b)))))
+
+(define (dispatch-equality type a b)
+  (case type
+    ((0) #t) ; All empty lists are equal
+    ((1) ((make-pair=? (make-default-comparator) (make-default-comparator)) a b))
+    ((2) (boolean=? a b))
+    ((3) (char=? a b))
+    ((4) (string=? a b))
+    ((5) (symbol=? a b))
+    ((6) (= a b))
+    ((7) ((make-vector=? (make-default-comparator)
+                         vector? vector-length vector-ref) a b))
+    ((8) ((make-vector=? (make-comparator exact-integer? = < default-hash)
+                         bytevector? bytevector-length bytevector-u8-ref) a b))
+    ; Add more here
+    (else (binary=? (registered-comparator type) a b))))
+
+(define (default-equality a b)
+  (let ((a-type (object-type a))
+        (b-type (object-type b)))
+    (if (= a-type b-type)
+        (dispatch-equality a-type a b)
+        #f)))
+
+(define (make-default-comparator)
+  (make-comparator
+    (lambda (obj) #t)
+    default-equality
+    default-ordering
+    default-hash))
+
+(define (=? comparator a b . objs)
+  (let loop ((a a) (b b) (objs objs))
+    (and (binary=? comparator a b)
+         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
+
+(define (<? comparator a b . objs)
+  (let loop ((a a) (b b) (objs objs))
+    (and (binary<? comparator a b)
+         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
+
+(define (>? comparator a b . objs)
+  (let loop ((a a) (b b) (objs objs))
+    (and (binary>? comparator a b)
+         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
+
+(define (<=? comparator a b . objs)
+  (let loop ((a a) (b b) (objs objs))
+    (and (binary<=? comparator a b)
+         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
+
+(define (>=? comparator a b . objs)
+  (let loop ((a a) (b b) (objs objs))
+    (and (binary>=? comparator a b)
+         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-13.scm.txt b/tests/resources/r7rs/srfi/srfi-13.scm.txt
new file mode 100644
index 00000000..75cfa0ef
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-13.scm.txt
@@ -0,0 +1,380 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-13)
+  (import
+    (liii base)
+    (srfi srfi-1))
+  (export
+    string-null? string-copy string-join
+    string-every string-any
+    string-take string-take-right string-drop string-drop-right 
+    string-pad string-pad-right
+    string-trim string-trim-right string-trim-both
+    string-prefix? string-suffix? 
+    string-index string-index-right
+    string-contains string-count
+    string-upcase string-downcase
+    string-fold string-fold-right string-for-each-index
+    string-reverse
+    string-tokenize)
+(begin
+
+(define (%string-from-range str start_end)
+  (cond ((null-list? start_end) str)
+        ((= (length start_end) 1)
+          (substring str (car start_end)))
+        ((= (length start_end) 2)
+         (substring str (first start_end) (second start_end)))
+        (else (error 'wrong-number-of-args "%string-from-range"))))
+
+(define (%make-criterion char/pred?)
+  (cond ((char? char/pred?) (lambda (x) (char=? x char/pred?)))
+        ((procedure? char/pred?) char/pred?)
+        (else (error 'wrong-type-arg "%make-criterion"))))
+
+(define (string-join l . delim+grammer)
+  (define (extract-params params-l)
+    (cond ((null-list? params-l)
+           (list "" 'infix))
+          ((and (= (length params-l) 1)
+                (string? (car params-l)))
+           (list (car params-l) 'infix))
+          ((and (= (length params-l) 2)
+                (string? (first params-l))
+                (symbol? (second params-l)))
+           params-l)
+          ((> (length params-l) 2)
+           (error 'wrong-number-of-args "optional params in string-join"))
+          (else (error 'type-error "optional params in string-join"))))
+  
+  (define (string-join-sub l delim)
+    (cond ((null-list? l) "")
+          ((= (length l) 1) (car l))
+          (else
+            (string-append
+              (car l)
+              delim
+              (string-join-sub (cdr l) delim)))))
+  
+  (let* ((params  (extract-params delim+grammer))
+         (delim   (first params))
+         (grammer (second params))
+         (ret     (string-join-sub l delim)))
+    (case grammer
+      ('infix ret)
+      ('strict-infix
+       (if (null-list? l)
+           (error 'value-error "empty list not allowed")
+           ret))
+      ('suffix
+        (if (null-list? l) "" (string-append ret delim)))
+      ('prefix
+        (if (null-list? l) "" (string-append delim ret)))
+      (else (error 'value-error "invalid grammer")))))
+
+(define (string-null? str)
+  (and (string? str) 
+       ((lambda (x) (= x 0)) (string-length str))))
+
+(define (string-every char/pred? str . start+end)
+  (define (string-every-sub pred? str)
+    (let
+      loop ((i 0) (len (string-length str)))
+      (or (= i len)
+          (and (pred? (string-ref str i)) 
+               (loop (+ i 1) len)))))
+  
+  (let ((str-sub (%string-from-range str start+end))
+        (criterion (%make-criterion char/pred?)))
+    (string-every-sub criterion str-sub)))
+
+(define (string-any char/pred? str . start+end)
+  (define (string-any-sub pred? str)
+    (let loop ((i 0) (len (string-length str)))
+      (if (= i len)
+          #f   
+          (or (pred? (string-ref str i)) 
+              (loop (+ i 1) len)))))
+  
+  (let ((str_sub (%string-from-range str start+end))
+        (criterion (%make-criterion char/pred?)))
+    (string-any-sub criterion str_sub)))
+
+(define (string-take str k)
+  (substring str 0 k))
+
+(define (string-take-right str k)
+  (let ((N (string-length str)))
+    (if (> k N)
+        (error 'out-of-range "k must be <= N" k N))
+        (substring str (- N k) N)))
+
+(define string-drop
+  (typed-lambda ((str string?) (k integer?))
+    (when (< k 0)
+      (error 'out-of-range "k must be non-negative" k))
+    (let ((N (string-length str)))
+      (if (> k N)
+        (error 'out-of-range "k must be <= N" k N)
+        (substring str k N)))))
+
+(define string-drop-right
+  (typed-lambda ((str string?) (k integer?))
+    (when (< k 0)
+      (error 'out-of-range "k must be non-negative" k))
+    (let ((N (string-length str)))
+      (if (> k N)
+        (error 'out-of-range "k must be <= N" k N)
+        (substring str 0 (- N k))))))
+
+(define (string-pad str len . char+start+end)
+  (define (string-pad-sub str len ch)
+    (let ((orig-len (string-length str)))
+      (if (< len orig-len)
+          (string-take-right str len)
+          (string-append (make-string (- len orig-len) ch) str))))
+  
+  (cond ((null-list? char+start+end)
+         (string-pad-sub str len #\ ))
+        ((list? char+start+end)
+         (string-pad-sub
+           (%string-from-range str (cdr char+start+end))
+           len
+           (car char+start+end)))
+        (else (error 'wrong-type-arg "string-pad"))))
+
+(define (string-pad-right str len . char+start+end)
+  (define (string-pad-right-sub str len ch)
+    (let ((orig-len (string-length str)))
+      (if (< len orig-len)
+          (string-take str len)
+          (string-append str (make-string (- len orig-len) ch)))))
+  
+  (cond ((null-list? char+start+end)
+         (string-pad-right-sub str len #\ ))
+        ((list? char+start+end)
+         (string-pad-right-sub
+           (%string-from-range str (cdr char+start+end))
+           len
+           (car char+start+end)))
+        (else (error 'wrong-type-arg "string-pad"))))
+
+(define (string-trim str . opt)
+  (let ((predicate (cond
+                    ((null? opt) char-whitespace?)
+                    ((char? (car opt)) (lambda (c) (char=? c (car opt))))
+                    ((procedure? (car opt)) (car opt))
+                    (else (type-error "Invalid second argument: expected character or predicate" (car opt))))))
+    (let* ((start (if (and (> (length opt) 1) (number? (cadr opt))) (cadr opt) 0))
+           (end (if (and (> (length opt) 2) (number? (caddr opt))) (caddr opt) (string-length str)))
+           (str (substring str start end)))
+      (let loop ((i 0)
+                 (len (string-length str)))
+        (if (or (>= i len) (not (predicate (string-ref str i))))
+            (substring str i len)
+            (loop (+ i 1) len))))))
+
+(define (string-trim-right str . opt)
+  (let ((predicate (cond
+                    ((null? opt) char-whitespace?)
+                    ((char? (car opt)) (lambda (c) (char=? c (car opt))))
+                    ((procedure? (car opt)) (car opt))
+                    (else (type-error "Invalid second argument: expected character or predicate" (car opt))))))
+    (let* ((start (if (and (> (length opt) 1) (number? (cadr opt))) (cadr opt) 0))
+           (end (if (and (> (length opt) 2) (number? (caddr opt))) (caddr opt) (string-length str)))
+           (str (substring str start end)))
+      (let loop ((j (- (string-length str) 1)))
+        (if (or (< j 0) (not (predicate (string-ref str j))))
+            (substring str 0 (+ j 1))
+            (loop (- j 1)))))))
+
+(define (string-trim-both str . opt)
+  (let ((predicate (cond
+                    ((null? opt) char-whitespace?)
+                    ((char? (car opt)) (lambda (c) (char=? c (car opt))))
+                    ((procedure? (car opt)) (car opt))
+                    (else (type-error "Invalid second argument: expected character or predicate" (car opt))))))
+    (let* ((start (if (and (> (length opt) 1) (number? (cadr opt))) (cadr opt) 0))
+           (end (if (and (> (length opt) 2) (number? (caddr opt))) (caddr opt) (string-length str)))
+           (str (substring str start end)))
+      (let loop-left ((i 0)
+                      (len (string-length str)))
+        (if (or (>= i len) (not (predicate (string-ref str i))))
+            (let loop-right ((j (- len 1)))
+              (if (or (< j i) (not (predicate (string-ref str j))))
+                  (substring str i (+ j 1))
+                  (loop-right (- j 1))))
+            (loop-left (+ i 1) len))))))
+
+(define (string-prefix? prefix str)
+  (let* ((prefix-len (string-length prefix))
+         (str-len (string-length str)))
+    (and (<= prefix-len str-len)
+         (string=? prefix (substring str 0 prefix-len)))))
+
+(define (string-suffix? suffix str)
+  (let* ((suffix-len (string-length suffix))
+         (str-len (string-length str)))
+    (and (<= suffix-len str-len)
+         (string=? suffix (substring str (- str-len suffix-len) str-len)))))
+
+(define (string-index str char/pred? . start+end)
+  (define (string-index-sub str pred?)
+    (let loop ((i 0))
+      (cond ((>= i (string-length str)) #f)
+            ((pred? (string-ref str i)) i)
+            (else (loop (+ i 1))))))
+  
+  (let* ((start (if (null-list? start+end) 0 (car start+end)))
+         (str-sub (%string-from-range str start+end))
+         (pred? (%make-criterion char/pred?))
+         (ret (string-index-sub str-sub pred?)))
+    (if ret (+ start ret) ret)))
+
+(define (string-index-right str char/pred? . start+end)
+  (define (string-index-right-sub str pred?)
+    (let loop ((i (- (string-length str) 1)))
+      (cond ((< i 0) #f)
+            ((pred? (string-ref str i)) i)
+            (else (loop (- i 1))))))
+  
+  (let* ((start (if (null-list? start+end) 0 (car start+end)))
+        (str-sub (%string-from-range str start+end))
+        (pred? (%make-criterion char/pred?))
+        (ret (string-index-right-sub str-sub pred?)))
+    (if ret (+ start ret) ret)))
+
+(define (string-contains str sub-str)
+  (let loop ((i 0))
+    (let ((len (string-length str))
+          (sub-str-len (string-length sub-str)))
+      (if (> i (- len sub-str-len)) 
+          #f
+          (if (string=? 
+                (substring
+                  str
+                  i
+                  (+ i sub-str-len))
+                sub-str)
+              #t
+              (loop (+ i 1)))))))
+
+(define (string-count str char/pred? . start+end)
+  (when (not (string? str))
+    (type-error "string-count: first parameter must be string"))
+  (let ((str-sub (%string-from-range str start+end))
+        (criterion (%make-criterion char/pred?)))
+    (count criterion (string->list str-sub))))
+
+(define s7-string-upcase string-upcase)
+
+(define* (string-upcase str (start 0) (end (string-length str)))
+  (let* ((left (substring str 0 start))
+         (middle (substring str start end))
+         (right (substring str end)))
+    (string-append left (s7-string-upcase middle) right)))
+
+(define s7-string-downcase string-downcase)
+
+(define* (string-downcase str (start 0) (end (string-length str)))
+  (let* ((left (substring str 0 start))
+         (middle (substring str start end))
+         (right (substring str end)))
+    (string-append left (s7-string-downcase middle) right)))
+
+(define (string-reverse str . start+end)
+  (cond ((null-list? start+end)
+         (reverse str))
+        ((= (length start+end) 1)
+         (let ((start (first start+end)))
+           (string-append (substring str 0 start)
+                          (reverse (substring str start)))))
+        ((= (length start+end) 2)
+         (let ((start (first start+end))
+               (end (second start+end)))
+           (string-append (substring str 0 start)
+                          (reverse (substring str start end))
+                          (substring str end))))
+        (else (error 'wrong-number-of-args "string-reverse"))))
+
+(define (string-fold kons knil s . rest)
+  (when (not (procedure? kons))
+        (type-error "string-fold: first argument must be a procedure"))
+  (when (not (string? s))
+        (type-error "string-fold: second argument must be a string"))
+
+  (let ((substr (%string-from-range s rest)))
+    (let loop ((i 0)
+               (result knil))
+      (if (= i (string-length substr))
+          result
+          (loop (+ i 1)
+                (kons (string-ref substr i) result))))))
+
+(define (string-fold-right kons knil s . rest)
+  (when (not (procedure? kons))
+        (type-error "string-fold-right: first argument must be a procedure"))
+  (when (not (string? s))
+        (type-error "string-fold-right: second argument must be a string"))
+
+  (let ((substr (%string-from-range s rest)))
+    (let loop ((i (- (string-length substr) 1))
+               (result knil))
+      (if (< i 0)
+          result
+          (loop (- i 1)
+                (kons (string-ref substr i) result))))))
+
+(define (string-for-each-index proc str . start+end)
+  (when (not (procedure? proc))
+    (error 'type-error "string-for-each-index: first argument must be a procedure"))
+  (when (not (string? str))
+    (error 'type-error "string-for-each-index: expected a string"))
+  (let ((substr (%string-from-range str start+end)))
+    (let loop ((i 0) (len (string-length substr)) (acc '()))
+      (if (< i len)
+          (loop (+ i 1) len (proc i (string-ref substr i) acc))
+          (reverse acc)))))
+
+(define (string-tokenize str . char+start+end)
+  
+  (define (string-tokenize-sub str char)
+    
+    (define (tokenize-helper tokens cursor)
+      (let ((sep-pos/false (string-index str char cursor)))
+        (if (not sep-pos/false)
+            (reverse (cons (substring str cursor) tokens))
+            (let ((new-tokens
+                   (if (= cursor sep-pos/false)
+                       tokens
+                       (cons (substring str cursor sep-pos/false) tokens)))
+                  (next-cursor (+ sep-pos/false 1)))
+              (tokenize-helper new-tokens next-cursor)))))
+  
+      (tokenize-helper '() 0))
+  
+  (cond ((null-list? char+start+end)
+         (string-tokenize-sub str #\ ))
+        ((list? char+start+end)
+         (string-tokenize-sub
+               (%string-from-range str (cdr char+start+end))
+               (car char+start+end)))
+        (else (error 'wrong-type-arg "string-tokenize"))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-132.scm.txt b/tests/resources/r7rs/srfi/srfi-132.scm.txt
new file mode 100644
index 00000000..da227609
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-132.scm.txt
@@ -0,0 +1,188 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-132)
+(export list-sorted? vector-sorted?
+        list-merge  list-sort  list-stable-sort  vector-merge  vector-sort  vector-stable-sort
+        list-merge! list-sort! list-stable-sort! vector-merge! vector-sort! vector-stable-sort!)
+(import (liii list)
+        (liii error)
+        (scheme case-lambda))
+(begin
+
+
+(define (list-sorted? less-p lis)
+  (if (null? lis)
+    #t
+    (do ((first lis (cdr first))
+          (second (cdr lis) (cdr second))
+          (res #t (not (less-p (car second) (car first)))))
+      ((or (null? second) (not res)) res))))
+
+(define vector-sorted?
+  (case-lambda
+    ((less-p v) (vector-sorted? less-p v 0 (vector-length v)))
+    ((less-p v start) (vector-sorted? less-p v start (vector-length v)))
+    ((less-p v start end)
+      (if (or (< start 0) (> end (vector-length v)) (> start end))
+        (raise "Invalid start or end parameters") ; 使用 raise 抛出错误
+        (let loop ((i start))
+          (if (>= i (- end 1))
+            #t
+            (if (less-p (vector-ref v (+ i 1)) (vector-ref v i))
+              #f
+              (loop (+ i 1)))))))))
+
+(define (list-merge less-p lis1 lis2)
+  (let loop
+    ((res '())
+      (lis1 lis1)
+      (lis2 lis2))
+    (cond
+      ((and (null? lis1) (null? lis2)) (reverse res))
+      ((null? lis1) (loop (cons (car lis2) res) lis1 (cdr lis2)))
+      ((null? lis2) (loop (cons (car lis1) res) lis2 (cdr lis1)))
+      ((less-p (car lis2) (car lis1)) (loop (cons (car lis2) res) lis1 (cdr lis2)))
+      (else (loop (cons (car lis1) res) (cdr lis1) lis2)))))
+
+(define list-merge!
+  (lambda (less-p lis1 lis2)
+    (define (merge! left right prev)
+      (let loop ((left left) (right right) (prev prev))
+        (cond
+          ((null? left) (set-cdr! prev right))
+          ((null? right) (set-cdr! prev left))
+          ((less-p (car left) (car right))
+            (set-cdr! prev left)
+            (loop (cdr left) right left))
+          (else
+            (set-cdr! prev right)
+            (loop left (cdr right) right)))))
+    (let ((dummy (cons '() '())))
+      (merge! lis1 lis2 dummy)
+      (cdr dummy))))
+
+(define (list-stable-sort less-p lis)
+  (define (sort l r)
+    (cond
+      ((= l r) '())
+      ((= (+ l 1) r) (list (list-ref lis l)))
+      (else
+        (let* ((mid (quotient (+ l r) 2))
+                (l-sorted (sort l mid))
+                (r-sorted (sort mid r)))
+          (list-merge less-p l-sorted r-sorted)))))
+  (sort 0 (length lis)))
+
+(define (list-sort less-p lis)
+  (if (or (null? lis) (null? (cdr lis)))
+      lis
+      (let ((pivot (car lis))
+            (rest (cdr lis)))
+        (let ((smaller (filter (lambda (x) (less-p x pivot)) rest))
+              (larger (filter (lambda (x) (not (less-p x pivot))) rest)))
+          (append (list-sort less-p smaller)
+                  (list pivot)
+                  (list-sort less-p larger))))))
+
+(define (list-sort! less-p lst)
+  ;; 辅助函数：返回列表的最后一个元素
+  (define (last-pair lst)
+    (if (null? (cdr lst))
+        lst
+        (last-pair (cdr lst))))
+  ;; 辅助函数：将列表分成小于和大于 pivot 的部分
+  (define (partition! lst pivot less-p)
+    (let loop ((lst lst) (less '()) (greater '()))
+      (cond
+        ((null? lst) (values (reverse less) (reverse greater)))  ;; 返回小于和大于部分
+        ((less-p (car lst) pivot)
+          (loop (cdr lst) (cons (car lst) less) greater))
+        (else
+          (loop (cdr lst) less (cons (car lst) greater))))))
+  ;; 排序函数：原地排序
+  (if (or (null? lst) (null? (cdr lst)))  ;; 如果列表为空或只有一个元素，已经排序好
+      lst
+      (let* ((pivot (car lst)))
+        (call-with-values 
+          (lambda () (partition! (cdr lst) pivot less-p))  ;; 调用 partition 并返回小于和大于部分
+          (lambda (less greater)
+            ;; 对小于和大于部分递归排序
+            (let ((sorted-less (list-sort! less-p less))
+                  (sorted-greater (list-sort! less-p greater)))
+              ;; 如果 sorted-less 是空，直接返回 sorted-greater
+              (if (null? sorted-less)
+                  sorted-greater
+                  (begin
+                    ;; 原地连接两个部分和 pivot
+                    (set-cdr! (last-pair sorted-less) (cons pivot sorted-greater))
+                    sorted-less))))))))  ;; 返回排序后的列表
+
+(define list-stable-sort!
+  (lambda (less-p lis)
+    (define (split! lis)
+      (let loop ((slow lis) (fast (cdr lis)))
+        (if (or (null? fast) (null? (cdr fast)))
+            (let ((mid (cdr slow)))
+              (set-cdr! slow '())
+              (values lis mid))
+            (loop (cdr slow) (cddr fast)))))
+    (if (or (null? lis) (null? (cdr lis)))
+        lis
+        (let-values (((left right) (split! lis)))
+          (list-merge! less-p
+                      (list-stable-sort! less-p left)
+                      (list-stable-sort! less-p right))))))
+
+(define vector-stable-sort
+  (case-lambda
+    ((less-p v)
+      (list->vector (list-stable-sort less-p (vector->list v))))
+    ((less-p v start)
+      (list->vector (list-stable-sort less-p (subvector->list v start (vector-length v)))))
+    ((less-p v start end)
+      (list->vector (list-stable-sort less-p (subvector->list v start end))))))
+
+(define vector-sort vector-stable-sort)
+
+(define (vector-sort! . r) (???))
+
+(define (vector-stable-sort! . r) (???))
+
+(define (subvector->list v start end)
+  (do ((r '() (cons (vector-ref v p) r))
+        (p start (+ 1 p)))
+    ((>= p end) (reverse r))))
+
+(define vector-merge
+  (case-lambda
+    ((less-p v1 v2)
+      (list->vector (list-merge less-p (vector->list v1) (vector->list v2))))
+    ((less-p v1 v2 start1)
+      (list->vector (list-merge less-p (subvector->list v1 start1 (vector-length v1)) (vector->list v2))))
+    ((less-p v1 v2 start1 end1)
+      (list->vector (list-merge less-p (subvector->list v1 start1 end1) (vector->list v2))))
+    ((less-p v1 v2 start1 end1 start2)
+      (list->vector (list-merge less-p (subvector->list v1 start1 end1) (subvector->list v2 start2 (vector-length v2)))))
+    ((less-p v1 v2 start1 end1 start2 end2)
+      (list->vector (list-merge less-p (subvector->list v1 start1 end1) (subvector->list v2 start2 end2))))))
+
+(define (vector-merge! . r) (???))
+
+
+) ; end of begin
+) ; end of library
+
diff --git a/tests/resources/r7rs/srfi/srfi-133.scm.txt b/tests/resources/r7rs/srfi/srfi-133.scm.txt
new file mode 100644
index 00000000..66accba0
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-133.scm.txt
@@ -0,0 +1,183 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-133)
+(import (liii base))
+(export
+  vector-empty?
+  vector-fold vector-fold-right
+  vector-count
+  vector-any vector-every vector-copy vector-copy!
+  vector-index vector-index-right vector-skip vector-skip-right vector-partition
+  vector-swap! vector-reverse! vector-cumulate reverse-list->vector
+  vector=)
+(begin
+
+(define (vector-empty? v)
+  (when (not (vector? v))
+    (error 'type-error "v is not a vector"))
+  (zero? (vector-length v)))
+
+(define (vector= elt=? . rest)
+  (define compare2vecs
+    (typed-lambda ((cmp procedure?) (vec1 vector?) (vec2 vector?))
+       (let*  ((len1 (vector-length vec1))
+               (len2 (vector-length vec2)))
+         (if (not (= len1 len2)) #f
+             (let loop ((ilhs 0) (irhs 0) (len len1))
+                  (if (= ilhs len) #t
+                      (if (not (cmp (vec1 ilhs) (vec2 irhs))) #f 
+                          (loop (+ 1 ilhs) (+ 1 irhs) len))))))))
+  (when (not (procedure? elt=?)) (error 'type-error "elt=? should be a procedure"))
+  (if (or(null? rest) (= 1 (length rest))) #t
+      (let loop ((vec1 (car rest)) (vec2 (car (cdr rest))) (vrest (cdr (cdr rest))))
+        (let1 rst (compare2vecs elt=? vec1 vec2)
+           (when (not (boolean? rst)) (error 'type-error "elt=> should return bool"))
+           (if (compare2vecs elt=? vec1 vec2)
+               (if (null? vrest) #t
+                   (loop vec2 (car vrest) (cdr vrest)))
+               #f)))))
+(define (vector-fold f initial vec)
+  (let loop ((i 0) (acc initial))
+    (if (< i (vector-length vec))
+        (loop (+ i 1) (f (vector-ref vec i) acc))
+        acc)))
+
+(define (vector-fold-right f initial vec)
+  (let loop ((i (- (vector-length vec) 1)) (acc initial))
+    (if (>= i 0)
+        (loop (- i 1) (f (vector-ref vec i) acc))
+        acc)))
+
+; TODO optional parameters
+(define (vector-count pred v)
+  (let loop ((i 0) (count 0))
+       (cond ((= i (vector-length v)) count)
+             ((pred (vector-ref v i)) 
+              (loop (+ i 1) (+ count 1)))
+             (else (loop (+ i 1) count)))))
+
+; Return a new vector v-rst with same length of input vector vec.
+; Every element of the result is the result the i-th iteration of fn cumu_i vec_i.
+;   Where fn should be a procedure with 2 args.
+;   The type of knil and vector could be different.
+; In the i-th iteration, cumu_i = fn cumu_(i-1) vec_i, with cumu_0 = fn knil vec_0.
+
+(define vector-cumulate
+  (typed-lambda ((fn procedure?) knil (vec vector?))
+    (let* ((len (vector-length vec))
+           (v-rst (make-vector len)))
+      (let loop ((i 0) (lhs knil))
+           (if (= i len)
+               v-rst
+               (let1 cumu-i (fn lhs (vec i))
+                 (begin
+                   (vector-set! v-rst i cumu-i)
+                   (loop (+ 1 i) cumu-i))))))))
+; TODO optional parameters
+(define (vector-any pred v)
+  (let loop ((i 0))
+       (cond ((= i (vector-length v)) #f)
+             ((pred (vector-ref v i)) #t)
+             (else (loop (+ i 1))))))
+
+; TODO optional parameters
+(define (vector-every pred v)
+  (let loop ((i 0))
+       (cond ((= i (vector-length v)) #t)
+             ((not (pred (vector-ref v i))) #f)
+             (else (loop (+ i 1))))))
+
+(define vector-index
+  (typed-lambda ((pred procedure?) (v vector?))
+    (let loop ((i 0))
+       (cond ((= i (vector-length v)) #f)
+             ((pred (vector-ref v i)) i)
+             (else (loop (+ i 1)))))))
+
+(define vector-index-right
+  (typed-lambda ((pred procedure?) (v vector?))
+    (let ((len (vector-length v)))
+      (let loop ((i (- len 1)))
+        (cond ((< i 0) #f)
+               ((pred (vector-ref v i)) i)
+               (else (loop (- i 1))))))))
+
+(define (vector-skip pred v)
+  (vector-index (lambda (x) (not (pred x))) v))
+
+(define (vector-skip-right pred v)
+  (vector-index-right (lambda (x) (not (pred x))) v))
+
+(define (vector-partition pred v)
+  (let* ((len (vector-length v))
+         (cnt (vector-count pred v))
+         (ret (make-vector len)))
+    (let loop ((i 0) (yes 0) (no cnt))
+      (if (= i len)
+        (values ret cnt)
+        (let ((elem (vector-ref v i)))
+          (if (pred elem)
+            (begin
+              (vector-set! ret yes elem)
+              (loop (+ i 1) (+ yes 1) no))
+            (begin
+              (vector-set! ret no elem)
+              (loop (+ i 1) yes (+ no 1)))))))))
+
+(define (vector-swap! vec i j)
+  (let ((elem-i (vector-ref vec i))
+        (elem-j (vector-ref vec j)))
+    (vector-set! vec i elem-j)
+    (vector-set! vec j elem-i)
+    ))
+
+(define (vector-reverse! vec . args)
+  (let* ((args-length (length args))
+        (start (if (null? args) 0 (car args)))  
+        (end  (if (<= args-length 1) 
+                  (vector-length vec)          
+                  (cadr args))))
+
+      (unless (and (< args-length 3) (>= args-length 0))
+        (error 'wrong-number-of-args "#<vector-reverse!>: too many args" args-length))
+      (unless (and (integer? start) (integer? end))
+        (error 'type-error "#<vector-reverse!>: *start* and *end* must be an integer" start end))
+      (when (< start 0)
+        (error 'out-of-range "#<vector-reverse!>: *start* cannot be negative" start))
+      (when (> end (vector-length vec))
+        (error 'out-of-range "#<vector-reverse!>: *end* exceeds vector length" end))
+      (when (> start end)
+        (error 'out-of-range "#<vector-reverse!>: *start* must be less than or equal to *end*" start end))
+    
+    (let loop ((i start) (j (- end 1)))
+      (when (< i j)
+        (vector-swap! vec i j)
+        (loop (+ i 1) (- j 1))))))
+
+; Input a proper-list, return a vector with inversed order elements.
+(define reverse-list->vector
+  (typed-lambda ((lst proper-list?))
+    (let* ((len (length lst)) (v-rst (make-vector len)))
+      (let loop ((l lst) (i (- len 1)))
+        (if (null? l) v-rst
+            (begin
+              (vector-set! v-rst i (car l))
+              (loop (cdr l) (- i 1))))))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-151.scm.txt b/tests/resources/r7rs/srfi/srfi-151.scm.txt
new file mode 100644
index 00000000..f739fcbc
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-151.scm.txt
@@ -0,0 +1,168 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-151)
+(import (liii base))
+(export
+  bitwise-not bitwise-and bitwise-ior bitwise-xor bitwise-eqv bitwise-nor bitwise-nand 
+  bit-count bitwise-orc1 bitwise-orc2 bitwise-andc1 bitwise-andc2
+  arithmetic-shift integer-length bitwise-if
+  bit-set? copy-bit bit-swap any-bit-set? every-bit-set? first-set-bit
+  bit-field bit-field-any? bit-field-every? bit-field-clear bit-field-set
+)
+(begin
+
+(define bitwise-not lognot)
+
+(define bitwise-and logand)
+
+(define bitwise-ior logior)
+
+(define bitwise-xor logxor)
+
+(define (bitwise-eqv a b)
+        (= (bitwise-xor a b) 0))
+
+(define (bitwise-nor a b)  
+        (lognot (bitwise-ior a b)))
+
+(define (bitwise-nand a b)  
+        (lognot (bitwise-and a b)))
+
+(define bit-count 
+  (typed-lambda ((i integer?))
+    (define (bit-count-positive i)
+      (let loop ((n i) (cnt 0))
+        (if (= n 0)
+            cnt
+            (loop (logand n (- n 1)) (+ cnt 1)))))
+
+    (cond ((zero? i) 0)
+          ((positive? i) (bit-count-positive i))
+          (else (bit-count-positive (lognot i))))))
+
+(define (bitwise-orc1 i j)
+  (bitwise-ior (bitwise-not i) j))
+
+(define (bitwise-orc2  i j) 
+  (bitwise-ior i (bitwise-not j)))
+
+(define (bitwise-andc1 i j)  
+  (bitwise-and (bitwise-not i) j))
+
+(define (bitwise-andc2 i j) 
+  (bitwise-and i (bitwise-not j)))
+
+(define arithmetic-shift ash)
+
+(define (integer-length n)
+  (if (zero? n)
+      0
+      (let loop ((value (abs n)) (count 1))
+           (if (<= value 1)
+               count
+               (loop (ash value -1) (+ count 1))))))
+
+(define (bitwise-if mask a b)
+  (bitwise-ior
+   (bitwise-and mask a)
+   (bitwise-and (bitwise-not mask) b)))
+
+(define (bit-set? index n)
+  (cond
+    ((negative? index)
+     (error 'out-of-range "bit-set?: Index cannot be negative" index))
+    ((> index 63)
+     (error 'out-of-range "bit-set?: Index cannot exceed 63" index))
+    ((= index 63)
+     (negative? n))
+    (else
+     (not (zero? (bitwise-and n (arithmetic-shift 1 index)))))))
+
+(define (copy-bit index n boolean)
+  (cond
+    ((negative? index)
+     (error 'out-of-range "copy-bit: Index cannot be negative" index))
+    ((> index 63)
+     (error 'out-of-range "copy-bit: Index cannot exceed 63" index))
+    ((= index 63)
+     (if boolean
+         (bitwise-ior n #x8000000000000000)
+         (bitwise-and n #x7FFFFFFFFFFFFFFF)))
+    (else
+     (if boolean
+         (bitwise-ior n (arithmetic-shift 1 index))
+         (bitwise-and n (bitwise-not (arithmetic-shift 1 index)))))))
+
+(define (bit-swap index1 index2 n)
+ (cond
+  ((or (negative? index1) (negative? index2))
+   (error 'out-of-range "bit-swap: Index cannot be negative" index1 index2))
+  ((or (> index1 63) (> index2 63))
+   (error 'out-of-range "bit-swap: Index cannot exceed 63" index1 index2))
+  (else 
+   (copy-bit index2
+        (copy-bit index1 n (bit-set? index2 n))
+        (bit-set? index1 n)))))
+
+(define (any-bit-set? test-bits n)
+  (not (zero? (bitwise-and test-bits n))))
+
+(define (every-bit-set? test-bits n)
+  (= (bitwise-and test-bits n) test-bits))
+
+(define (first-set-bit n)
+  (if (zero? n)
+      -1
+      (let ((lsb (bitwise-and n (- n))))
+        (- (integer-length lsb) 1))))
+
+(define (bit-field i start end)
+  (let* ((bits (integer-length i)))
+    (if (>= start bits)
+        (error 'out-of-range "bit-field: Start cannot be greater than or equal to the integer length" start)
+        (let* ((end (min end bits))
+               (width (- end start)))
+          (if (<= width 0)
+              0
+              (let ((mask (arithmetic-shift (- (expt 2 width) 1) start)))
+                (arithmetic-shift (bitwise-and i mask) (- start))))))))
+
+(define (bit-field-any? i start end)
+  (not (zero?
+         (bitwise-and
+           (arithmetic-shift i (- start))
+           (- (arithmetic-shift 1 (- end start)) 1)))))
+
+(define (bit-field-every? i start end)
+  (= (bitwise-and (arithmetic-shift i (- start)) 
+                  (- (arithmetic-shift 1 (- end start)) 1)) 
+     (- (arithmetic-shift 1 (- end start)) 1)))
+
+(define (bit-field-clear i start end)
+  (bitwise-and i
+    (bitwise-not
+      (arithmetic-shift
+        (- (arithmetic-shift 1 (- end start)) 1) start))))
+
+(define (bit-field-set i start end)
+  (bitwise-ior i
+    (arithmetic-shift
+       (- (arithmetic-shift 1 (- end start)) 1) start)))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-16.scm.txt b/tests/resources/r7rs/srfi/srfi-16.scm.txt
new file mode 100644
index 00000000..6f159a54
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-16.scm.txt
@@ -0,0 +1,20 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-16)
+  (import (scheme case-lambda))
+  (export case-lambda))
+
diff --git a/tests/resources/r7rs/srfi/srfi-2.scm.txt b/tests/resources/r7rs/srfi/srfi-2.scm.txt
new file mode 100644
index 00000000..8a63b5c6
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-2.scm.txt
@@ -0,0 +1,11 @@
+; 0-clause BSD by Bill Schottstaedt from S7 source repo: s7test.scm
+(define-library (srfi srfi-2)
+(export and-let*)
+(begin
+
+(define-macro (and-let* vars . body)
+  `(let () (and ,@(map (lambda (v) `(define ,@v)) vars) (begin ,@body))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-216.scm.txt b/tests/resources/r7rs/srfi/srfi-216.scm.txt
new file mode 100644
index 00000000..05cb4e45
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-216.scm.txt
@@ -0,0 +1,33 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-216)
+(export true false nil runtime)
+(import (scheme time))
+(begin
+
+(define true #t)
+
+(define false #f)
+
+(define nil '())
+
+(define (runtime)
+  (round (* 1000 (current-second))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-26.scm.txt b/tests/resources/r7rs/srfi/srfi-26.scm.txt
new file mode 100644
index 00000000..e59988c0
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-26.scm.txt
@@ -0,0 +1,70 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-26)
+(export cut cute)
+(import (liii list)
+        (liii error))
+(begin
+
+(define-macro (cut . paras)
+  (letrec*
+    ((slot? (lambda (x) (equal? '<> x)))
+     (more-slot? (lambda (x) (equal? '<...> x)))
+     (slots (filter slot? paras))
+     (more-slots (filter more-slot? paras))
+     (xs (map (lambda (x) (gensym)) slots))
+     (rest (gensym))
+     (parse
+       (lambda (xs paras)
+         (cond
+           ((null? paras) paras)
+           ((not (list? paras)) paras)
+           ((more-slot? (car paras)) `(,rest ,@(parse xs (cdr paras))))
+           ((slot? (car paras)) `(,(car xs) ,@(parse (cdr xs) (cdr paras))))
+           (else `(,(car paras) ,@(parse xs (cdr paras))))))))
+    (cond
+      ((null? more-slots)
+       `(lambda ,xs ,(parse xs paras)))
+      (else
+        (when
+          (or (> (length more-slots) 1)
+              (not (more-slot? (last paras))))
+          (error 'syntax-error "<...> must be the last parameter of cut"))
+        (let ((parsed (parse xs paras)))
+          `(lambda (,@xs . ,rest) (apply ,@parsed)))))))
+
+(define-macro (cute . paras)
+  (letrec*
+    ((slot? (lambda (x) (equal? '<> x)))
+     (more-slot? (lambda (x) (equal? '<...> x)))
+     (exprs (filter (lambda (x) (not (or (slot? x) (more-slot? x))))
+                    paras))
+     (xs (map (lambda (x) (gensym)) exprs))
+     (lets (map list xs exprs))
+     (parse
+       (lambda (xs paras)
+         (cond
+           ((null? paras) paras)
+           ((not (list? paras)) paras)
+           ((not (or (slot? (car paras)) (more-slot? (car paras))))
+            `(,(car xs) ,@(parse (cdr xs) (cdr paras))))
+           (else `(,(car paras) ,@(parse xs (cdr paras))))))))
+    `(let ,lets (cut ,@(parse xs paras)))))
+
+) ; end of begin
+) ; end of library
+
diff --git a/tests/resources/r7rs/srfi/srfi-39.scm.txt b/tests/resources/r7rs/srfi/srfi-39.scm.txt
new file mode 100644
index 00000000..9ad50e3d
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-39.scm.txt
@@ -0,0 +1,35 @@
+; 0-clause BSD
+; Bill Schottstaedt
+; from S7 source repo: r7rs.scm
+
+(define-library (srfi srfi-39)
+(export make-parameter parameterize)
+(begin
+
+;; parameters
+;;   s7 has no built-in parameter objects
+(define* (make-parameter init converter)
+  (let* ((convert (or converter (lambda (x) x)))
+         (old-values ()) ; see below -- this is part of the funclet
+         (value (convert init)))
+    (lambda () value)))
+
+(define-macro (parameterize vars . body)
+  `(dynamic-wind
+       (lambda ()
+         ,@(map (lambda (var)
+                  `(with-let (funclet ,(car var))
+                     (set! old-values (cons value old-values))
+                     (set! value (convert ,(cadr var)))))
+                vars))
+       (lambda () 
+         ,@body)
+       (lambda ()
+         ,@(map (lambda (var)
+                  `(with-let (funclet ,(car var))
+                     (set! value (car old-values))
+                     (set! old-values (cdr old-values))))
+                vars))))
+
+) ; end of begin
+) ; end of define-library
diff --git a/tests/resources/r7rs/srfi/srfi-78.scm.txt b/tests/resources/r7rs/srfi/srfi-78.scm.txt
new file mode 100644
index 00000000..ae14ffb7
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-78.scm.txt
@@ -0,0 +1,165 @@
+; <PLAINTEXT>
+; Copyright (c) 2005-2006 Sebastian Egner.
+; 
+; Permission is hereby granted, free of charge, to any person obtaining
+; a copy of this software and associated documentation files (the
+; ''Software''), to deal in the Software without restriction, including
+; without limitation the rights to use, copy, modify, merge, publish,
+; distribute, sublicense, and/or sell copies of the Software, and to
+; permit persons to whom the Software is furnished to do so, subject to
+; the following conditions:
+; 
+; The above copyright notice and this permission notice shall be
+; included in all copies or substantial portions of the Software.
+; 
+; THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
+; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+; 
+; -----------------------------------------------------------------------
+; 
+; Lightweight testing (reference implementation)
+; ==============================================
+;
+; Sebastian.Egner@philips.com
+; in R5RS + SRFI 23 (error) + SRFI 42 (comprehensions)
+;
+; history of this file:
+;   SE, 25-Oct-2004: first version based on code used in SRFIs 42 and 67
+;   SE, 19-Jan-2006: (arg ...) made optional in check-ec
+;
+; Naming convention "check:<identifier>" is used only internally.
+;
+; Copyright (c) 2024 The Goldfish Scheme Authors
+; Follow the same License as the original one
+
+(define-library (srfi srfi-78)
+(import (liii lang))
+(export check check-set-mode! check-report check-reset!
+        check-passed? check-failed?
+        check:proc)
+(begin
+
+(define check:write display*)
+
+(define check:mode #f)
+
+(define (check-set-mode! mode)
+  (set! check:mode
+        (case mode
+          ((off)           0)
+          ((summary)       1)
+          ((report-failed) 10)
+          ((report)        100)
+          (else (error "unrecognized mode" mode)))))
+
+
+(check-set-mode! 'report)
+
+(define check:correct 0)
+(define check:failed '())
+
+(define (check-reset!)
+  (set! check:correct 0)
+  (set! check:failed '()))
+
+(define (check:add-correct!)
+  (set! check:correct (+ check:correct 1)))
+
+(define (check:add-failed! expression actual-result expected-result)
+  (set! check:failed
+        (cons (list expression actual-result expected-result)
+              check:failed)))
+
+(define (check:report-expression expression)
+  (newline)
+  (check:write expression)
+  (display " => "))
+
+(define (check:report-actual-result actual-result)
+  (check:write actual-result)
+  (display " ; "))
+
+(define (check:report-correct cases)
+  (display "correct")
+  (if (not (= cases 1))
+      (begin (display " (")
+             (display cases)
+             (display " cases checked)")))
+  (newline))
+
+(define (check:report-failed expected-result)
+  (display "*** failed ***")
+  (newline)
+  (display "; expected result: ")
+  (check:write expected-result)
+  (newline))
+
+(define (check-passed? expected-total-count)
+  (and (= (length check:failed) 0)
+       (= check:correct expected-total-count)))
+
+(define (check-failed?)
+  (>= (length check:failed) 1))
+
+(define* (check:proc expression thunk expected-result (equal class=?))
+  (case check:mode
+    ((0) #f)
+    ((1)
+     (let ((actual-result (thunk)))
+       (if (equal actual-result expected-result)
+           (check:add-correct!)
+           (check:add-failed! expression actual-result expected-result))))
+    ((10)
+     (let ((actual-result (thunk)))
+       (if (equal actual-result expected-result)
+           (check:add-correct!)
+           (begin
+             (check:report-expression expression)
+             (check:report-actual-result actual-result)
+             (check:report-failed expected-result)
+             (check:add-failed! expression actual-result expected-result)))))
+    ((100)
+     (check:report-expression expression)
+     (let ((actual-result (thunk)))
+       (check:report-actual-result actual-result)
+       (if (equal actual-result expected-result)
+           (begin (check:report-correct 1)
+                  (check:add-correct!))
+           (begin (check:report-failed expected-result)
+                  (check:add-failed! expression 
+                                     actual-result 
+                                     expected-result)))))
+    (else (error "unrecognized check:mode" check:mode))))
+
+(define-macro (check expr => expected)
+  `(check:proc ',expr (lambda () ,expr) ,expected))
+
+(define (check-report)
+  (if (>= check:mode 1)
+      (begin
+        (newline)
+        (display "; *** checks *** : ")
+        (display check:correct)
+        (display " correct, ")
+        (display (length check:failed))
+        (display " failed.")
+        (if (or (null? check:failed) (<= check:mode 1))
+            (newline)
+            (let* ((w (car (reverse check:failed)))
+                   (expression (car w))
+                   (actual-result (cadr w))
+                   (expected-result (caddr w)))
+              (display " First failed example:")
+              (newline)
+              (check:report-expression expression)
+              (check:report-actual-result actual-result)
+              (check:report-failed expected-result))))))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-8.scm.txt b/tests/resources/r7rs/srfi/srfi-8.scm.txt
new file mode 100644
index 00000000..c8c952ff
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-8.scm.txt
@@ -0,0 +1,28 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-8)
+(export receive)              
+(begin
+
+(define-macro (receive formals expression . body)
+  `(call-with-values
+    (lambda () (values ,expression))
+    (lambda ,formals ,@body)))
+
+) ; end of begin
+) ; end of define-library
+
diff --git a/tests/resources/r7rs/srfi/srfi-9.scm.txt b/tests/resources/r7rs/srfi/srfi-9.scm.txt
new file mode 100644
index 00000000..20b1c647
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-9.scm.txt
@@ -0,0 +1,7 @@
+(define-library (srfi srfi-9)
+(import (scheme base))
+(export define-record-type)
+(begin
+) ; end of begin
+) ; end of define-library
+

From 3cb543e19b6dc41aa1dc55b38951f8ee6f4dcbbc Mon Sep 17 00:00:00 2001
From: VSteveHL <hzq1283014604@163.com>
Date: Tue, 15 Jul 2025 14:59:10 +0800
Subject: [PATCH 2/6] I think the current
 analysis/dependency/rules/library-import.sls is robust enough to handle the
 r7rs situation.

Added two new tests in tests/analysis/dependency/rules/test-library-import.sps
---
 analysis/dependency/rules/library-import.sls         |  2 +-
 .../dependency/rules/test-library-import.sps         | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/analysis/dependency/rules/library-import.sls b/analysis/dependency/rules/library-import.sls
index 7b5763ca..fcdf7a2b 100644
--- a/analysis/dependency/rules/library-import.sls
+++ b/analysis/dependency/rules/library-import.sls
@@ -18,7 +18,7 @@
         [expression (annotation-stripped ann)])
       (match expression
         [('library _ **1 ) (map match-import (index-node-children index-node))]
-        ; [('define-library _ **1 ) (map match-import (index-node-children index-node))]
+        [('define-library _ **1 ) (map match-import (index-node-children index-node))]
         [else (list (match-import index-node))]))))
 
 (define (match-import index-node)
diff --git a/tests/analysis/dependency/rules/test-library-import.sps b/tests/analysis/dependency/rules/test-library-import.sps
index 8270b682..e4106c64 100755
--- a/tests/analysis/dependency/rules/test-library-import.sps
+++ b/tests/analysis/dependency/rules/test-library-import.sps
@@ -28,4 +28,16 @@
         (test-equal '((chezscheme) (srfi :37 args-fold) (scheme-langserver)) (car (map library-import-process root-index-nodes))))
 (test-end)
 
+(test-begin "library-import-process for r7rs liii")
+    (let* ([root-file-node (init-virtual-file-system "./tests/resources/r7rs/liii/rich-vector.scm.txt" '() (lambda (fuzzy) #t) 'r7rs)]
+            [root-index-nodes (document-index-node-list (file-node-document root-file-node))])
+        (test-equal '((liii string) (liii hash-table) (liii sort) (liii list) (liii vector) (liii oop) (srfi srfi-8)) (car (map library-import-process root-index-nodes))))
+(test-end)
+
+(test-begin "library-import-process for r7rs srfi")
+    (let* ([root-file-node (init-virtual-file-system "./tests/resources/r7rs/srfi/sicp.scm.txt" '() (lambda (fuzzy) #t) 'r7rs)]
+            [root-index-nodes (document-index-node-list (file-node-document root-file-node))])
+        (test-equal '((srfi srfi-216)) (car (map library-import-process root-index-nodes))))
+(test-end)
+
 (exit (if (zero? (test-runner-fail-count (test-runner-get))) 0 1))

From 64f2c5303b62b2db2842f16ddbc7444761ffa0d7 Mon Sep 17 00:00:00 2001
From: VSteveHL <hzq1283014604@163.com>
Date: Tue, 15 Jul 2025 15:05:38 +0800
Subject: [PATCH 3/6] remove some files

---
 tests/resources/r7rs/liii/alist.scm.txt       |  52 --
 tests/resources/r7rs/liii/argparse.scm.txt    | 139 ------
 .../resources/r7rs/liii/array-buffer.scm.txt  | 127 -----
 tests/resources/r7rs/liii/base.scm.txt        | 115 -----
 tests/resources/r7rs/liii/base64.scm.txt      | 136 ------
 tests/resources/r7rs/liii/bitwise.scm.txt     |  37 --
 tests/resources/r7rs/liii/case.scm.txt        | 344 -------------
 tests/resources/r7rs/liii/check.scm.txt       |  51 --
 tests/resources/r7rs/liii/chez.scm.txt        |  26 -
 tests/resources/r7rs/liii/comparator.scm.txt  |  35 --
 tests/resources/r7rs/liii/cut.scm.txt         |  20 -
 tests/resources/r7rs/liii/datetime.scm.txt    | 193 --------
 tests/resources/r7rs/liii/either.scm.txt      | 122 -----
 tests/resources/r7rs/liii/error.scm.txt       |  59 ---
 tests/resources/r7rs/liii/hash-table.scm.txt  |  35 --
 tests/resources/r7rs/liii/lang.scm.txt        | 153 ------
 tests/resources/r7rs/liii/list.scm.txt        | 151 ------
 tests/resources/r7rs/liii/logging.scm.txt     | 144 ------
 tests/resources/r7rs/liii/oop.scm.txt         | 440 -----------------
 tests/resources/r7rs/liii/option.scm.txt      |  94 ----
 tests/resources/r7rs/liii/os.scm.txt          | 137 ------
 tests/resources/r7rs/liii/path.scm.txt        | 341 -------------
 tests/resources/r7rs/liii/range.scm.txt       |  90 ----
 tests/resources/r7rs/liii/rich-char.scm.txt   | 179 -------
 .../r7rs/liii/rich-hash-table.scm.txt         | 102 ----
 tests/resources/r7rs/liii/rich-list.scm.txt   | 452 ------------------
 tests/resources/r7rs/liii/rich-string.scm.txt | 348 --------------
 tests/resources/r7rs/liii/set.scm.txt         |  69 ---
 tests/resources/r7rs/liii/sort.scm.txt        |  22 -
 tests/resources/r7rs/liii/stack.scm.txt       |  60 ---
 tests/resources/r7rs/liii/string.scm.txt      |  64 ---
 tests/resources/r7rs/liii/sys.scm.txt         |  28 --
 tests/resources/r7rs/liii/uuid.scm.txt        |  25 -
 tests/resources/r7rs/liii/vector.scm.txt      |  58 ---
 tests/resources/r7rs/srfi/srfi-1.scm.txt      | 355 --------------
 tests/resources/r7rs/srfi/srfi-113.scm.txt    |  29 --
 tests/resources/r7rs/srfi/srfi-125.scm.txt    | 161 -------
 tests/resources/r7rs/srfi/srfi-128.scm.txt    | 376 ---------------
 tests/resources/r7rs/srfi/srfi-13.scm.txt     | 380 ---------------
 tests/resources/r7rs/srfi/srfi-132.scm.txt    | 188 --------
 tests/resources/r7rs/srfi/srfi-133.scm.txt    | 183 -------
 tests/resources/r7rs/srfi/srfi-151.scm.txt    | 168 -------
 tests/resources/r7rs/srfi/srfi-16.scm.txt     |  20 -
 tests/resources/r7rs/srfi/srfi-2.scm.txt      |  11 -
 tests/resources/r7rs/srfi/srfi-216.scm.txt    |  33 --
 tests/resources/r7rs/srfi/srfi-26.scm.txt     |  70 ---
 tests/resources/r7rs/srfi/srfi-39.scm.txt     |  35 --
 tests/resources/r7rs/srfi/srfi-78.scm.txt     | 165 -------
 tests/resources/r7rs/srfi/srfi-8.scm.txt      |  28 --
 tests/resources/r7rs/srfi/srfi-9.scm.txt      |   7 -
 50 files changed, 6657 deletions(-)
 delete mode 100644 tests/resources/r7rs/liii/alist.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/argparse.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/array-buffer.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/base.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/base64.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/bitwise.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/case.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/check.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/chez.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/comparator.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/cut.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/datetime.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/either.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/error.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/hash-table.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/lang.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/list.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/logging.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/oop.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/option.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/os.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/path.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/range.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/rich-char.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/rich-hash-table.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/rich-list.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/rich-string.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/set.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/sort.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/stack.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/string.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/sys.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/uuid.scm.txt
 delete mode 100644 tests/resources/r7rs/liii/vector.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-1.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-113.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-125.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-128.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-13.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-132.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-133.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-151.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-16.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-2.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-216.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-26.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-39.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-78.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-8.scm.txt
 delete mode 100644 tests/resources/r7rs/srfi/srfi-9.scm.txt

diff --git a/tests/resources/r7rs/liii/alist.scm.txt b/tests/resources/r7rs/liii/alist.scm.txt
deleted file mode 100644
index c6743a55..00000000
--- a/tests/resources/r7rs/liii/alist.scm.txt
+++ /dev/null
@@ -1,52 +0,0 @@
-;
-; BSD License by Peter Danenberg
-;
-
-(define-library (liii alist)
-(import (liii base)
-        (liii list)
-        (liii error)
-        (scheme case-lambda))
-(export alist? alist-cons alist-ref alist-ref/default vector->alist)
-(begin
-
-(define (alist? l)
-  (and (list? l)
-       (every pair? l)))
-
-(define alist-ref
-  (case-lambda
-    ((alist key)
-     (alist-ref
-       alist
-       key
-       (lambda () (key-error "alist-ref: key not found " key))))
-    ((alist key thunk)
-     (alist-ref alist key thunk eqv?))
-    ((alist key thunk =)
-     (let ((value (assoc key alist =)))
-       (if value
-           (cdr value)
-           (thunk))))))
-
-(define alist-ref/default
-  (case-lambda
-    ((alist key default)
-     (alist-ref alist key (lambda () default)))
-    ((alist key default =)
-     (alist-ref alist key (lambda () default) =))))
-
-; MIT License
-; Copyright guenchi (c) 2018 - 2019
-(define vector->alist
-  (typed-lambda ((x vector?))
-    (if (zero? (length x)) '()
-        (let loop ((x (vector->list x)) (n 0))
-             (cons (cons n (car x)) 
-                   (if (null? (cdr x))
-                       '()
-                       (loop (cdr x) (+ n 1))))))))
-    
-) ; end of begin
-) ; end of library
-
diff --git a/tests/resources/r7rs/liii/argparse.scm.txt b/tests/resources/r7rs/liii/argparse.scm.txt
deleted file mode 100644
index e4d499aa..00000000
--- a/tests/resources/r7rs/liii/argparse.scm.txt
+++ /dev/null
@@ -1,139 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii argparse)
-(import (liii base)
-        (liii error)
-        (liii list)
-        (liii string)
-        (liii hash-table)
-        (liii alist)
-        (liii sys))
-(export make-argument-parser)
-(begin
-
-(define (make-arg-record name type short-name default)
-  (list name type short-name default default))
-
-(define (convert-value value type)
-  (case type
-    ((number) 
-     (if (number? value)
-         value
-         (let ((num (string->number value)))
-           (if num 
-               num
-               (error "Invalid number format" value)))))
-    ((string) 
-     (if (string? value)
-         value
-         (error "Value is not a string")))
-    (else (error "Unsupported type" type))))
-
-(define (arg-type? type)
-  (unless (symbol? type)
-    (type-error "type of the argument must be symbol"))
-  (member type '(string number)))
-
-(define (%add-argument args-ht args)
-  (let* ((options (car args))
-         (name (alist-ref options 'name
-           (lambda () (value-error "name is required for an option"))))
-         (type (alist-ref/default options 'type 'string))
-         (short-name (alist-ref/default options 'short #f))
-         (default (alist-ref/default options 'default #f))
-         (arg-record (make-arg-record name type short-name default)))
-    (unless (string? name)
-      (type-error "name of the argument must be string"))
-    (unless (arg-type? type)
-      (value-error "Invalid type of the argument" type))
-    (unless (or (not short-name) (string? short-name))
-      (type-error "short name of the argument must be string if given"))
-    (hash-table-set! args-ht name arg-record)
-    (when short-name
-          (hash-table-set! args-ht short-name arg-record))))
-
-(define (%get-argument args-ht args)
-  (let ((found (hash-table-ref/default args-ht (car args) #f)))
-    (if found
-        (fifth found)
-        (error "Argument not found" (car args)))))
-
-(define (long-form? arg)
-  (and (string? arg) 
-       (>= (string-length arg) 3)
-       (string-starts? arg "--")))
-
-(define (short-form? arg)
-  (and (string? arg)
-       (>= (string-length arg) 2)
-       (char=? (string-ref arg 0) #\-)))
-
-(define (retrieve-args args)
-  (if (null? args)
-      (cddr (argv))
-      (car args)))
-
-(define (%parse-args args-ht prog-args)
-  (let loop ((args (retrieve-args prog-args)))
-    (if (null? args)
-        args-ht
-        (let ((arg (car args)))
-          (cond
-            ((long-form? arg)
-             (let* ((name (substring arg 2))
-                    (found (hash-table-ref args-ht name)))
-               (if found
-                   (if (null? (cdr args))
-                       (error "Missing value for argument" name)
-                       (begin
-                         (let ((value (convert-value (cadr args) (cadr found))))
-                           (set-car! (cddddr found) value))
-                         (loop (cddr args))))
-                   (value-error (string-append "Unknown option: --" name)))))
-            
-            ((short-form? arg)
-             (let* ((name (substring arg 1))
-                    (found (hash-table-ref args-ht name)))
-               (if found
-                   (if (null? (cdr args))
-                       (error "Missing value for argument" name)
-                       (begin
-                         (let ((value (convert-value (cadr args) (cadr found))))
-                           (set-car! (cddddr found) value))
-                         (loop (cddr args))))
-                   (value-error (string-append "Unknown option: -" name)))))
-            
-            (else (loop (cdr args))))))))
-
-(define (make-argument-parser)
-  (let ((args-ht (make-hash-table)))
-    (lambda (command . args)
-      (case command
-        ((add) (%add-argument args-ht args))
-        ((add-argument) (%add-argument args-ht args))
-        ((get) (%get-argument args-ht args))
-        ((get-argument) (%get-argument args-ht args))
-        ((parse) (%parse-args args-ht args))
-        ((parse-args) (%parse-args args-ht args))
-        (else
-          (if (and (null? args) (symbol? command))
-              (%get-argument args-ht (list (symbol->string command)))
-              (error "Unknown parser command" command)))))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/array-buffer.scm.txt b/tests/resources/r7rs/liii/array-buffer.scm.txt
deleted file mode 100644
index d48f87b1..00000000
--- a/tests/resources/r7rs/liii/array-buffer.scm.txt
+++ /dev/null
@@ -1,127 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii array-buffer)
-(import (liii lang) (liii error))
-(export array-buffer)
-(begin
-
-(define-case-class array-buffer
-  ((data vector?)
-   (size integer?)
-   (capacity integer?))
-
-(chained-define (@from-vector vec)
-  (let ((len (vector-length vec)))
-    (array-buffer (copy vec) len len)))
-
-(chained-define (@from-list lst)
-  (let ((len (length lst)))
-    (array-buffer (copy lst (make-vector len)) len len)))
-
-(typed-define (check-bound (n integer?))
-  (when (or (< n 0) (>= n size))
-    (index-error
-      ($ "access No." :+ n :+ " of array-buffer [0:" :+ size :+ ")" :get))))
-
-(define (%collect)
-  (copy data (make-vector size)))
-
-(define (%length) size)
-
-(define (%apply n)
-  (check-bound n)
-  (vector-ref data n))
-
-(chained-define (%set! n v)
-  (check-bound n)
-  (vector-set! data n v)
-  (%this))
-
-(define (%update! . args)
-  (apply %set! args))
-
-(chained-define (%extend! n)
-  (when (< capacity n)
-    (if (= capacity 0)
-      (set! capacity n)
-      (let loop ()
-        (when (< capacity n)
-          (set! capacity (* 2 capacity))
-          (loop))))
-    (set! data (copy data (make-vector capacity) 0 size)))
-  (%this))
-
-(define (%size-hint! . args) (apply %extend! args))
-
-(chained-define (%resize! n)
-  (%extend! n)
-  (set! size n)
-  (%this))
-
-(chained-define (%trim-to-size! n)
-  (%extend! n)
-  (set! size n)
-  (when (> capacity (* 2 size))
-    (set! data (copy data (make-vector size)))
-    (set! capacity size))
-  (%this))
-
-(chained-define (%add-one! x)
-  (%extend! (+ size 1))
-  (vector-set! data size x)
-  (set! size (+ size 1))
-  (%this))
-
-(chained-define (%clear!)
-  (set! size 0)
-  (%this))
-
-(chained-define (%clear/shrink!)
-  (set! size 0)
-  (set! capacity 1)
-  (set! data (make-vector 1))
-  (%this))
-
-(chained-define (%insert! index elem)
-  (%extend! (+ size 1))
-  (set! size (+ size 1))
-  (check-bound index)
-  (let loop ((p (- size 1)))
-    (when (> p index)
-      (vector-set! data p (vector-ref data (- p 1)))
-      (loop (- p 1))))
-  (vector-set! data index elem)
-  (%this))
-
-(typed-define (%equals (that case-class?))
-  (and (that :is-instance-of 'array-buffer)
-       ((%to-vector) :equals (that :to-vector))))
-
-(define (%to-vector)
-  (rich-vector (copy data (make-vector size))))
-
-(define (%to-list)
-  (vector->list data 0 size))
-
-(define (%to-rich-list)
-  (box (%to-list)))
-
-) ; end of array-buffer
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/base.scm.txt b/tests/resources/r7rs/liii/base.scm.txt
deleted file mode 100644
index b84faad1..00000000
--- a/tests/resources/r7rs/liii/base.scm.txt
+++ /dev/null
@@ -1,115 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii base)
-(import (scheme base)
-        (srfi srfi-2)
-        (srfi srfi-8))
-(export
-  ; (scheme base) defined by R7RS
-  let-values
-  ; R7RS 5: Program Structure
-  define-values define-record-type
-  ; R7RS 6.2: Numbers
-  square exact inexact max min floor s7-floor ceiling s7-ceiling truncate s7-truncate
-  round s7-round floor-quotient gcd lcm s7-lcm exact-integer-sqrt
-  numerator denominator
-  ; R7RS 6.3: Booleans
-  boolean=?
-  ; R7RS 6.4: list
-  pair? cons car cdr set-car! set-cdr! caar cadr cdar cddr
-  null? list? make-list list length append reverse list-tail
-  list-ref list-set! memq memv member assq assv assoc list-copy
-  ; R7RS 6.5: Symbol
-  symbol? symbol=? string->symbol symbol->string
-  ; R7RS 6.6: Characters
-  digit-value
-  ; R7RS 6.7: String
-  string-copy
-  ; R7RS 6.8 Vector
-  vector->string string->vector vector-copy vector-copy! vector-fill!
-  ; R7RS 6.9 Bytevectors
-  bytevector? make-bytevector bytevector bytevector-length bytevector-u8-ref
-  bytevector-u8-set! bytevector-copy bytevector-append
-  utf8->string string->utf8 u8-string-length u8-substring bytevector-advance-u8
-  ; Input and Output
-  call-with-port port? binary-port? textual-port? input-port-open? output-port-open?
-  open-binary-input-file open-binary-output-file close-port eof-object
-  ; Control flow
-  string-map vector-map string-for-each vector-for-each
-  ; Exception
-  raise guard read-error? file-error?
-  ; SRFI-2
-  and-let*
-  ; SRFI-8
-  receive
-  ; Extra routines
-  loose-car loose-cdr compose identity any?
-  ; Extra structure
-  let1  typed-lambda
-)
-(begin
-
-(define* (u8-substring str (start 0) (end #t))
-  (utf8->string (string->utf8 str start end)))
-
-(define (loose-car pair-or-empty)
-  (if (eq? '() pair-or-empty)
-      '()
-      (car pair-or-empty)))
-
-(define (loose-cdr pair-or-empty)
-  (if (eq? '() pair-or-empty)
-      '()
-      (cdr pair-or-empty)))
-
-(define identity (lambda (x) x))
-
-(define (compose . fs)
-  (if (null? fs)
-      (lambda (x) x)
-      (lambda (x)
-        ((car fs) ((apply compose (cdr fs)) x)))))
-  
-(define (any? x) #t)
-
-(define-macro (let1 name1 value1 . body)
-  `(let ((,name1 ,value1))
-     ,@body))
-
-; 0 clause BSD, from S7 repo stuff.scm
-(define-macro (typed-lambda args . body)
-  ; (typed-lambda ((var [type])...) ...)
-  (if (symbol? args)
-      (apply lambda args body)
-      (let ((new-args (copy args)))
-        (do ((p new-args (cdr p)))
-            ((not (pair? p)))
-          (if (pair? (car p))
-              (set-car! p (caar p))))
-        `(lambda ,new-args
-           ,@(map (lambda (arg)
-                    (if (pair? arg)
-                        `(unless (,(cadr arg) ,(car arg))
-                           (error 'type-error
-                             "~S is not ~S~%" ',(car arg) ',(cadr arg)))
-                        (values)))
-                  args)
-           ,@body))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/base64.scm.txt b/tests/resources/r7rs/liii/base64.scm.txt
deleted file mode 100644
index e51e1550..00000000
--- a/tests/resources/r7rs/liii/base64.scm.txt
+++ /dev/null
@@ -1,136 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii base64)
-(import (liii base)
-        (liii bitwise))
-(export
-  string-base64-encode bytevector-base64-encode base64-encode
-  string-base64-decode bytevector-base64-decode base64-decode
-)
-(begin
-(define-constant BYTE2BASE64_BV
-  (string->utf8 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"))
-
-(define-constant BASE64_PAD_BYTE
-  (char->integer #\=))
-
-(define bytevector-base64-encode
-  (typed-lambda ((bv bytevector?))
-    (define (encode b1 b2 b3)
-      (let* ((p1 b1)
-             (p2 (if b2 b2 0))
-             (p3 (if b3 b3 0))
-             (combined (bitwise-ior (ash p1 16) (ash p2 8) p3))
-             (c1 (bitwise-and (ash combined -18) #x3F))
-             (c2 (bitwise-and (ash combined -12) #x3F))
-             (c3 (bitwise-and (ash combined -6) #x3F))
-             (c4 (bitwise-and combined #x3F)))
-        (values
-          (BYTE2BASE64_BV c1)
-          (BYTE2BASE64_BV c2)
-          (if b2 (BYTE2BASE64_BV c3) BASE64_PAD_BYTE)
-          (if b3 (BYTE2BASE64_BV c4) BASE64_PAD_BYTE))))
-    
-    (let* ((input-N (bytevector-length bv))
-           (output-N (* 4 (ceiling (/ input-N 3))))
-           (output (make-bytevector output-N)))
-      (let loop ((i 0) (j 0))
-        (when (< i input-N)
-          (let* ((b1 (bv i))
-                 (b2 (if (< (+ i 1) input-N) (bv (+ i 1)) #f))
-                 (b3 (if (< (+ i 2) input-N) (bv (+ i 2)) #f)))
-            (receive (r1 r2 r3 r4) (encode b1 b2 b3)
-              (bytevector-u8-set! output j r1)
-              (bytevector-u8-set! output (+ j 1) r2)
-              (bytevector-u8-set! output (+ j 2) r3)
-              (bytevector-u8-set! output (+ j 3) r4)
-              (loop (+ i 3) (+ j 4))))))
-      output)))
-
-(define string-base64-encode
-  (typed-lambda ((str string?))
-    (utf8->string (bytevector-base64-encode (string->utf8 str)))))
-
-(define (base64-encode x)
-  (cond ((string? x)
-         (string-base64-encode x))
-        ((bytevector? x)
-         (bytevector-base64-encode x))
-        (else
-         (type-error "input must be string or bytevector"))))
-
-(define-constant BASE64_TO_BYTE_V
-  (let1 byte2base64-N (bytevector-length BYTE2BASE64_BV)
-    (let loop ((i 0) (v (make-vector 256 -1)))
-      (if (< i byte2base64-N)
-          (begin
-            (vector-set! v (BYTE2BASE64_BV i) i)
-            (loop (+ i 1) v))
-          v))))
-
-(define (bytevector-base64-decode bv)
-  (define (decode c1 c2 c3 c4)
-    (let* ((b1 (BASE64_TO_BYTE_V c1))
-           (b2 (BASE64_TO_BYTE_V c2))
-           (b3 (BASE64_TO_BYTE_V c3))
-           (b4 (BASE64_TO_BYTE_V c4)))
-      (if (or (negative? b1) (negative? b2)
-              (and (negative? b3) (not (equal? c3 BASE64_PAD_BYTE)))
-              (and (negative? b4) (not (equal? c4 BASE64_PAD_BYTE))))
-          (value-error "Invalid base64 input")
-          (values
-            (bitwise-ior (ash b1 2) (ash b2 -4))
-            (bitwise-and (bitwise-ior (ash b2 4) (ash b3 -2)) #xFF)
-            (bitwise-and (bitwise-ior (ash b3 6) b4) #xFF)
-            (if (negative? b3) 1 (if (negative? b4) 2 3))))))
-  
-  (let* ((input-N (bytevector-length bv))
-         (output-N (* input-N 3/4))
-         (output (make-bytevector output-N)))
-
-    (unless (zero? (modulo input-N 4))
-      (value-error "length of the input bytevector must be 4X"))
-    
-    (let loop ((i 0) (j 0))
-      (if (< i input-N)
-          (receive (r1 r2 r3 cnt)
-                   (decode (bv i) (bv (+ i 1)) (bv (+ i 2)) (bv (+ i 3)))
-            (bytevector-u8-set! output j r1)
-            (when (>= cnt 2)
-              (bytevector-u8-set! output (+ j 1) r2))
-            (when (>= cnt 3)
-              (bytevector-u8-set! output (+ j 2) r3))
-            (loop (+ i 4) (+ j cnt)))
-          (let ((final (make-bytevector j)))
-            (vector-copy! final 0 output 0 j)
-            final)))))
-
-(define string-base64-decode
-  (typed-lambda ((str string?))
-    (utf8->string (bytevector-base64-decode (string->utf8 str)))))
-
-(define (base64-decode x)
-  (cond ((string? x)
-         (string-base64-decode x))
-        ((bytevector? x)
-         (bytevector-base64-decode x))
-        (else
-         (type-error "input must be string or bytevector"))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/bitwise.scm.txt b/tests/resources/r7rs/liii/bitwise.scm.txt
deleted file mode 100644
index 370b82e7..00000000
--- a/tests/resources/r7rs/liii/bitwise.scm.txt
+++ /dev/null
@@ -1,37 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii bitwise)
-(import (srfi srfi-151)
-        (liii error))
-(export
-  ; from (srfi srfi-151)
-  bitwise-not bitwise-and bitwise-ior bitwise-xor bitwise-eqv  bitwise-or bitwise-nor bitwise-nand
-  bit-count bitwise-orc1 bitwise-orc2 bitwise-andc1 bitwise-andc2
-  arithmetic-shift integer-length bitwise-if
-  bit-set? copy-bit bit-swap any-bit-set? every-bit-set? first-set-bit
-  bit-field bit-field-any? bit-field-every? bit-field-clear bit-field-set
-  ; S7 built-in
-  lognot logand logior logxor
-  ash
-)
-(begin
-
-(define bitwise-or bitwise-ior)
-
-) ; end of begin
-) ; end of library
-
diff --git a/tests/resources/r7rs/liii/case.scm.txt b/tests/resources/r7rs/liii/case.scm.txt
deleted file mode 100644
index 68e575c5..00000000
--- a/tests/resources/r7rs/liii/case.scm.txt
+++ /dev/null
@@ -1,344 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii case)
-(import (liii base))
-(export case*)
-(begin
-
-; 0 clause BSD, from S7 repo case.scm
-(define case* 
-  (let ((case*-labels (lambda (label)
-      (let ((labels ((funclet ((funclet 'case*) 'case*-helper)) 'labels)))
-        (labels (symbol->string label))))) ; if ellipsis, this has been quoted by case*
-  
-  (case*-match? (lambda* (matchee pattern (e (curlet)))
-      (let ((matcher ((funclet ((funclet 'case*) 'case*-helper)) 'handle-sequence)))
-        (or (equivalent? matchee pattern)
-            (and (or (pair? matchee) 
-               (vector? matchee))
-           (begin
-             (fill! ((funclet ((funclet 'case*) 'case*-helper)) 'labels) #f) ; clear labels
-             ((matcher pattern e) matchee)))))))
-  (case*-helper
-   (with-let (unlet)
-     (define labels (make-hash-table))
-
-     (define (ellipsis? pat)
-       (and (undefined? pat)
-      (or (equal? pat #<...>)
-          (let ((str (object->string pat)))
-      (and (char-position #\: str)
-           (string=? "...>" (substring str (- (length str) 4))))))))
-       
-     (define (ellipsis-pair-position pos pat)
-       (and (pair? pat)
-      (if (ellipsis? (car pat))
-          pos
-          (ellipsis-pair-position (+ pos 1) (cdr pat)))))
-
-     (define (ellipsis-vector-position pat vlen)
-       (let loop ((pos 0))
-         (and (< pos vlen)
-        (if (ellipsis? (pat pos))
-      pos
-      (loop (+ pos 1))))))
-
-     (define (splice-out-ellipsis sel pat pos e)
-       (let ((sel-len (length sel))
-       (new-pat-len (- (length pat) 1))
-       (ellipsis-label (and (not (eq? (pat pos) #<...>))              
-          (let* ((str (object->string (pat pos)))
-                 (colon (char-position #\: str)))
-            (and colon
-                 (substring str 2 colon))))))
-         (let ((func (and (string? ellipsis-label)
-        (let ((comma (char-position #\, ellipsis-label)))
-          (and comma
-               (let ((str (substring ellipsis-label (+ comma 1))))
-           (set! ellipsis-label (substring ellipsis-label 0 comma))
-           (let ((func-val (symbol->value (string->symbol str) e)))
-             (if (undefined? func-val)
-                 (error 'unbound-variable "function ~S is undefined\n" func))
-             (if (not (procedure? func-val))
-                 (error 'wrong-type-arg "~S is not a function\n" func))
-             func-val)))))))
-     (if (pair? pat)
-         (cond ((= pos 0)               ; ellipsis at start of pattern
-          (if ellipsis-label
-        (set! (labels ellipsis-label) 
-              (list 'quote (copy sel (make-list (- sel-len new-pat-len))))))
-          (values (list-tail sel (- sel-len new-pat-len))
-            (cdr pat)
-            (or (not func)
-          (func (cadr (labels ellipsis-label)))))) ; value is (quote ...) and we want the original list here
-         
-         ((= pos new-pat-len)     ; ellipsis at end of pattern
-          (if ellipsis-label
-        (set! (labels ellipsis-label) 
-              (list 'quote (copy sel (make-list (- sel-len pos)) pos))))
-          (values (copy sel (make-list pos))
-            (copy pat (make-list pos))
-            (or (not func) 
-          (func (cadr (labels ellipsis-label))))))
-         
-         (else                    ; ellipsis somewhere in the middle
-          (let ((new-pat (make-list new-pat-len))
-          (new-sel (make-list new-pat-len)))
-            (if ellipsis-label
-          (set! (labels ellipsis-label) 
-          (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))))
-            (copy pat new-pat 0 pos)
-            (copy pat (list-tail new-pat pos) (+ pos 1))
-            (copy sel new-sel 0 pos)
-            (copy sel (list-tail new-sel pos) (- sel-len pos))
-            (values new-sel new-pat
-              (or (not func) 
-            (func (cadr (labels ellipsis-label))))))))
-         
-         (cond ((= pos 0)
-          (if ellipsis-label
-        (set! (labels ellipsis-label) 
-              (list 'quote (copy sel (make-list (- sel-len new-pat-len))))))
-          (values (subvector sel (max 0 (- sel-len new-pat-len)) sel-len) ; was new-pat-len (max 0 (- sel-len new-pat-len))
-            (subvector pat 1 (+ new-pat-len 1))                     ;     new-pat-len 1
-            (or (not func) 
-          (func (cadr (labels ellipsis-label))))))
-         
-         ((= pos new-pat-len)
-          (if ellipsis-label
-        (set! (labels ellipsis-label) 
-              (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))))
-          (values (subvector sel 0 new-pat-len)
-            (subvector pat 0 new-pat-len)
-            (or (not func) 
-          (func (cadr (labels ellipsis-label))))))
-         
-         (else
-          (let ((new-pat (make-vector new-pat-len))
-          (new-sel (make-vector new-pat-len)))
-            (if ellipsis-label
-          (set! (labels ellipsis-label) 
-          (list 'quote (copy sel (make-list (- sel-len new-pat-len)) pos))))
-            (copy pat new-pat 0 pos)
-            (copy pat (subvector new-pat pos new-pat-len) (+ pos 1))       ; (- new-pat-len pos) pos)   copy: (+ pos 1))
-            (copy sel new-sel 0 pos)
-            (copy sel (subvector new-sel pos new-pat-len) (- sel-len pos))
-                                                                           ; (- new-pat-len pos) pos)  copy: (- sel-len pos))
-            (values new-sel new-pat
-              (or (not func) 
-            (cadr (func (labels ellipsis-label))))))))))))
-       
-     (define (handle-regex x) #f)
-     ;(define handle-regex
-     ;  (let ((rg ((*libc* 'regex.make))) ; is this safe?
-     ;  (local-regcomp (*libc* 'regcomp))
-     ;  (local-regerror (*libc* 'regerror))
-     ;  (local-regexec (*libc* 'regexec))
-     ;  (local-regfree (*libc* 'regfree)))
-     ;    (lambda (reg)
-     ;(lambda (x)
-     ;  (and (string? x)
-     ; (let ((res (local-regcomp rg (substring reg 1 (- (length reg) 1)) 0)))
-     ;   (unless (zero? res)
-     ;     (error 'regex-error "~S~%" (local-regerror res rg)))
-     ;   (set! res (local-regexec rg x 0 0))
-     ;   (local-regfree rg)
-     ;   (zero? res)))))))
-
-     (define (undefined->function undef e)   ; handle the pattern descriptor ("undef") of the form #< whatever >, "e" = caller's curlet
-       (let* ((str1 (object->string undef))
-        (str1-end (- (length str1) 1)))
-         (if (not (char=? (str1 str1-end) #\>))
-       (error 'wrong-type-arg "pattern descriptor does not end in '>': ~S\n" str1))
-         (let ((str (substring str1 2 str1-end)))
-     (if (= (length str) 0)                                           ; #<> = accept anything
-         (lambda (x) #t)
-         (let ((colon (char-position #\: str)))
-           (cond (colon                                               ; #<label:...> might be #<label:> or #<label:func>
-            (let ((label (substring str 0 colon))               ; str is label:...
-            (func (substring str (+ colon 1))))           ; func might be ""
-        (cond ((labels label)                             ; see if we already have saved something under this label
-               (lambda (sel)                              ;   if so, return function that will return an error
-           (error 'syntax-error "label ~S is defined twice: old: ~S, new: ~S~%" label (labels label) sel)))
-              
-              ;; otherwise the returned function needs to store the current sel-item under label in labels
-              ((zero? (length func))
-               (lambda (x)
-           (set! (labels label) x)                  ; #<label:>, set label, accept anything
-           #t))
-              
-              ((char=? (func 0) #\")                      ; labelled regex, #<label:"regexp">
-               (lambda (x)
-           (set! (labels label) x)
-           (handle-regex func)))
-              
-              (else                                       ; #<label:func>
-               (let ((func-val (symbol->value (string->symbol func) e)))
-           (if (undefined? func-val)
-               (error 'unbound-variable "function ~S is undefined\n" func)
-               (if (not (procedure? func-val))
-             (error 'wrong-type-arg "~S is not a function\n" func)
-             (lambda (x)                     ; set label and call func
-               (set! (labels label) x)
-               (func-val x)))))))))
-           
-           ;; if no colon either #<label> or #<func> or #<"regexp"> -- label means match its saved expr, func = call func
-           ((char=? (str 0) #\")
-            (handle-regex str))
-           
-           (else                                                ; #<label> or #<func>
-            (let ((saved (labels str)))
-        (if saved                                         ; #<label>
-            (lambda (x) (equivalent? x saved))
-            (symbol->value (string->symbol str) e)))))))))) ; #<func> using curlet=e passed in above
-     
-     (define (handle-pattern sel-item pat-item e)
-       (and (undefined? pat-item)      ; turn #<func> into func and call it on the current selector element
-      (not (eq? pat-item #<undefined>))
-      (let ((func (undefined->function pat-item e)))
-        (if (undefined? func)
-      (error 'unbound-variable "function ~S is undefined\n" pat-item))
-        (if (not (procedure? func))
-      (error 'wrong-type-arg "~S is not a function\n" func))
-        (func sel-item))))
-
-     (define (handle-sequence pat e)
-       (lambda (sel)
-         ;(format *stderr* "~S ~S~%" sel pat)
-         (and (eq? (type-of sel) (type-of pat))
-        (let ((func-ok #t))
-
-          (when (or (pair? pat)                           ; look for ellipsis
-        (vector? pat))
-      (if (pair? (cyclic-sequences pat))
-          (error 'wrong-type-arg "case* pattern is cyclic: ~S~%" pat))
-      (let ((pos (if (pair? pat)
-               (ellipsis-pair-position 0 pat)
-               (ellipsis-vector-position pat (length pat)))))
-        (when (and pos
-             (>= (length sel) (- (length pat) 1))) ; else pat without ellipsis is too long for sel
-          (let ((new-vars (list (splice-out-ellipsis sel pat pos e))))
-            (set! sel (car new-vars))
-            (set! pat (cadr new-vars))
-            (set! func-ok (caddr new-vars))))))
-
-          (and (= (length sel) (length pat))             ; march through selector and current target matching elements
-         func-ok
-         (call-with-exit
-          (lambda (return)
-            (for-each 
-             (lambda (sel-item pat-item)
-         (or (equivalent? sel-item pat-item) ; items match
-
-             (and (or (pair? pat-item)       ; recursive check (* (+ #<symbol?> 1) 2), pat-item: (+ #symbol?> 1)
-                (vector? pat-item))    ; pat-item, not sel-item here so pat-item can cover anything (a list for example)
-            ((handle-sequence pat-item e) sel-item))
-
-             (handle-pattern sel-item pat-item e)
-
-             (return #f)))                   ; else give up (selector does not match target)
-             sel pat)
-            
-            ;; dotted list, check final cdr
-            (unless (or (not (pair? sel)) 
-            (proper-list? sel))
-        (let ((sel-item (list-tail sel (abs (length sel))))
-              (pat-item (list-tail pat (abs (length pat)))))
-          (return (or (equivalent? sel-item pat-item)
-                (handle-pattern sel-item pat-item e)))))
-              
-            #t)))))))
-
-     (define (find-labelled-pattern tree)
-       ;; walk body looking for a labelled pattern
-       (or (undefined? tree)
-     (and (pair? tree)
-          (or (find-labelled-pattern (car tree))
-        (find-labelled-pattern (cdr tree))))
-     (and (vector? tree)
-          (let vector-walker ((pos 0))
-      (and (< pos (length tree))
-           (or (undefined? (tree pos))
-         (and (pair? (tree pos))
-              (find-labelled-pattern (tree pos)))
-         (and (vector? (tree pos))
-              (vector-walker (tree pos)))
-         (vector-walker (+ pos 1))))))))
-
-     (define (handle-body select body return e)
-       (if (null? body)
-     (return select))
-
-       (when (find-labelled-pattern body) ; if labelled, remake the body substituting the labelled-exprs for the labels
-         (set! body (let pair-builder ((tree body))
-          (cond ((undefined? tree)
-           (let ((label (let ((str (object->string tree)))
-              (substring str 2 (- (length str) 1)))))
-             (or (labels label) tree)))
-          
-          ((pair? tree)
-           (cons (pair-builder (car tree))
-           (pair-builder (cdr tree))))
-          
-          ((vector? tree)
-           (vector (map pair-builder tree)))
-          
-          (else tree)))))
-     
-       ;; evaluate the result (case* expands into a call on case*-helper; we need to evaluate the result expressions ourselves)
-       (return (eval (if (null? (cdr body))
-             (car body)
-             (if (eq? (car body) '=>)
-           (list (cadr body) select)
-           (cons 'begin body)))
-         e)))
-    
-     ;; case*-helper
-     (lambda (select clauses e)
-       (call-with-exit
-        (lambda (return)
-    (for-each
-     (lambda (clause)                                        ;((target...) body...)
-       (let ((targets (car clause))
-       (body (cdr clause)))
-         (fill! labels #f)                                   ; clear previous labels
-         (if (memq targets '(else #t))                       ; (else...) or (#t...)
-       (return (eval (cons 'begin body) e))
-       (for-each
-        (lambda (target)
-          (if (or (equivalent? target select)
-            (and (undefined? target)              ; #<...>
-           (not (eq? target #<undefined>))
-           (let ((func (undefined->function target e)))
-             ;(format *stderr* "func: ~S~%" func)
-             ;; (if (undefined? func) (error 'unbound-variable "function ~A is undefined\n" str))
-             ;; not the above check because we want to be able to pass patterns as selectors! (scase37 in s7test)
-             ;;    this seems like a mistake: #<symbol?> won't work? 
-             (and (procedure? func)
-            (func select))))
-            (and (sequence? target)
-           ((handle-sequence target e) select)))
-        (handle-body select body return e)))
-        targets))))
-     clauses)))))))
-    ;; case*
-    (#_macro (selector . clauses)
-      `(((#_funclet 'case*) 'case*-helper) ,selector ',clauses (#_curlet)))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/check.scm.txt b/tests/resources/r7rs/liii/check.scm.txt
deleted file mode 100644
index f9efaf4f..00000000
--- a/tests/resources/r7rs/liii/check.scm.txt
+++ /dev/null
@@ -1,51 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii check)
-(export test check check-set-mode! check:proc
-  check-catch check-report check-failed?
-  check-true check-false)
-(import (srfi srfi-78)
-        (rename (srfi srfi-78)
-                (check-report srfi-78-check-report)))
-(begin
-
-(define-macro (check-true body)
-  `(check ,body => #t))
-
-(define-macro (check-false body)
-  `(check ,body => #f))
-
-(define-macro (check-catch error-id body)
-  `(check
-    (catch ,error-id
-      (lambda () ,body)
-      (lambda args ,error-id))
-      => ,error-id))
-
-(define-macro (test left right)
-  `(check ,left => ,right))
-
-(define (check-report . msg)
-  (if (not (null? msg))
-    (begin
-      (display (car msg))))
-  (srfi-78-check-report)
-  (if (check-failed?) (exit -1)))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/chez.scm.txt b/tests/resources/r7rs/liii/chez.scm.txt
deleted file mode 100644
index f58fe80c..00000000
--- a/tests/resources/r7rs/liii/chez.scm.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii chez)
-(export atom?)
-(begin
-
-(define (atom? x)
-  (not (pair? x)))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/comparator.scm.txt b/tests/resources/r7rs/liii/comparator.scm.txt
deleted file mode 100644
index 393bb99c..00000000
--- a/tests/resources/r7rs/liii/comparator.scm.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii comparator)
-(import (srfi srfi-128))
-(export
-  comparator? comparator-ordered? comparator-hashable?
-  make-comparator make-pair-comparator make-list-comparator
-  make-vector-comparator make-eq-comparator make-eqv-comparator make-equal-comparator
-  boolean-hash char-hash char-ci-hash string-hash string-ci-hash
-  symbol-hash number-hash
-  make-default-comparator default-hash
-  comparator-type-test-predicate comparator-equality-predicate
-  comparator-ordering-predicate comparator-hash-function
-  comparator-test-type comparator-check-type comparator-hash
-  =? <? >? <=? >=?
-)
-(begin
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/cut.scm.txt b/tests/resources/r7rs/liii/cut.scm.txt
deleted file mode 100644
index f8b6e139..00000000
--- a/tests/resources/r7rs/liii/cut.scm.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii cut)
-  (import (srfi srfi-26))
-  (export cut cute))
-
diff --git a/tests/resources/r7rs/liii/datetime.scm.txt b/tests/resources/r7rs/liii/datetime.scm.txt
deleted file mode 100644
index 526af674..00000000
--- a/tests/resources/r7rs/liii/datetime.scm.txt
+++ /dev/null
@@ -1,193 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii datetime)
-(import (liii oop))
-(export datetime date years)
-(begin
-
-(define-object years
-
-(define (@leap? year)
-  (when (not (integer? year))
-    (type-error "years@leap? must accept integer"))
-  (or (and (zero? (modulo year 4)) 
-           (not (zero? (modulo year 100))))
-      (zero? (modulo year 400))))
-
-)
-
-(define-case-class datetime
-  ((year integer?)
-   (month integer?)
-   (day integer?)
-   (hour integer? 0)
-   (minute integer? 0)
-   (second integer? 0)
-   (micro-second integer? 0))
-
-(chained-define (@now)
-  (let ((time-vec (g_datetime-now)))
-    (datetime 
-      :year (vector-ref time-vec 0)
-      :month (vector-ref time-vec 1)
-      :day (vector-ref time-vec 2)
-      :hour (vector-ref time-vec 3)
-      :minute (vector-ref time-vec 4)
-      :second (vector-ref time-vec 5)
-      :micro-second (vector-ref time-vec 6))))
-
-(define (%to-string)
-  (define (pad2 n)  ; 补零到 2 位
-    (if (< n 10)
-        (string-append "0" (number->string n))
-        (number->string n)))
-  (define (pad6 n)  ; 补零到 6 位（微秒）
-    (let ((s (number->string n)))
-      (string-append (make-string (- 6 (string-length s)) #\0) s)))
-  
-  (let ((date-part (string-append (number->string year) "-"
-                                 (pad2 month) "-"
-                                 (pad2 day)))
-        (time-part (string-append (pad2 hour) ":"
-                                 (pad2 minute) ":"
-                                 (pad2 second))))
-    (if (zero? micro-second)
-        (string-append date-part " " time-part)
-        (string-append date-part " " time-part "." (pad6 micro-second)))))
-
-(define (%plus-days days-to-add)
-  
-  (define (days-in-month m y)
-    (cond ((member m '(4 6 9 11)) 30)
-          ((= m 2) (if (years :leap? y) 29 28))
-          (else 31)))
-  
-  (let loop ((y year)
-             (m month)
-             (d day)
-             (remaining-days days-to-add))
-    (cond
-      ;; No more days to add
-      ((zero? remaining-days)
-       (datetime :year y
-                 :month m
-                 :day d
-                 :hour hour
-                 :minute minute
-                 :second second
-                 :micro-second micro-second))
-      
-      ;; Adding days (positive)
-      ((> remaining-days 0)
-       (let ((days-in-current-month (days-in-month m y)))
-         (if (<= (+ d remaining-days) days-in-current-month)
-             ;; Simple case: result is within the same month
-             (loop y m (+ d remaining-days) 0)
-             ;; Complex case: need to move to next month
-             (let ((next-month (if (= m 12) 1 (+ m 1)))
-                   (next-year (if (= m 12) (+ y 1) y)))
-               (loop next-year 
-                     next-month 
-                     1 
-                     (- (+ remaining-days d) days-in-current-month 1))))))
-      
-      ;; Subtracting days (negative)
-      (else
-       (if (> d (abs remaining-days))
-           ;; Simple case: result is within the same month
-           (loop y m (+ d remaining-days) 0)
-           ;; Complex case: need to move to previous month
-           (let* ((prev-month (if (= m 1) 12 (- m 1)))
-                  (prev-year (if (= m 1) (- y 1) y))
-                  (days-in-prev-month (days-in-month prev-month prev-year)))
-             (loop prev-year 
-                   prev-month 
-                   days-in-prev-month 
-                   (+ remaining-days d))))))))
-
-(define (%plus-months months-to-add)
-  (define (days-in-month m y)
-    (cond ((member m '(4 6 9 11)) 30)
-          ((= m 2) (if (years :leap? y) 29 28))
-          (else 31)))
-  
-  ;; Calculate new year and month
-  (let* ((total-months (+ (+ (* year 12) month -1) months-to-add))
-         (new-year (quotient total-months 12))
-         (new-month (+ (remainder total-months 12) 1))
-         ;; Adjust day if necessary
-         (days-in-new-month (days-in-month new-month new-year))
-         (new-day (min day days-in-new-month)))
-    
-    (datetime :year new-year
-              :month new-month
-              :day new-day
-              :hour hour
-              :minute minute
-              :second second
-              :micro-second micro-second)))
-
-(define (%plus-years years-to-add)
-  (define (days-in-month m y)
-    (cond ((member m '(4 6 9 11)) 30)
-          ((= m 2) (if (years :leap? y) 29 28))
-          (else 31)))
-  
-  ;; Calculate new year
-  (let* ((new-year (+ year years-to-add))
-         ;; Adjust day if necessary (for Feb 29 in leap years)
-         (days-in-new-month (days-in-month month new-year))
-         (new-day (min day days-in-new-month)))
-    
-    (datetime :year new-year
-              :month month
-              :day new-day
-              :hour hour
-              :minute minute
-              :second second
-              :micro-second micro-second)))
-
-)
-
-(define-case-class date
-  ((year integer?)
-   (month integer?)
-   (day integer?))
-
-(chained-define (@now)
-  (let ((time-vec (g_date-now)))
-    (date 
-      :year (vector-ref time-vec 0)
-      :month (vector-ref time-vec 1)
-      :day (vector-ref time-vec 2))))
-
-(define (%to-string)
-  (define (pad2 n)  ; 补零到 2 位
-    (if (< n 10)
-        (string-append "0" (number->string n))
-        (number->string n)))
-  
-  (let ((date-part (string-append (number->string year) "-"
-                                  (pad2 month) "-"
-                                  (pad2 day))))
-       date-part))
-
-)
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/either.scm.txt b/tests/resources/r7rs/liii/either.scm.txt
deleted file mode 100644
index cf4f42a1..00000000
--- a/tests/resources/r7rs/liii/either.scm.txt
+++ /dev/null
@@ -1,122 +0,0 @@
-;
-; Copyright (C) 2025 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii either)
-(import (liii option) (liii oop) (liii base))
-(export either left right)
-(begin
-
-(define-case-class either
-  ((type symbol?)
-   (value any?))
-
-(define (%left?)
-  (eq? type 'left))
-
-(define (%right?)
-  (eq? type 'right))
-
-(define (%get)
-  value)
-
-(define (%or-else default)
-  (unless (case-class? default) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %or-else '(default) 'default "case-class" (object->string default))))  
-  
-  (when (not (default :is-instance-of 'either))
-    (type-error "The first parameter of either%or-else must be a either case class"))
-
-  (if (%right?)
-      (%this)
-      default))
-
-(define (%get-or-else default)
-  (cond ((%right?) value)
-        ((and (procedure? default) (not (case-class? default)))
-         (default))
-        (else default)))
-
-(define (%filter-or-else pred zero)
-  (unless (procedure? pred) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %filter-or-else '(pred zero) 'pred "procedure" (object->string pred))))
-  
-  (unless (any? zero) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %filter-or-else '(pred zero) 'zero "any" (object->string zero))))  
-  (if (%right?)
-      (if (pred value)
-          (%this)
-          (left zero))
-      (%this)))
-
-(define (%contains x)
-  (and (%right?)
-       (class=? x value)))
-
-(define (%for-each f)
-  (when (%right?)
-    (f value)))
-
-(define (%to-option)
-  (if (%right?)
-      (option value)
-      (none)))
-
-(define (%map f . args)
-  (chain-apply args
-    (if (%right?)
-      (right (f value))
-      (%this))))
-
-(define (%flat-map f . args)
-  (chain-apply args
-    (if (%right?)
-      (f value)
-      (%this))))
-
-(define (%forall pred)
-  (unless (procedure? pred) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %forall '(pred) 'pred "procedure" (object->string pred))))
-  (if (%right?)
-      (pred value)
-      #t))
-
-(define (%exists pred)
-  (unless (procedure? pred) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %exists '(pred) 'pred "procedure" (object->string pred))))
-  (if (%right?)
-      (pred value)
-      #f))
-
-)
-
-(define (left v)
-  (either 'left v))
-
-(define (right v)
-  (either 'right v))
-
-) ; end of begin
-) ; end of define-library
diff --git a/tests/resources/r7rs/liii/error.scm.txt b/tests/resources/r7rs/liii/error.scm.txt
deleted file mode 100644
index affc2def..00000000
--- a/tests/resources/r7rs/liii/error.scm.txt
+++ /dev/null
@@ -1,59 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-; see https://docs.python.org/3/library/exceptions.html#exception-hierarchy
-(define-library (liii error)
-(export ???
-  os-error file-not-found-error not-a-directory-error file-exists-error
-  timeout-error type-error type-error? key-error value-error index-error)
-(begin
-
-(define (os-error . args)
-  (apply error (cons 'os-error args)))
-
-(define (file-not-found-error . args)
-  (apply error (cons 'file-not-found-error args)))
-
-(define (not-a-directory-error . args)
-  (apply error (cons 'not-a-directory-error args)))
-
-(define (file-exists-error . args)
-  (apply error (cons 'file-exists-error args)))
-
-(define (timeout-error . args)
-  (apply error (cons 'timeout-error args)))
-
-(define (type-error . args)
-  (apply error (cons 'type-error args)))
-
-(define (type-error? err)
-  (not (null? (member err `(type-error wrong-type-arg)))))
-
-(define (key-error . args)
-  (apply error (cons 'key-error args)))
-
-(define (value-error . args)
-  (apply error (cons 'value-error args)))
-
-(define (index-error . args)
-  (apply error (cons 'index-error args)))
-
-(define (??? . args)
-  (apply error (cons '??? args)))
-
-) ; begin
-) ; define-library
-
diff --git a/tests/resources/r7rs/liii/hash-table.scm.txt b/tests/resources/r7rs/liii/hash-table.scm.txt
deleted file mode 100644
index dc2707ac..00000000
--- a/tests/resources/r7rs/liii/hash-table.scm.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii hash-table)
-(import (srfi srfi-125)
-        (srfi srfi-128))
-(export
-  make-hash-table hash-table hash-table-unfold alist->hash-table
-  hash-table? hash-table-contains? hash-table-empty? hash-table=?
-  hash-table-mutable?
-  hash-table-ref hash-table-ref/default
-  hash-table-set! hash-table-delete! hash-table-intern! hash-table-update!
-  hash-table-update!/default hash-table-pop! hash-table-clear!
-  hash-table-size hash-table-keys hash-table-values hash-table-entries
-  hash-table-find hash-table-count
-  hash-table-for-each hash-table-map->list
-  hash-table->alist
-)
-(begin
-) ; end of begin
-) ; end of library
-
diff --git a/tests/resources/r7rs/liii/lang.scm.txt b/tests/resources/r7rs/liii/lang.scm.txt
deleted file mode 100644
index f906ba57..00000000
--- a/tests/resources/r7rs/liii/lang.scm.txt
+++ /dev/null
@@ -1,153 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii lang)
-                
-(import (only (liii base)
-              u8-string-length any? receive u8-substring)
-        (only (liii oop)
-              define-case-class display* @ typed-define case-class? chained-define
-              define-object define-class chain-apply object->string)
-        (only (liii sort) list-stable-sort vector-stable-sort)
-        (only (liii hash-table)
-              hash-table-update!/default hash-table-for-each hash-table-ref/default hash-table-contains? hash-table-delete!
-              hash-table-count)
-        (only (liii bitwise) bitwise-and bitwise-ior arithmetic-shift)
-        (liii error)
-        (liii list)
-        (liii option)
-        (liii either)
-        (liii rich-list)
-        (liii rich-char)
-        (liii rich-vector)
-        (liii rich-string)
-        (liii rich-hash-table))
-
-(export
-  @ typed-define define-case-class define-object define-class
-  case-class? class=? chained-define display* object->string
-  option none either left right
-  rich-integer rich-float rich-char rich-string
-  rich-vector rich-list array rich-hash-table
-  box $
-)
-(begin
-
-(define (class=? left right)
-  (cond
-    ((and (case-class? left) (case-class? right))
-     (left :equals right))
-    ((case-class? left)
-     (left :equals ($ right)))
-    ((case-class? right)
-     ($ left :equals right))
-    (else
-     (equal? left right))))
-
-(define (box x)
-  (cond ((integer? x) (rich-integer x))
-        ((rational? x) (rich-rational x))
-        ((float? x) (rich-float x))
-        ((char? x) (rich-char x))
-        ((string? x) (rich-string x))
-        ((list? x) (rich-list x))
-        ((vector? x) (rich-vector x))
-        ((hash-table? x) (rich-hash-table x))
-        (else (type-error "box: x must be integer?, rational?, float?, char?, string?, list?, vector?, hash-table?"))))
-
-(define ($ x . xs)
-  (if (null? xs) (box x) (apply (box x) xs)))
-
-(define-case-class rich-integer ((data integer?))
-
-(define (%get) data)
-
-(define (%to n) 
-  (unless (integer? n) 
-    (type-error 
-      (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-              %to '(n) 'n "integer" (object->string n))))
-  (if (< n data) 
-    (rich-list (list)) 
-    (rich-list (iota (+ (- n data) 1) data))))
-
-(define (%until n) 
-  (unless (integer? n) 
-    (type-error 
-      (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-              %until '(n) 'n "integer" (object->string n))))
-  (if (<= n data) 
-    (rich-list (list)) 
-    (rich-list (iota (+ (- n data)) data))))
-
-(define (%to-rich-char)
-  (rich-char data))
-
-(define (%to-string)
-  (number->string data))
-
-(define (@max-value) 9223372036854775807)
-
-(define (@min-value) -9223372036854775808)
-
-;;return exact integer
-(define (%sqrt)
-  (if (< data 0)
-      (value-error
-        (format #f "sqrt of negative integer is undefined!         ** Got ~a **" data))
-      (inexact->exact (floor (sqrt data)))))
-
-)
-
-(define-case-class rich-rational ((data rational?))
-
-(define (%get) data)
-
-(define (%abs) 
-  (if (< data 0)
-      (- 0 data)
-      data))
-  
-)
-
-(define-case-class rich-float ((data float?))
-                   
-(define (%get) data)
-
-(define (%abs) 
-  (if (< data 0)
-      (- 0 data)
-      data))
-  
-(define (%to-string)
-  (number->string data))
-
-(define (%sqrt)
-  (if (< data 0)
-      (value-error
-        (format #f "sqrt of negative float is undefined!         ** Got ~a **" data))
-      (sqrt data)))
-
-)
-
-
-(define array rich-vector)
-
-
-
-) ; end of begin
-) ; end of library
-
diff --git a/tests/resources/r7rs/liii/list.scm.txt b/tests/resources/r7rs/liii/list.scm.txt
deleted file mode 100644
index c64f8d69..00000000
--- a/tests/resources/r7rs/liii/list.scm.txt
+++ /dev/null
@@ -1,151 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii list)
-(export
-  ; S7 built-in
-  cons car cdr map for-each
-  ; SRFI 1: Constructors
-  circular-list iota list-copy xcons cons*
-  ; SRFI 1: Predicates
-  null-list? circular-list? proper-list? dotted-list?
-  ; SRFI 1: Selectors
-  first second third fourth fifth sixth seventh eighth ninth tenth
-  take drop take-right drop-right split-at
-  last-pair last
-  ; SRFI 1: Miscellaneous: length, append, concatenate, reverse, zip & count
-  zip count
-  ; SRFI 1: fold, unfold & map
-  fold fold-right reduce reduce-right
-  filter partition remove append-map
-  ; SRFI 1: Searching
-  find any every list-index
-  take-while drop-while
-  ; SRFI 1: Deleting
-  delete
-  ; SRFI 1: Association List
-  assoc assq assv alist-cons
-  ; Liii List extensions
-  flat-map
-  list-null? list-not-null? not-null-list?
-  length=? length>? length>=? flatten
-)
-(import (srfi srfi-1)
-        (srfi srfi-13)
-        (liii error)
-        (liii case)
-        (only (liii oop) define-case-class chain-apply))
-(begin
-
-(define (length=? x scheme-list)
-  (when (not (integer? x))
-    (type-error "length=?: first parameter x must be an integer"))
-  (when (< x 0)
-    (value-error "length=?: expected non-negative integer x but received ~d" x))
-  (cond ((and (= x 0) (null? scheme-list)) #t)
-        ((or (= x 0) (null? scheme-list)) #f)
-        (else (length=? (- x 1) (cdr scheme-list)))))
-
-(define (length>? lst len)
-  (let loop ((lst lst)
-             (cnt 0))
-    (cond ((null? lst) (< len cnt))
-          ((pair? lst) (loop (cdr lst) (+ cnt 1)))
-          (else (< len cnt)))))
-
-(define (length>=? lst len)
-  (let loop ((lst lst)
-             (cnt 0))
-    (cond ((null? lst) (<= len cnt))
-          ((pair? lst) (loop (cdr lst) (+ cnt 1)))
-          (else (<= len cnt)))))
-
-(define flat-map append-map)
-
-(define (not-null-list? l)
-  (cond ((pair? l)
-         (or (null? (cdr l)) (pair? (cdr l))))
-        ((null? l) #f)
-        (else
-         (error 'type-error "type mismatch"))))
-
-(define (list-null? l)
-  (and (not (pair? l)) (null? l)))
-
-(define (list-not-null? l)
-  (and (pair? l)
-       (or (null? (cdr l)) (pair? (cdr l)))))
-
-(define* (flatten lst (depth 1))
-  (define (flatten-depth-iter rest depth res-node)
-    (if (null? rest)
-        res-node
-        (let ((first (car rest))
-              (tail  (cdr rest)))
-          (cond ((and (null? first) (not (= 0 depth)))
-                 (flatten-depth-iter tail depth res-node))
-                ((or (= depth 0) (not (pair? first)))
-                 (set-cdr! res-node (cons first '()))
-                 (flatten-depth-iter tail depth (cdr res-node)))
-                (else
-                 (flatten-depth-iter
-                  tail
-                  depth
-                  (flatten-depth-iter
-                   first
-                   (- depth 1)
-                   res-node)))))))
-  (define (flatten-depth lst depth)
-    (let ((res (cons #f '())))
-      (flatten-depth-iter lst depth res)
-      (cdr res)))
-
-  (define (flatten-deepest-iter rest res-node)
-    (if (null? rest)
-      res-node
-      (let ((first (car rest))
-            (tail  (cdr rest)))
-        (cond ((pair? first)
-               (flatten-deepest-iter
-                tail
-                (flatten-deepest-iter
-                 first
-                 res-node)))
-              ((null? first)
-               (flatten-deepest-iter tail res-node))
-              (else
-               (set-cdr! res-node (cons first '()))
-               (flatten-deepest-iter tail (cdr res-node)))))))
-  (define (flatten-deepest lst)
-    (let ((res (cons #f '())))
-      (flatten-deepest-iter lst res)
-      (cdr res)))
-
-  (cond ((eq? depth 'deepest)
-         (flatten-deepest lst))
-        ((integer? depth)
-         (flatten-depth lst depth))
-        (else
-         (type-error
-          (string-append
-            "flatten: the second argument depth should be symbol "
-            "`deepest' or a integer, which will be uesd as depth,"
-            " but got a ~A") depth)))
-  ) ; end of (define* (flatten))
-
-) ; end of begin
-) ; end of library
-
diff --git a/tests/resources/r7rs/liii/logging.scm.txt b/tests/resources/r7rs/liii/logging.scm.txt
deleted file mode 100644
index 67fe04ae..00000000
--- a/tests/resources/r7rs/liii/logging.scm.txt
+++ /dev/null
@@ -1,144 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii logging)
-(import (liii lang)
-        (liii path)
-        (liii datetime)
-        (liii error))
-(export logging)
-(begin
-
-(define-constant NOTSET 0)
-(define-constant DEBUG 10)
-(define-constant INFO 20)
-(define-constant WARNING 30)
-(define-constant ERROR 40)
-(define-constant CRITICAL 50)
-
-(define loggers-registry (make-hash-table))
-(define-class logging
-  ((name string? "default")
-   (log-path string? "")
-   (level integer? WARNING))
-  
-
-(define (%set-path! p)
-  (cond ((string? p)
-         (set! log-path p))
-        
-        ((path :is-type-of p)
-         (set! log-path (p :to-string)))
-        
-        (else
-         (type-error "path should be a string or path object"))))
-
-(define (%set-level! l)
-  (define (check-valid-level val)
-    (member val '(0 10 20 30 40 50)))
-  
-  (cond ((integer? l) 
-         (if (check-valid-level l)
-             (set! level l)
-             (value-error "invalid level number" l)))
-
-        ((rich-integer :is-type-of l) 
-         (if (check-valid-level (l :get))
-             (set! level (l :get))
-             (value-error "invalid level number" (l :get))))
-
-        (else 
-         (type-error "level should be an integer"))))
-
-(define (@apply p-name)
-  ;; Check if logger with this name already exists in registry
-  (let ((existing-logger (hash-table-ref loggers-registry p-name)))
-    (if (eq? existing-logger #f)
-        ;; If not, create a new logger and store in registry
-        (let ((new-logger (logging)))
-          (new-logger :set-name! p-name)
-          (hash-table-set! loggers-registry p-name new-logger)
-          new-logger)
-        ;; If exists, return existing logger
-        existing-logger)))
-
-(define (format-timestamp)
-  (let ((now (datetime :now)))
-    (now :to-string)))
-
-(define (print-log level-name . args)
-  (let* ((timestamp (format-timestamp))
-         (prefix (string-append timestamp " [" level-name "] " name ": "))
-         (message (apply string-append 
-                         (map (lambda (arg) 
-                                (if (string? arg) 
-                                    arg 
-                                    (arg :get)))
-                              args))))
-    (let ((line (string-append prefix message "\n")))
-      (if (string=? log-path "")
-          (display line)
-          (path-append-text log-path line)))))
-
-(define (%get-level)
-  (cond
-    ((= level 0) "NOTSET")
-    ((= level 10) "DEBUG")
-    ((= level 20) "INFO")
-    ((= level 30) "WARNING")
-    ((= level 40) "ERROR")
-    ((= level 50) "CRITICAL")))
-
-(define (%debug?)
-  (<= level DEBUG))
-
-(define (%info?)
-  (<= level INFO))
-
-(define (%warning?)
-  (<= level WARNING))
-
-(define (%error?)
-  (<= level ERROR))
-
-(define (%critical?)
-  (<= level CRITICAL))
-
-(define (%debug . args)
-  (when (%debug?)
-    (apply print-log "DEBUG" args)))
-
-(define (%info . args)
-  (when (%info?)
-    (apply print-log "INFO" args)))
-
-(define (%warning . args)
-  (when (%warning?)
-    (apply print-log "WARNING" args)))
-
-(define (%error . args)
-  (when (%error?)
-    (apply print-log "ERROR" args)))
-
-(define (%critical . args)
-  (when (%critical?)
-    (apply print-log "CRITICAL" args)))
-
-)
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/oop.scm.txt b/tests/resources/r7rs/liii/oop.scm.txt
deleted file mode 100644
index 254c16cc..00000000
--- a/tests/resources/r7rs/liii/oop.scm.txt
+++ /dev/null
@@ -1,440 +0,0 @@
-;
-; Copyright (C) 2025 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii oop)
-(import (srfi srfi-2) (srfi srfi-1) (liii string))
-(export
-  @ typed-define define-case-class define-object define-class
-  case-class? chained-define display* object->string
-  chain-apply
-)
-(begin
-
-(define-macro (@ . paras)
-  (letrec*
-    (
-      (slot? (lambda (x) (equal? '_ x)))
-      (exprs (filter (lambda (x) (not (slot? x))) paras))
-      (slots (filter slot? paras))
-
-      (exprs-sym-list (map (lambda (x) (gensym)) exprs))  
-      (slots-sym-list (map (lambda (x) (gensym)) slots))
-
-      (lets (map list exprs-sym-list exprs))
-
-      (parse
-        (lambda (exprs-sym-list slots-sym-list paras)
-          (cond
-            ((null? paras) paras)
-            ((not (list? paras)) paras)
-            ((slot? (car paras)) 
-              `(,(car slots-sym-list) 
-                ,@(parse exprs-sym-list (cdr slots-sym-list) (cdr paras))))
-            (else 
-              `(,(car exprs-sym-list) 
-                ,@(parse (cdr exprs-sym-list) slots-sym-list (cdr paras))))))))
-                
-  `(let ,lets 
-        (lambda ,slots-sym-list 
-                ,(parse exprs-sym-list slots-sym-list paras)))))
-
-(define-macro (typed-define name-and-params body . rest)
-  (let* ((name (car name-and-params))
-          (params (cdr name-and-params))
-          (param-names (map car params)))
-
-        `(define* 
-            (,name 
-            ,@(map  
-              (lambda (param)
-                (let  ((param-name (car param))
-                      (type-pred (cadr param))
-                      (default-value (cddr param)))
-                      (if (null? default-value)
-                          param-name
-                          `(,param-name ,(car default-value)))))
-              params))
-
-        ;; Runtime type check                    
-        ,@(map (lambda (param)
-                (let* ((param-name (car param))
-                      (type-pred (cadr param))
-                      ;;remove the '?' in 'type?'
-                      (type-name-str 
-                         (let ((s (symbol->string type-pred)))
-                           (if (and (positive? (string-length s))
-                                    (char=? (string-ref s (- (string-length s) 1)) #\?))
-                               (substring s 0 (- (string-length s) 1))
-                               s))))
-
-                  `(unless 
-                      (,type-pred ,param-name)
-                      (type-error 
-                          (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**"
-                                ,name
-                                ',param-names
-                                ',param-name
-                                ,type-name-str
-                                (object->string ,param-name))))))
-              params)
-       ,body
-       ,@rest)))
-
-(define-macro (define-case-class class-name fields . private-fields-and-methods)
-  (let* ((key-fields
-         (map (lambda (field) (string->symbol (string-append ":" (symbol->string (car field)))))
-              fields))
-        
-         (field-names (map car fields))
-         (field-count (length field-names))
-
-         (private-fields (filter (lambda (x)
-                                   (and (list? x)
-                                        (>= (length x) 2)
-                                        (symbol? (x 1))))
-                                 private-fields-and-methods))
-
-         (methods (filter (lambda (x)
-                            (and (list? x)
-                                 (>= (length x) 2)
-                                 (pair? (x 1))))
-                          private-fields-and-methods))
-         
-         (method-names
-           (map (lambda (method)
-                  (let* ((method-sym (caadr method))
-                         (method-name (symbol->string method-sym)))
-                    (cond
-                      ((string-starts? method-name "@")
-                       (string-remove-prefix method-name "@"))
-                      ((string-starts? method-name "%")
-                       (string-remove-prefix method-name "%"))
-                      (else method-name))))
-                methods))
-         
-         (conflicts-names
-          (filter (lambda (method-name)
-                    (let ((name (string->symbol method-name)))
-                      (member name field-names)))
-                  method-names))
-         
-         (check-conflicts-names (unless (null? conflicts-names)
-              (let ((conflict-str (apply string-append 
-                                        (map (lambda (c) (string-append " <" c ">"))
-                                             conflicts-names))))
-                (error 'syntax-error (string-append "In class ["
-                                          (symbol->string class-name)
-                                          "]: Method name" 
-                                          (if (= (length conflicts-names) 1) "" "s")
-                                          conflict-str
-                                          " conflicts with field name"
-                                          (if (= (length conflicts-names) 1) "" "s"))))))
-         
-         (instance-methods
-          (filter (lambda (method) (string-starts? (symbol->string (caadr method)) "%"))
-                  methods))
-         (instance-method-symbols (map caadr instance-methods))
-         (instance-messages
-          (map (lambda (method)
-                 (let ((name (string-remove-prefix (symbol->string method) "%")))
-                   (string->symbol (string-append ":" name))))
-               instance-method-symbols))
-         (static-methods
-          (filter (lambda (method) (string-starts? (symbol->string (caadr method)) "@"))
-                  methods))
-         (static-method-symbols (map caadr static-methods))
-         (static-messages
-          (map (lambda (method)
-                 (let ((name (string-remove-prefix (symbol->string method) "@")))
-                   (string->symbol (string-append ":" name))))
-               static-method-symbols))
-         ;(default-static-messages '(:is-type-of))
-         (internal-methods
-           (filter (lambda (method) (not (or (string-starts? (symbol->string (caadr method)) "%")
-                                             (string-starts? (symbol->string (caadr method)) "@"))))
-                   methods))
-         (this-symbol (gensym))
-         (f-make-case-class (string->symbol (string-append "make-case-class-" (symbol->string class-name)))))
-
-`(define (,class-name . args)
-
-(define (@is-type-of obj)
-  (and (case-class? obj)
-       (obj :is-instance-of ',class-name)))
-   
-,@static-methods
-
-(define (is-normal-function? msg)
-  (and  (symbol? msg) 
-        (char=? (string-ref (symbol->string msg) 0) #\:)))
-
-(define (static-dispatcher msg . args)
-    (cond
-     ((eq? msg :is-type-of) (apply @is-type-of args))
-     ,@(map (lambda (method expected) `((eq? msg ,expected) (apply ,method args)))
-            static-method-symbols static-messages)
-     (else (value-error "No such static method " msg))))
-
-(define* (,f-make-case-class 
-  ,@(map  
-    (lambda (param)
-      (let  ((param-name (car param))
-            (type-pred (cadr param))
-            (default-value (cddr param)))
-            (if (null? default-value)
-                param-name
-                `(,param-name ,(car default-value)))))
-    fields))
-  ,@(map (lambda (param)
-        (let* ((param-name (car param))
-              (type-pred (cadr param))
-              ;;remove the '?' in 'type?'
-              (type-name-str 
-                  (let ((s (symbol->string type-pred)))
-                    (if (and (positive? (string-length s))
-                            (char=? (string-ref s (- (string-length s) 1)) #\?))
-                        (substring s 0 (- (string-length s) 1))
-                        s))))
-
-          `(unless 
-              (,type-pred ,param-name)
-              (type-error 
-                  (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**"
-                        ,f-make-case-class
-                        ',field-names
-                        ',param-name
-                        ,type-name-str
-                        (object->string ,param-name))))))
-      fields)
-
-  (define ,this-symbol #f)
-  (define (%this . xs)
-    (if (null? xs)
-      ,this-symbol
-      (apply ,this-symbol xs)))
-
-  (define (%is-instance-of x)
-    (eq? x ',class-name))
-         
-  (define (%equals that)
-    (unless (case-class? that) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %equals '(that) 'that "case-class" (object->string that))))
-    (and (that :is-instance-of ',class-name)
-         ,@(map (lambda (field) `(equal? ,(car field) (that ',(car field))))
-                fields)))
-         
-  (define (%apply . args)
-    (cond ((null? args)
-           (value-error ,class-name "Apply on zero args is not implemented"))
-          ((equal? ((symbol->string (car args)) 0) #\:)
-           (value-error ,class-name "No such method: " (car args)))
-          (else (value-error ,class-name "No such field: " (car args)))))
-         
-  (define (%to-string)
-    (let ((field-strings
-           (list ,@(map (lambda (field key-field)
-                          `(string-append
-                            ,(symbol->string key-field) " "
-                            (object->string ,(car field))))
-                        fields key-fields))))
-      (let loop ((strings field-strings)
-                 (acc ""))
-        (if (null? strings)
-            (string-append "(" ,(symbol->string class-name) " " acc ")")
-            (loop (cdr strings)
-                  (if (zero? (string-length acc))
-                      (car strings)
-                      (string-append acc " " (car strings))))))))
-
-  ,@private-fields
-  ,@internal-methods
-  ,@instance-methods
- 
-  (define (instance-dispatcher)
-    (lambda (msg . args)
-      (cond
-        ((eq? msg :is-instance-of) (apply %is-instance-of args))
-        ((eq? msg :equals) (apply %equals args))
-        ((eq? msg :to-string) (%to-string))
-        ((eq? msg :this) (apply %this args))
-        ,@(map (lambda (field key-field)
-            `((eq? msg ,key-field)
-              (,class-name
-              ,@(map (lambda (f) (if (eq? (car f) (car field)) '(car args) (car f)))
-                      fields))))
-          fields key-fields)
-        ((is-normal-function? msg)
-         (case msg
-           ,@(map (lambda (method expected)
-                    `((,expected) (apply ,method args)))
-                  instance-method-symbols instance-messages)
-           (else (value-error ,class-name "No such method: " msg))))
-        ,@(map (lambda (field) `((eq? msg ',(car field)) ,(car field))) fields)
-        (else (apply %apply (cons msg args))))))
-
-  (set! ,this-symbol (instance-dispatcher))
-  ,this-symbol
-) ; end of the internal typed define
-
-(if (null? args)
-    (,f-make-case-class)
-    (let ((msg (car args)))
-      (cond ((member msg (list ,@static-messages :is-type-of))
-             (apply static-dispatcher args))
-            ((and (zero? ,field-count) (member :apply (list ,@static-messages)))
-             (apply static-dispatcher (cons :apply args)))
-            (else
-             (apply ,f-make-case-class args)))))
-
-) ; end of define
-) ; end of let
-) ; end of define-macro
-
-(define-macro (define-object object-name . definitions)
-  (let* ((static-methods (filter (lambda (def)
-                               (and (list? def) (>= (length def) 3)
-                                    (eq? (car def) 'define)
-                                    (list? (cadr def))
-                                    (caadr def)
-                                    (symbol? (caadr def))
-                                    (let ((name-str (symbol->string (caadr def))))
-                                      (and (> (string-length name-str) 0)
-                                           (char=? (string-ref name-str 0) #\@)))))
-                              definitions))
-         (method-infos (map (lambda (def-form)
-                              (let* ((static-name-sym (caadr def-form))
-                                     (static-name-str (symbol->string static-name-sym))
-                                     (method-name-str (substring static-name-str 1 (string-length static-name-str)))
-                                     (dispatch-keyword (string->symbol (string-append ":" method-name-str))))
-                                (list dispatch-keyword static-name-sym)))
-                            static-methods))
-         (varlet-bindings (map (lambda (def-form)
-                                 (let ((defined-sym
-                                         (if (list? (cadr def-form))
-                                             (caadr def-form)
-                                             (cadr def-form))))
-                                   `(varlet (curlet) ',defined-sym ,defined-sym)))
-                               definitions)))
-
-    `(begin
-       (define (,object-name . msgs-and-args)
-         (let ((env (funclet ,object-name)))
-           (if (null? msgs-and-args)
-               (value-error (string-append "Object '" (symbol->string ',object-name) "' called with no arguments"))
-               (let ((msg (car msgs-and-args))
-                     (args (cdr msgs-and-args)))
-                 (cond
-                   ,@(map (lambda (info)
-                            (let ((dispatch-key (car info))
-                                  (static-method-sym (cadr info)))
-                              `((eq? msg ',dispatch-key) (apply (env ',static-method-sym) args))))
-                          method-infos)
-                   (else (value-error (string-append "No such static method '"
-                                                     (if (symbol? msg) (symbol->string msg) (object->string msg))
-                                                     "' in object '" (symbol->string ',object-name) "'"))))))))
-       (with-let (funclet ,object-name)
-         ,@definitions
-         ,@varlet-bindings
-         #t 
-         ))))
-
-(define-macro (define-class class-name private-fields . private-fields-and-methods)
-  (let* ((field-defs '())
-         (getter-defs '())
-         (setter-defs '())
-         
-         ;; generate define, getter, setter
-         (process-fields
-          (map (lambda (field-spec)
-                 (let* ((field-name (car field-spec))
-                        (type-pred (cadr field-spec))
-                        (default-value (if (>= (length field-spec) 3)
-                                          (caddr field-spec)
-                                          ''()))
-                        (getter-name (string->symbol 
-                                      (string-append "%get-" (symbol->string field-name))))
-                        (setter-name (string->symbol 
-                                      (string-append "%set-" (symbol->string field-name) "!"))))
-                   
-                   (set! field-defs 
-                         (cons `(define ,field-name ,default-value) field-defs))
-                   
-                   (set! getter-defs 
-                         (cons `(define (,getter-name) ,field-name) getter-defs))
-                   
-                   (set! setter-defs 
-                         (cons `(typed-define (,setter-name (x ,type-pred))
-                                  (set! ,field-name x))
-                               setter-defs))))
-               private-fields)))
-    
-    `(define-case-class ,class-name ()
-       ;; define
-       ,@(reverse field-defs)
-       
-       ;; Getter
-       ,@(reverse getter-defs)
-       
-       ;; Setter
-       ,@(reverse setter-defs)
-       
-       ;; else
-       ,@private-fields-and-methods)))
-
-(define (case-class? x)
-  (and-let* ((is-proc? (procedure? x))
-             (source (procedure-source x))
-             (source-at-least-3? (and (list? source) (>= (length source) 3)))
-             (body (source 2))
-             (body-at-least-3? (and (list? body) (>= (length body) 3)))
-             (is-cond? (eq? (car body) 'cond))
-             (pred1 ((body 1) 0))
-             (pred2 ((body 2) 0)))
-    (and (equal? pred1 '(eq? msg :is-instance-of))
-         (equal? pred2 '(eq? msg :equals)))))
-
-(define-macro (chained-define head . body)
-  (let ((xs (gensym))
-        (result (gensym)))
-    `(define ,(append head xs)
-       (let ((,result (begin ,@body)))
-         (if (null? ,xs)
-           ,result
-           (apply ,result ,xs))))))
-
-(define (chain-apply args r)
-  (if (null? args)
-      r
-      (apply r args)))
-
-(define (display* . params)
-  (define (%display x)
-    (if (case-class? x)
-        (display (x :to-string))
-        (display x)))
-  (for-each %display params))
-
-(define s7-object->string object->string)
-
-(define (object->string x)
-  (if (case-class? x)
-      (x :to-string)
-      (s7-object->string x)))
-
-) ; end of begin
-) ; end of define-library
diff --git a/tests/resources/r7rs/liii/option.scm.txt b/tests/resources/r7rs/liii/option.scm.txt
deleted file mode 100644
index 3b385298..00000000
--- a/tests/resources/r7rs/liii/option.scm.txt
+++ /dev/null
@@ -1,94 +0,0 @@
-;
-; Copyright (C) 2025 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii option)
-(import (liii oop) (liii base))
-(export option none)
-(begin
-
-(define-case-class option ((value any?))
-
-(define (%get)
-  (if (null? value)
-      (value-error "option is empty, cannot get value")
-      value))
-
-(define (%get-or-else default)
-  (cond ((not (null? value)) value)
-        ((and (procedure? default) (not (case-class? default)))
-         (default))
-        (else default)))
-
-(define (%or-else default . args)
-  (when (not (option :is-type-of default))
-    (type-error "The first parameter of option%or-else must be a option case class"))
-  
-  (chain-apply args
-    (if (null? value)
-        default
-        (option value))))
-
-(define (%equals that)
-  (class=? value (that 'value)))
-
-(define (%defined?) (not (null? value)))
-  
-(define (%empty?)
-  (null? value))
-
-(define (%forall f)
-  (if (null? value)
-      #f
-      (f value)))
-
-(define (%exists f)
-  (if (null? value)
-      #f
-      (f value)))
-
-(define (%contains elem)
-  (if (null? value)
-      #f
-      (equal? value elem)))
-
-(define (%for-each f)
-  (when (not (null? value))
-        (f value)))
-
-(define (%map f . args)
-  (chain-apply args
-    (if (null? value)
-        (option '())
-        (option (f value)))))
-
-(define (%flat-map f . args)
-  (chain-apply args
-    (if (null? value)
-        (option '())
-        (f value))))
-
-(define (%filter pred . args)
-  (chain-apply args
-    (if (or (null? value) (not (pred value)))
-        (option '())
-        (option value))))
-
-)
-
-(define (none) (option '()))
-
-) ; end of begin
-) ; end of define-library
diff --git a/tests/resources/r7rs/liii/os.scm.txt b/tests/resources/r7rs/liii/os.scm.txt
deleted file mode 100644
index cc87f4f9..00000000
--- a/tests/resources/r7rs/liii/os.scm.txt
+++ /dev/null
@@ -1,137 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii os)
-(export
-  os-arch os-type os-windows? os-linux? os-macos? os-temp-dir
-  os-sep pathsep
-  os-call ; system
-  mkdir chdir rmdir remove getenv putenv unsetenv getcwd listdir access getlogin getpid)
-(import (scheme process-context)
-        (liii base)
-        (liii error)
-        (liii string))
-(begin
-
-(define (os-arch)
-  (g_os-arch))
-
-(define (os-type)
-  (g_os-type))
-
-(define (os-linux?)
-  (let ((name (os-type)))
-    (and name (string=? name "Linux"))))
-
-(define (os-macos?)
-  (let ((name (os-type)))
-    (and name (string=? name "Darwin"))))
-
-(define (os-windows?)
-  (let ((name (os-type)))
-    (and name (string=? name "Windows"))))
-
-(define (os-sep)
-  (if (os-windows?)
-    #\\
-    #\/))
-
-(define (pathsep)
-  (if (os-windows?)
-    #\;
-    #\:))
-
-(define (%check-dir-andthen path f)
-  (cond ((not (file-exists? path))
-         (file-not-found-error
-           (string-append "No such file or directory: '" path "'")))
-        ((not (g_isdir path))
-         (not-a-directory-error
-           (string-append "Not a directory: '" path "'")))
-        (else (f path))))
-
-(define (os-call command)
-  (g_os-call command))
-
-(define (system command)
-  (g_system command))
-
-(define (access path mode)
-  (cond ((eq? mode 'F_OK) (g_access path 0))
-        ((eq? mode 'X_OK) (g_access path 128))
-        ((eq? mode 'W_OK) (g_access path 2))
-        ((eq? mode 'R_OK) (g_access path 1))
-        (else (error 'value-error "Allowed mode 'F_OK, 'X_OK,'W_OK, 'R_OK"))))
-
-(define* (getenv key (default #f))
-  (let ((val (get-environment-variable key)))
-    (if val
-        val
-        default)))
-
-(define (putenv key value)
-  (if (and (string? key) (string? value))
-      (g_setenv key value)
-      (error 'type-error "(putenv key value): key and value must be strings")))
-
-(define (unsetenv key)
-  (g_unsetenv key))
-
-(define (os-temp-dir)
-  (let1 temp-dir (g_os-temp-dir)
-    (string-remove-suffix temp-dir (string (os-sep)))))
-
-(define (mkdir path)
-  (if (file-exists? path)
-    (file-exists-error (string-append "File exists: '" path "'"))
-    (g_mkdir path)))
-
-(define (rmdir path)
-  (%check-dir-andthen path g_rmdir))
-
-(define (remove path)
-  (cond
-    ((not (string? path))
-     (error 'type-error "(remove path): path must be string"))
-    ((not (file-exists? path))
-     (error 'file-not-found-error (string-append "File not found: " path)))
-    ((g_isdir path)  ; 检查是否为目录
-     (error 'value-error "Cannot remove a directory (use 'rmdir' instead)"))
-    (else
-     (g_remove-file path))))
-
-(define (chdir path)
-  (if (file-exists? path)
-    (g_chdir path)
-    (file-not-found-error (string-append "No such file or directory: '" path "'"))))
-
-(define (listdir path)
-  (%check-dir-andthen path g_listdir))
-
-(define (getcwd)
-  (g_getcwd))
-
-(define (getlogin)
-  (if (os-windows?)
-      (getenv "USERNAME")
-      (g_getlogin)))
-
-(define (getpid)
-  (g_getpid))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/path.scm.txt b/tests/resources/r7rs/liii/path.scm.txt
deleted file mode 100644
index 8c20ceb6..00000000
--- a/tests/resources/r7rs/liii/path.scm.txt
+++ /dev/null
@@ -1,341 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii path)
-(export
-  path-dir? path-file? path-exists?
-  path-getsize path-read-text path-read-bytes path-write-text path-append-text path-touch
-  path
-)
-(import (liii base) (liii lang) (liii error) (liii vector) (liii string) (liii list)
-        (liii os))
-(begin
-
-(define (path-dir? path)
-  (g_isdir path))
-
-(define (path-file? path)
-  (g_isfile path))
-
-(define (path-exists? path)
-  (file-exists? path))
-
-(define path-getsize
-  (typed-lambda ((path string?))
-    (if (not (file-exists? path))
-      (file-not-found-error
-        (string-append "No such file or directory: '" path "'"))
-      (g_path-getsize path))))
-
-(define path-read-text
-  (typed-lambda ((path string?))
-    (if (not (file-exists? path))
-      (file-not-found-error
-        (string-append "No such file or directory: '" path "'"))
-      (g_path-read-text path))))
-
-(define path-read-bytes
-  (typed-lambda ((path string?))
-    (if (not (file-exists? path))
-      (file-not-found-error
-        (string-append "No such file or directory: '" path "'"))
-      (g_path-read-bytes path))))
-
-(define path-write-text
-  (typed-lambda ((path string?) (content string?))
-    (g_path-write-text path content)))
-
-(define path-append-text
-  (typed-lambda ((path string?) (content string?))
-    (g_path-append-text path content)))
-
-(define (path-touch path)
-  (g_path-touch path))
-
-(define-case-class path ()
-  (define parts #("."))
-  (define type 'posix)
-  (define drive "")
-  
-  (define (%set-parts! v)
-    (if (rich-vector :is-type-of v)
-        (set! parts (v :collect))
-        (set! parts v)))
-  
-  (define (%set-type! s)
-    (set! type s))
-  
-  (define (%set-drive! s)
-    (set! drive s))
-  
-  (define (%get-parts) parts)
-  (define (%get-type) type)
-  (define (%get-drive) drive)
-  
-  (define (%copy)
-    (let1 p (path)
-      (p :set-parts! parts)
-      (p :set-type! type)
-      (p :set-drive! drive)
-      p))
-
-
-(chained-define (@of-drive ch)
-  (when (not (char? ch))
-    (type-error "path@of-drive must take char? as input"))
-    (let1 r (path)
-        (r :set-type! 'windows)
-        (r :set-drive! ($ ch :to-upper :make-string))
-        (r :set-parts! #())
-        r))
-
-(chained-define (@root)
-  (let1 r (path)
-        (r :set-parts! #("/"))
-        r))
-
-(chained-define (@from-parts x) 
-   (let1 r (path)
-     (r :set-parts! x)
-     r))
-
-(chained-define (@/ x) 
-   (if (path :is-type-of x)
-       (path :root :/ x)
-       (cond ((and (string-ends? x ":") (= (string-length x) 2))
-               (path :of-drive (x 0)))
-            
-             ((string=? x "/") (path :root))
-            
-             (else
-               (path :from-parts (vector-append (vector (string (os-sep))) (vector x)))))))
-
-(chained-define (@apply s)
-  (cond ((and (or (os-linux?) (os-macos?))
-              (string-starts? s "/"))
-         (path :/ (@apply ($ s :drop 1 :get))))
-        ((and (os-windows?)
-              (= (string-length s) 2)
-              (char=? (s 1) #\:))
-         (path :of-drive (s 0)))
-        ((and (os-windows?) (>= (string-length s) 3)
-              (char=? (s 1) #\:)
-              (char=? (s 2) #\\))
-         (path :of-drive (s 0)
-               :/ (@apply ($ s :drop 3 :get))))
-        (else
-         (let loop ((iter s))
-           (cond ((or (string-null? iter) (string=? iter "."))
-                  (path))
-                 
-                 ((not (char=? (iter 0) (os-sep)))
-                  (path :from-parts ($ iter :split (string (os-sep)))))
-                 
-                 (else
-                  (loop ($ iter :drop 1 :get))))))))
-
-(chained-define (@from-env name)
-  (path (getenv name)))
-
-(define (%name)
-  (if (string=? "." ($ parts :last))
-      ""
-      ($ parts :last)))
-
-(define (%stem)
-  (define last-part-str 
-    (if (> (vector-length parts) 0)
-        (vector-ref parts (- (vector-length parts) 1))
-        ""))
-  
-  (define (drop-suffix str)
-    (let* ((rich-str ($ str))
-           (rich-splits (rich-str :split "."))  ; 按点分割
-           (count (rich-splits :count)))  ; 获取分割数量
-      (cond ((<= count 1) str)  ; 无后缀或单一部分
-            ((string=? str ".") "")  ; 当前目录特殊处理
-            ((string=? str "..") "..") ; 上级目录特殊处理
-            ((and (string=? (rich-splits 0) "")  ; 以点开头
-                  (= count 2))  ; 且只有一个点（纯隐藏文件）
-             str)  ; 保留完整文件名
-            (else  ; 正常多后缀情况
-             (rich-splits :take (- count 1) :make-string ".")))))
-  
-  (drop-suffix (%name)))
-
-(define (%suffix)
-  (let* ((name (%name))
-         (rich-str ($ name))
-         (rich-splits (rich-str :split "."))
-         (count (rich-splits :count)))
-    (cond ((<= count 1) "")  ; 无后缀
-          ((string=? name ".") "")  ; 当前目录
-          ((string=? name "..") "") ; 上级目录
-          ((and (string=? (rich-splits 0) "")  ; 以点开头
-                (= count 2))  ; 且只有一个点（纯隐藏文件）
-           "")
-          (else 
-           (string-append "." (rich-splits :last))))))  ; 返回最后一部分
-
-(define (%equals that)
-  (if (path :is-type-of that)
-      (string=? (%to-string) (that :to-string))
-      #f))
-
-(define (%file?)
-  (path-file? (%to-string)))
-
-(define (%dir?)
-  (path-dir? (%to-string))) 
-
-(define (%absolute?)
-   (case type
-     ((posix) (string-starts? (parts 0) "/"))
-    
-     ((windows) (not ($ drive :empty?)))
-    
-     (else
-       (value-error
-         (string-append "path%absolute?: unknown type" (symbol->string type))))))
-
-(define (%relative)
-  (not (%absolute?)))
-
-(define (%exists?)
-  (path-exists? (%to-string)))
-
-(define (%to-string)
-  (case type
-    ((posix)
-     (let1 s ($ parts :make-string (string (os-sep)))
-        (if (and (> ($ s :length) 1) (string-starts? s (string (os-sep))))
-            (string-drop s 1)
-            s)))
-    ((windows)
-     (let1 s ($ parts :make-string "\\")
-       (if (string-null? drive)
-           s
-           (string-append drive ":\\" s))))
-    (else (value-error "path%to-string: unknown type" type))))
-
-(define (%read-text)
-  (path-read-text (%to-string)))
-
-(typed-define (%write-text (content string?))
-  (path-write-text (%to-string) content))
-
-(typed-define (%append-text (content string?))
-  (path-append-text (%to-string) content))
-
-(define (%list)
-  (box (listdir (%to-string))))
-
-(define (%list-path)
-  ((box (listdir (%to-string)))
-   :map (lambda (x) ((%this) :/ x))))
-
-(define (%touch)
-  (path-touch (%to-string)))
-
-(chained-define (%/ x)
-  (cond ((string? x)
-         (let1 new-path (%copy)
-            (new-path :set-parts! (vector-append parts (vector x)))
-            new-path))
-        
-        ((path :is-type-of x)
-         (cond ((x :absolute?)
-                (value-error "path to append must not be absolute path: " (x :to-string)))
-               ((string=? (x :to-string) ".")
-                (%this))
-               (else (let ((new-path (%copy))
-                           (x-parts (x :get-parts)))
-                       (if (os-windows?)
-                           (new-path :set-parts! x-parts)
-                           (new-path :set-parts! (vector-append (vector (string (os-sep))) x-parts)))
-                       new-path))))
-        
-        (else (type-error "only string?, path is allowed"))))
-
-(chained-define (%parent)   
-  (define (parts-drop-right parts x)
-     (let1 path-vec ($ parts :drop-right x)
-       (let1 new-path (%copy)
-         (if (path-vec :empty?)
-             (if (os-windows?)
-                 (new-path :set-parts! #(""))
-                 (new-path :set-parts! #(".")))
-             (new-path :set-parts! (path-vec :append #(""))))
-         new-path)))
-                
-  (cond
-    ((or (equal? #("/") parts) (equal? #(".") parts))
-     (%this))
-    ((or (os-macos?) (os-linux?))
-     (let1 last-part (($ parts) :take-right 1 :collect)
-           (if (equal? last-part #(""))
-               (parts-drop-right parts 2)
-               (parts-drop-right parts 1))))
-    ((os-windows?)
-     (if ($ parts :empty?)
-         (%this)
-         (let1 last-part (($ parts) :take-right 1 :collect)
-           (if (equal? last-part #(""))
-               (parts-drop-right parts 2)
-               (parts-drop-right parts 1)))))
-    
-    (else (??? "Unsupported platform"))))
-
-(define (%rmdir)
-  (rmdir (%to-string)))
-
-(define* (%unlink (missing-ok #f))  ; 使用define*定义可选参数
-  (let ((path-str (%to-string)))
-    (cond
-      ((file-exists? path-str)  ; 文件存在时总是删除
-       (remove path-str))
-      (missing-ok  ; 文件不存在时根据missing-ok决定
-       #t)         ; missing-ok为#t时静默返回#t
-      (else        ; missing-ok为#f时抛出错误
-       (error 'file-not-found-error 
-              (string-append "File not found: " path-str))))))
-
-
-(chained-define (@./ x)
-  (let1 p (path x)
-        (if (p :absolute?)
-            (value-error "path@./: only accecpt relative path")
-            (path x))))
-
-(chained-define (@cwd)
-  (path (getcwd)))
-
-(chained-define (@home)
-  (cond ((or (os-linux?) (os-macos?))
-         (path (getenv "HOME")))
-        ((os-windows?)
-         (path :of-drive ((getenv "HOMEDRIVE") 0)
-               :/ (path (getenv "HOMEPATH"))))
-        (else (value-error "path@home: unknown type"))))
-
-(chained-define (@temp-dir)
-  (path (os-temp-dir)))
-
-)
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/range.scm.txt b/tests/resources/r7rs/liii/range.scm.txt
deleted file mode 100644
index e8725f8f..00000000
--- a/tests/resources/r7rs/liii/range.scm.txt
+++ /dev/null
@@ -1,90 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii range)
-(import (liii oop) 
-        (liii rich-list)
-        (liii error)) 
-(export range)
-(begin
-
-(define-case-class range
-  ((start integer?) (end integer?) (step integer? 1) (inclusive? boolean? #f))
-
-(define* (@inclusive start end (step 1))
-  (range start end step #t))
-
-(define (check-step)
-  (when (zero? step)
-      (value-error "step can't be zero")))
-
-(define (in-range? x)
-  (or (and (> step 0) (if inclusive? (and (<= x end) (>= x start)) (and (< x end) (>= x start))))
-      (and (< step 0) (if inclusive? (and (>= x end) (<= x start)) (and (> x end) (<= x start))))))
-
-(define (not-in-range? x)
-  (or (and (> step 0) (or (> x end) (< x start)))
-      (and (< step 0) (or (< x end) (> x start)))
-      (and (= x end) (not inclusive?))))
-
-(define (%empty?)
-  (check-step)
-  (or (and (> start end) (> step 0))
-      (and (< start end) (< step 0))
-      (and (= start end) (not inclusive?))))
-
-(define (%map map-func)
-  (if (%empty?)
-      (rich-list :empty)
-      (let loop ((current start) (result '()))
-        (if (not-in-range? current)
-            (rich-list (reverse result))
-            (loop (+ current step)
-                  (cons (map-func current) result))))))
-
-(define (%for-each proc)
-  (when (not (%empty?))
-    (let loop ((current start))
-         (when (in-range? current)
-               (proc current)
-               (loop (+ current step))))))
-
-(define (%filter f)
-  (if (%empty?)
-      (rich-list :empty)
-      (let loop ((i start) (return '()))
-        (if (not-in-range? i)
-            (rich-list (reverse return))
-            (loop (+ i step)
-                  (if (f i)
-                      (cons i return)
-                       return))))))
-
-(define (%contains elem)
-  (check-step)
-  (if (%empty?)
-      #f
-      (if (in-range? elem) ;判断是否在范围内
-          (zero? (modulo (- elem start) (abs step)))
-          #f)))
-
-           
-           
-
-) ; define-case-cass
-) ; begin
-) ; define-library
-
diff --git a/tests/resources/r7rs/liii/rich-char.scm.txt b/tests/resources/r7rs/liii/rich-char.scm.txt
deleted file mode 100644
index 6a895aaa..00000000
--- a/tests/resources/r7rs/liii/rich-char.scm.txt
+++ /dev/null
@@ -1,179 +0,0 @@
-;
-; Copyright (C) 2025 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii rich-char)
-(import (liii oop) (liii bitwise) (liii base) (liii string))
-(export rich-char)
-(begin
-
-(define-case-class rich-char ((data any?))
-  
-(define code-point
-  (cond ((char? data)
-         (char->integer data))
-        ((integer? data)
-         (if (and (>= data 0) (<= data #x10FFFF))
-             data
-             (value-error "rich-char: code point out of range" data)))
-        (else
-         (type-error "rich-char: only accept char and integer"))))
-
-(define (%equals that)
-  (cond ((char? that)
-         (= code-point (char->integer that)))
-        ((rich-char :is-type-of that)
-         (= code-point (that :to-integer)))
-        (else #f)))
-
-(define (%ascii?)
-  (and (>= code-point 0) (<= code-point 127)))
-
-
-(define (%numeric?)
-  (if (and (>= code-point 0) (<= code-point 255))
-      (let ((ch (integer->char code-point)))
-        (char-numeric? ch))
-      #f))
-
-(define (%upper?)
-  (and (>= code-point #x41) (<= code-point #x5A)))
-
-(define (%lower?)
-  (and (>= code-point #x61) (<= code-point #x7A)))
-
-(define (%digit?)
-  (or
-   (and (>= code-point 48) (<= code-point 57))
-   (and (>= code-point #xFF10) (<= code-point #xFF19))
-   (and (>= code-point #x0660) (<= code-point #x0669))
-   (and (>= code-point #x06F0) (<= code-point #x06F9))
-   (and (>= code-point #x0966) (<= code-point #x096F))
-   (and (>= code-point #x09E6) (<= code-point #x09EF))
-   (and (>= code-point #x0A66) (<= code-point #x0A6F))
-   (and (>= code-point #x0AE6) (<= code-point #x0AEF))
-   (and (>= code-point #x0B66) (<= code-point #x0B6F))
-   (and (>= code-point #x0BE6) (<= code-point #x0BEF))
-   (and (>= code-point #x0C66) (<= code-point #x0C6F))
-   (and (>= code-point #x0CE6) (<= code-point #x0CEF))
-   (and (>= code-point #x0D66) (<= code-point #x0D6F))
-   (and (>= code-point #x0E50) (<= code-point #x0E59))
-   (and (>= code-point #x0ED0) (<= code-point #x0ED9))
-   (and (>= code-point #x0F20) (<= code-point #x0F29))
-   (and (>= code-point #x1040) (<= code-point #x1049))
-   (and (>= code-point #x17E0) (<= code-point #x17E9))
-   (and (>= code-point #x1810) (<= code-point #x1819))))
-  
-(define (%to-upper . args)
-  (chain-apply args
-    (rich-char
-      (if (and (>= code-point #x61) (<= code-point #x7A))
-          (bitwise-and code-point #b11011111)
-          code-point))))
-
-(define (%to-lower . args)
-  (chain-apply args
-    (rich-char
-      (if (and (>= code-point #x41) (<= code-point #x5A))
-          (bitwise-ior code-point #b00100000)
-          code-point))))
-
-(define (%to-bytevector)
-  (cond
-    ((<= code-point #x7F)
-     (bytevector code-point))
-
-    ((<= code-point #x7FF)
-     (let ((byte1 (bitwise-ior #b11000000 (bitwise-and (arithmetic-shift code-point -6) #b00011111)))
-           (byte2 (bitwise-ior #b10000000 (bitwise-and code-point #b00111111))))
-       (bytevector byte1 byte2)))
-
-    ((<= code-point #xFFFF)
-     (let ((byte1 (bitwise-ior #b11100000 (bitwise-and (arithmetic-shift code-point -12) #b00001111)))
-           (byte2 (bitwise-ior #b10000000 (bitwise-and (arithmetic-shift code-point -6) #b00111111)))
-           (byte3 (bitwise-ior #b10000000 (bitwise-and code-point #b00111111))))
-       (bytevector byte1 byte2 byte3)))
-
-    ((<= code-point #x10FFFF)
-     (let ((byte1 (bitwise-ior #b11110000 (bitwise-and (arithmetic-shift code-point -18) #b00000111)))
-           (byte2 (bitwise-ior #b10000000 (bitwise-and (arithmetic-shift code-point -12) #b00111111)))
-           (byte3 (bitwise-ior #b10000000 (bitwise-and (arithmetic-shift code-point -6) #b00111111)))
-           (byte4 (bitwise-ior #b10000000 (bitwise-and code-point #b00111111))))
-       (bytevector byte1 byte2 byte3 byte4)))
-
-    (else
-     (value-error "Invalid code point"))))
-
-(define (@from-bytevector x)
-  (define (utf8-byte-sequence->code-point byte-seq)
-    (let ((len (bytevector-length byte-seq)))
-      (cond
-        ((= len 1)
-         (bytevector-u8-ref byte-seq 0))
-        ((= len 2)
-         (let ((b1 (bytevector-u8-ref byte-seq 0))
-               (b2 (bytevector-u8-ref byte-seq 1)))
-           (bitwise-ior
-            (arithmetic-shift (bitwise-and b1 #x1F) 6)
-            (bitwise-and b2 #x3F))))
-        ((= len 3)
-         (let ((b1 (bytevector-u8-ref byte-seq 0))
-               (b2 (bytevector-u8-ref byte-seq 1))
-               (b3 (bytevector-u8-ref byte-seq 2)))
-           (bitwise-ior
-            (arithmetic-shift (bitwise-and b1 #x0F) 12)
-            (arithmetic-shift (bitwise-and b2 #x3F) 6)
-            (bitwise-and b3 #x3F))))
-        ((= len 4)
-         (let ((b1 (bytevector-u8-ref byte-seq 0))
-               (b2 (bytevector-u8-ref byte-seq 1))
-               (b3 (bytevector-u8-ref byte-seq 2))
-               (b4 (bytevector-u8-ref byte-seq 3)))
-           (bitwise-ior
-           (arithmetic-shift (bitwise-and b1 #x07) 18)
-           (arithmetic-shift (bitwise-and b2 #x3F) 12)
-           (arithmetic-shift (bitwise-and b3 #x3F) 6)
-           (bitwise-and b4 #x3F))))
-        (else
-         (value-error "Invalid UTF-8 byte sequence length")))))
-
-  (rich-char (utf8-byte-sequence->code-point x)))
-
-(define (%to-string)
-  (if (%ascii?)
-      (object->string (integer->char code-point))
-      (string-append "#\\" (utf8->string (%to-bytevector)))))
-
-(define (@from-string x)
-  (when (not (string-starts? x "#\\"))
-    (value-error "char@from-string: the input must start with #\\"))
-  (if (= 1 ($ x :drop 2 :length))
-      (rich-char :from-bytevector (string->utf8 ($ x :drop 2 :get)))
-      (value-error "rich-char: must be u8 string which length equals 1")))
-
-(define (%make-string)
-  (utf8->string (%to-bytevector)))
-
-(define (@from-integer x . args)
-  (chain-apply args
-    (rich-char x)))
-
-(define (%to-integer)
-  code-point)
-
-)
-
-) ; end of begin
-) ; end of define-library
\ No newline at end of file
diff --git a/tests/resources/r7rs/liii/rich-hash-table.scm.txt b/tests/resources/r7rs/liii/rich-hash-table.scm.txt
deleted file mode 100644
index 1bf0262a..00000000
--- a/tests/resources/r7rs/liii/rich-hash-table.scm.txt
+++ /dev/null
@@ -1,102 +0,0 @@
-;
-; Copyright (C) 2025 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii rich-hash-table)
-(import (liii hash-table) (liii oop) (srfi srfi-8))
-(export rich-hash-table)
-(begin
-
-(define-case-class rich-hash-table ((data hash-table?))
-  (define (%collect) data)
-
-(chained-define (@empty)
-  (rich-hash-table (make-hash-table)))
-
-(define (%find pred?)
-  (define iter (make-iterator data))
-  (let loop ((kv (iter)))
-    (cond 
-        ((eof-object? kv) (none))
-        ((and (pair? kv) (pred? (car kv) (cdr kv))) (option kv))
-        (else (loop (iter))))))
-
-(define (%get k)
-  (option (hash-table-ref/default data k '())))
-
-(define (%remove k)
-  (rich-hash-table
-   (let ((new (make-hash-table)))
-     (hash-table-for-each
-      (lambda (key val)
-       (unless (equal? key k)
-        (hash-table-set! new key val)))
-       data)
-      new)))
-
-(chained-define (%remove! k)
-  (hash-table-delete! data k)
-  %this)
-
-(define (%contains k)
-  (hash-table-contains? data k))
-
-(define (%forall pred?)
-  (let ((all-kv (map identity data)))
-    (let loop ((kvs all-kv))  
-      (if (null? kvs)
-          #t  
-          (let ((kv (car kvs)))
-            (if (pred? (car kv) (cdr kv))
-                (loop (cdr kvs))  
-                #f))))))  
-
-(define (%exists pred?)
-  (define iter (make-iterator data))
-  (let loop ((kv (iter)))
-    (cond 
-        ((eof-object? kv) #f)
-        ((and (pair? kv) (pred? (car kv) (cdr kv))) #t)
-        (else (loop (iter))))))
-
-(define (%map f . args)
-  (chain-apply args
-    (let ((r (make-hash-table)))
-      (hash-table-for-each
-         (lambda (k v)
-           (receive (k1 v1) (f k v)
-             (hash-table-set! r k1 v1)))
-         data)
-      (rich-hash-table r))))
-
-(define (%count pred)
-  (hash-table-count pred data))
-
-(define (%for-each proc)
-  (hash-table-for-each proc data))
-
-(define (%filter f . args)
-  (chain-apply args
-    (let ((r (make-hash-table)))
-      (hash-table-for-each
-         (lambda (k v)
-           (when (f k v) (hash-table-set! r k v)))
-         data)
-      (rich-hash-table r))))
-
-) ; end of define-case-class
-
-) ; end of begin
-) ; end of define-library
diff --git a/tests/resources/r7rs/liii/rich-list.scm.txt b/tests/resources/r7rs/liii/rich-list.scm.txt
deleted file mode 100644
index b7bb84f6..00000000
--- a/tests/resources/r7rs/liii/rich-list.scm.txt
+++ /dev/null
@@ -1,452 +0,0 @@
-(define-library (liii rich-list)
-(import (liii list)
-        (liii oop)
-        (liii sort)
-        (liii hash-table)
-        (liii string)
-        (liii option)
-        (srfi srfi-8))
-(export rich-list)
-(begin
-
-
-(define-case-class rich-list ((data list?))
-
-(define (@range start end . step-and-args)
-  (chain-apply (if (null? step-and-args) 
-                   step-and-args 
-                   (if (number? (car step-and-args))
-                       (cdr step-and-args)
-                       step-and-args))
-    (let ((step-size 
-            (if (null? step-and-args) 
-                1
-                (if (number? (car step-and-args))
-                    (car step-and-args)
-                    1))))
-      (cond
-        ((and (positive? step-size) (>= start end))
-         (rich-list '()))
-        ((and (negative? step-size) (<= start end))
-         (rich-list '()))
-        ((zero? step-size)
-         (value-error "Step size cannot be zero"))
-        (else
-         (let ((cnt (ceiling (/ (- end start) step-size))))
-           (rich-list (iota cnt start step-size))))))))
-
-(define (@empty . args)
-  (chain-apply args
-    (rich-list (list ))))
-
-(define (@concat lst1 lst2 . args)
-  (chain-apply args
-    (rich-list (append (lst1 :collect) (lst2 :collect)))))
-
-(define (@fill n elem)
-  (cond
-    ((< n 0)
-      (value-error "n cannot be negative"))
-    ((= n 0)
-      (rich-list '()))
-    (else
-      (rich-list (make-list n elem)))))
-
-(define (%collect) data)
-
-(define (%apply n)
-  (list-ref data n))
-
-(define (%find pred)
-  (let loop ((lst data))
-    (cond
-      ((null? lst) (none))
-      ((pred (car lst)) (option (car lst)))
-      (else (loop (cdr lst))))))
-
-(define (%find-last pred)
-  (let ((reversed-list (reverse data)))  ; 先反转列表
-    (let loop ((lst reversed-list))
-      (cond
-        ((null? lst) (none))  ; 遍历完未找到
-        ((pred (car lst)) (option (car lst)))  ; 找到第一个匹配项（即原列表最后一个）
-        (else (loop (cdr lst)))))))  ; 继续查找
-
-(define (%head)
-  (if (null? data)
-      (error 'out-of-range "rich-list%head: list is empty")
-      (car data)))
-
-(define (%head-option)
-  (if (null? data)
-      (none)
-      (option (car data))))
-
-
-(define (%last)
-  (if (null? data)
-      (index-error "rich-list%last: empty list")
-      (car (reverse data))))
-
-(define (%last-option)
-  (if (null? data)
-      (none)
-      (option (car (reverse data)))))
-
-(define (%slice from until . args)
-  (chain-apply args
-    (let* ((len (length data))
-          (start (max 0 (min from len)))
-          (end (max 0 (min until len))))
-      (if (< start end)
-          (rich-list (take (drop data start) (- end start)))
-          (rich-list '())))))
-
-(define (%empty?)
-  (null? data))
-
-(define (%equals that)
-  (let* ((l1 data)
-         (l2 (that 'data))
-         (len1 (length l1))
-         (len2 (length l2)))
-    (if (not (eq? len1 len2))
-        #f
-        (let loop ((left l1) (right l2))
-          (cond ((null? left) #t)
-                ((not (class=? (car left) (car right))) #f)
-                (else (loop (cdr left) (cdr right))))))))
-
-(define (%forall pred)
-  (every pred data))
-
-(define (%exists pred)
-  (any pred data))
-
-(define (%contains elem)
-  (%exists (lambda (x) (equal? x elem))))
-
-(define (%map x . args)
-  (chain-apply args
-    (rich-list (map x data))))
-
-(define (%flat-map x . args)
-  (chain-apply args
-    (rich-list (flat-map x data))))
-
-(define (%filter x . args)
-  (chain-apply args
-    (rich-list (filter x data))))
-
-(define (%for-each x)
-  (for-each x data))
-
-(define (%reverse . args)
-  (chain-apply args
-    (rich-list (reverse data))))
-    
-(define (%take x . args)
-  (chain-apply args
-    (begin 
-      (define (scala-take data n)
-        (unless (list? data) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-take '(data n) 'data "list" (object->string data))))
-        (unless (integer? n) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-take '(data n) 'n "integer" (object->string n))))
-      
-        (cond ((< n 0) '())
-              ((>= n (length data)) data)
-              (else (take data n))))
-    
-      (rich-list (scala-take data x)))))
-
-(define (%drop x . args)
-  (chain-apply args
-    (begin 
-      (define (scala-drop data n)
-        (unless (list? data) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-drop '(data n) 'data "list" (object->string data))))
-        (unless (integer? n) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-drop '(data n) 'n "integer" (object->string n))))
-      
-        (cond ((< n 0) data)
-              ((>= n (length data)) '())
-              (else (drop data n))))
-    
-      (rich-list (scala-drop data x)))))
-
-(define (%take-right x . args)
-  (chain-apply args
-    (begin 
-      (define (scala-take-right data n)
-        (unless (list? data) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-take-right '(data n) 'data "list" (object->string data))))
-        (unless (integer? n) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-take-right '(data n) 'n "integer" (object->string n))))
-      
-        (cond ((< n 0) '())
-              ((>= n (length data)) data)
-              (else (take-right data n))))
-    
-      (rich-list (scala-take-right data x)))))
-
-(define (%drop-right x . args)
-  (chain-apply args
-    (begin 
-      (define (scala-drop-right data n)
-        (unless (list? data) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-drop-right '(data n) 'data "list" (object->string data))))
-        (unless (integer? n) 
-            (type-error 
-               (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                              scala-drop-right '(data n) 'n "integer" (object->string n))))
-      
-        (cond ((< n 0) data)
-              ((>= n (length data)) '())
-              (else (drop-right data n))))
-    
-      (rich-list (scala-drop-right data x)))))
-
-(define (%count . xs)
-  (cond ((null? xs) (length data))
-        ((length=? 1 xs) (count (car xs) data))
-        (else (error 'wrong-number-of-args "rich-list%count" xs))))
-
-(define (%length)
-  (length data))
-
-(define (%fold initial f)
-  (fold f initial data))
-
-(define (%fold-right initial f)
-  (fold-right f initial data))
-
-(define (%sort-with less-p . args)
-  (chain-apply args
-    (let ((sorted-data (list-stable-sort less-p data)))
-        (rich-list sorted-data))))
-
-(define (%sort-by f . args)
-  (chain-apply args
-    (let ((sorted-data (list-stable-sort (lambda (x y) (< (f x) (f y))) data)))
-    (rich-list sorted-data))))
-
-(define (%group-by func)
-  (let ((group (make-hash-table)))
-    (for-each
-      (lambda (elem) 
-        (let ((key (func elem)))
-          (hash-table-update!/default
-            group
-            key
-            (lambda (current-list) (cons elem current-list))
-            '())))
-      data)
-    (hash-table-for-each 
-      (lambda (k v) (hash-table-set! group k (reverse v))) 
-      group)
-  (rich-hash-table group)))
-
-(define (%sliding size . step-arg)
-  (unless (integer? size) (type-error "rich-list%sliding: size must be an integer " size))
-  (unless (> size 0) (value-error "rich-list%sliding: size must be a positive integer " size))
-
-  (let ((N (length data)))
-    (if (null? data)
-        #()
-        (let* ((is-single-arg-case (null? step-arg))
-               (step (if is-single-arg-case 1 (car step-arg))))
-
-          (when (and (not is-single-arg-case)
-                     (or (not (integer? step)) (<= step 0)))
-            (if (not (integer? step))
-                (type-error "rich-list%sliding: step must be an integer " step)
-                (value-error "rich-list%sliding: step must be a positive integer " step)))
-          
-          (if (and is-single-arg-case (< N size))
-              (vector data)
-              (let collect-windows ((current-list-segment data) (result-windows '()))
-                (cond
-                  ((null? current-list-segment) (list->vector (reverse result-windows)))
-                  ((and is-single-arg-case (< (length current-list-segment) size))
-                   (list->vector (reverse result-windows)))
-                  (else
-                   (let* ((elements-to-take (if is-single-arg-case
-                                                size
-                                                (min size (length current-list-segment))))
-                          (current-window (take current-list-segment elements-to-take))
-                          (next-list-segment (if (>= step (length current-list-segment))
-                                                 '()
-                                                 (drop current-list-segment step))))
-                     (collect-windows next-list-segment
-                                      (cons current-window result-windows)))))))))))
-
-(define (%zip l . args)
-  (chain-apply args
-    (rich-list (apply map cons (list data l)))))
-
-(define (%zip-with-index . args)
-  (chain-apply args
-    (let loop ((lst data) (idx 0) (result '()))
-      (if (null? lst)
-          (rich-list (reverse result))  
-          (loop (cdr lst) 
-                (+ idx 1) 
-                (cons (cons idx (car lst)) result))))))
-
-(define (%distinct . args)
-  (chain-apply args
-    (let loop
-      ((result '()) 
-      (data data) 
-      (ht (make-hash-table)))
-      (cond
-        ((null? data) (rich-list (reverse result)))  
-        (else
-         (let ((elem (car data)))
-           (if (eq? (hash-table-ref ht elem) #f) 
-               (begin
-                 (hash-table-set! ht elem #t)  
-                 (loop (cons elem result) (cdr data) ht))
-               (loop result (cdr data) ht))))))))
-
-(define (%reduce f)
-  (if (null? data)
-      (value-error "rich-list%reduce: empty list is not allowed to reduce")
-      (reduce f '() data)))
-
-(define (%reduce-option f)
-  (if (null? data)
-      (none)
-      (option (reduce f '() data))))
-
-(define (%take-while pred . args)
-  (chain-apply args
-    (let ((result (take-while pred data)))
-      (rich-list result))))
-
-(define (%drop-while pred . args)
-  (chain-apply args
-    (let ((result (drop-while pred data)))
-      (rich-list result))))
-
-(define (%index-where pred)
-  (list-index pred data))
-
-(define (%max-by f)
-  (unless (procedure? f) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %max-by '(f) 'f "procedure" (object->string f))))              
-  (if (null? data)
-      (value-error "rich-list%max-by: empty list is not allowed")
-      (let loop ((rest (cdr data))
-                 (max-elem (car data))
-                 (max-val (let ((val (f (car data))))
-                           (unless (real? val)
-                             (type-error "rich-list%max-by: procedure must return real number but got"
-                                        (object->string val)))
-                           val)))
-        (if (null? rest)
-            max-elem
-            (let* ((current (car rest))
-                   (current-val (let ((val (f current)))
-                                 (unless (real? val)
-                                   (type-error "rich-list%max-by: procedure must return real number but got"
-                                              (object->string val)))
-                                 val)))
-              (if (> current-val max-val)
-                  (loop (cdr rest) current current-val)
-                  (loop (cdr rest) max-elem max-val)))))))
-
-(define (%min-by f)
-  (unless (procedure? f) 
-      (type-error 
-        (format #f "In funtion #<~a ~a>: argument *~a* must be *~a*!    **Got ~a**" 
-                    %min-by '(f) 'f "procedure" (object->string f))))              
-  (if (null? data)
-      (value-error "rich-list%min-by: empty list is not allowed")
-      (let loop ((rest (cdr data))
-                 (min-elem (car data))
-                 (min-val (let ((val (f (car data))))
-                            (unless (real? val)
-                              (type-error "rich-list%min-by: procedure must return real number but got"
-                                         (object->string val)))
-                            val)))
-        (if (null? rest)
-            min-elem
-            (let* ((current (car rest))
-                   (current-val (let ((val (f current)))
-                                  (unless (real? val)
-                                    (type-error "rich-list%min-by: procedure must return real number but got"
-                                               (object->string val)))
-                                  val)))
-              (if (< current-val min-val)
-                  (loop (cdr rest) current current-val)
-                  (loop (cdr rest) min-elem min-val)))))))
-
-(define (%append l)
-  (rich-list (append data l)))
-
-(define (%max-by-option f)
-  (if (null? data)
-      (none)
-      (option (%max-by f))))
-
-(define (%min-by-option f)
-  (if (null? data)
-      (none)
-      (option (%min-by f))))
-
-(define (%to-string)
-  (object->string data))
-
-(define (%make-string . xs)
-  (define (parse-args xs)
-    (cond
-      ((null? xs) (values "" "" ""))
-      ((length=? 1 xs)
-       (let ((sep (car xs)))
-         (if (string? sep)
-             (values "" sep "")
-             (type-error "rich-list%make-string: separator must be a string" sep))))
-      ((length=? 2 xs)
-       (error 'wrong-number-of-args "rich-list%make-string: expected 0, 1, or 3 arguments, but got 2" xs))
-      ((length=? 3 xs)
-       (let ((start (car xs))
-             (sep (cadr xs))
-             (end (caddr xs)))
-         (if (and (string? start) (string? sep) (string? end))
-             (values start sep end)
-             (error 'type-error "rich-list%make-string: prefix, separator, and suffix must be strings" xs))))
-      (else (error 'wrong-number-of-args "rich-list%make-string: expected 0, 1, or 3 arguments" xs))))
-
-  (receive (start sep end) (parse-args xs)
-    (let ((as-string (lambda (x) (if (string? x) x (object->string x)))))
-      (string-append start (string-join (map as-string data) sep) end))))
-
-(define (%to-vector)
-  (list->vector data))
-
-(define (%to-rich-vector)
-  (rich-vector (list->vector data)))
-
-) ; end of define-case-class rich-list
-
-
-) ; end of begin
-) ; end of define-library
diff --git a/tests/resources/r7rs/liii/rich-string.scm.txt b/tests/resources/r7rs/liii/rich-string.scm.txt
deleted file mode 100644
index 16d311eb..00000000
--- a/tests/resources/r7rs/liii/rich-string.scm.txt
+++ /dev/null
@@ -1,348 +0,0 @@
-;
-; Copyright (C) 2025 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii rich-string)
-(import (liii string)
-        (liii oop)
-        (liii base)
-        (liii rich-char)
-        (liii rich-vector)
-        (liii vector))
-(export rich-string)
-(begin
-
-(define-case-class rich-string
-  ((data string?))
-  
-(define N (u8-string-length data))
-
-(define (@empty . args)
-  (chain-apply args (rich-string "")))
-
-(define (@value-of v . args)
-  (chain-apply args
-    (cond ((char? v) (rich-string (string v)))
-          ((number? v) (rich-string (number->string v)))
-          ((symbol? v) (rich-string (symbol->string v)))
-          ((string? v) (rich-string v))
-          ((rich-char :is-type-of v)
-           (rich-string (v :make-string)))
-          (else (type-error "Expected types are char, rich-char, number, symbol or string")))))
-
-(define (%get) data)
-
-(define (%length)
-  N)
-
-(define (%char-at index)
-  (when (not (integer? index))
-    (type-error "rich-string%char-at: index must be integer" index))
-
-  (let* ((start index)
-         (end (+ index 1))
-         (byte-seq (string->utf8 data start end)))
-    (rich-char :from-bytevector byte-seq)))
-
-(define (%apply i)
-  (%char-at i))
-
-(define (%find pred) ((%to-rich-vector) :find pred))
-
-(define (%find-last pred) ((%to-rich-vector) :find-last pred))
-
-(define (%head)
-  (if (string-null? data)
-      (index-error "rich-string%head: string is empty")
-      ($ data 0)))
-
-(define (%head-option)
-  (if (string-null? data)
-      (none)
-      (option ($ data 0))))
-
-(define (%last)
-  (if (string-null? data)
-      (index-error "rich-string%last: string is empty")
-      ($ data (- N 1))))
-
-(define (%last-option)
-  (if (string-null? data)
-      (none)
-      (option ($ data (- N 1)))))
-
-(define (%slice from until . args)
-  (chain-apply args
-    (let* ((start (max 0 from))
-           (end (min N until)))
-      (cond ((and (zero? start) (= end N))
-             (%this))
-            ((>= start end)
-             (rich-string :empty))
-            (else
-             (rich-string (u8-substring data start end)))))))
-
-(define (%take n . args)
-  (chain-apply args
-    (%slice 0 n)))
-
-(define (%take-right n . args)
-  (chain-apply args
-    (%slice (- N n) N)))
-
-(define (%drop n . args)
-  (chain-apply args
-    (%slice n N)))
-
-(define (%drop-right n . args)
-  (chain-apply args
-    (%slice 0 (- N n))))
-
-(define (%empty?)
-  (string-null? data))
-
-(define (%starts-with prefix)
-  (string-starts? data prefix))
-
-(define (%ends-with suffix)
-  (string-ends? data suffix))
-
-(define (%forall pred)
-  ((%to-rich-vector) :forall pred))
-
-(define (%exists pred)
-  ((%to-rich-vector) :exists pred))
-
-(define (%contains elem)
-  (cond ((rich-string :is-type-of elem)
-         (string-contains data (elem :get)))
-    
-        ((string? elem)
-         (string-contains data elem))
-        
-        ((rich-char :is-type-of elem)
-         (string-contains data (elem :make-string)))
-        
-        ((char? elem)
-         (string-contains data (string elem)))
-        
-        (else (type-error "elem must be char or string"))))
-
-(define* (%index-of str/char (start-index 0))
-  (define (bytes-match? data-bv data-pos str-bv str-size data-size)
-    (let loop ((i 0))
-      (if (>= i str-size)
-          #t
-          (and (< (+ data-pos i) data-size)
-               (= (bytevector-u8-ref data-bv (+ data-pos i))
-                  (bytevector-u8-ref str-bv i))
-               (loop (+ i 1))))))
-
-  (define (char-index->byte-pos bv size char-index)
-    (let loop ((i 0) (pos 0))
-      (if (>= i char-index)
-          pos
-          (loop (+ i 1) (bytevector-advance-u8 bv pos size)))))
-  
-  (define* (inner-index-of str start-index)
-    (if (or (string-null? data) (string-null? str))
-        -1
-        (let* ((data-bv (string->utf8 data))
-               (str-bv (string->utf8 str))
-               (data-size (bytevector-length data-bv))
-               (str-size (bytevector-length str-bv)))
-          (if (or (negative? start-index)
-                  (>= start-index N))
-              -1
-              (let ((start-byte-pos (char-index->byte-pos data-bv data-size start-index)))
-                (let search ((byte-pos start-byte-pos) (current-char-index start-index))
-                  (cond
-                    ((> (+ byte-pos str-size) data-size) -1)
-                    ((bytes-match? data-bv byte-pos str-bv str-size data-size)
-                     current-char-index)
-                    (else
-                     (search (bytevector-advance-u8 data-bv byte-pos data-size)
-                             (+ current-char-index 1))))))))))
-
-  (unless (integer? start-index)
-    (type-error "rich-string%index-of: the second parameter must be integer"))
-  
-  (let ((positive-start-index (max 0 start-index)))
-    (cond ((string? str/char)
-           (inner-index-of str/char positive-start-index))
-          ((rich-string :is-type-of str/char)
-           (inner-index-of (str/char :get) positive-start-index))
-          ((char? str/char)
-           (inner-index-of (string str/char) positive-start-index))
-          ((rich-char :is-type-of str/char)
-           (inner-index-of (str/char :make-string) positive-start-index))
-          (else (type-error "rich-string%index-of: first parameter must be string/rich-string/char/rich-char")))))
-
-(define (%map f . args)
-  (chain-apply args
-    (rich-string ((%to-rich-vector)
-                  :map f
-                  :map (lambda (x) (x :make-string))
-                  :make-string))))
-
-(define (%filter pred . args)
-  (chain-apply args
-    (rich-string ((%to-rich-vector)
-                  :filter pred
-                  :map (lambda (x) (x :make-string))
-                  :make-string))))
-
-(define (%reverse . args)
-  (chain-apply args
-    (rich-string ((%to-rich-vector)
-                  :reverse
-                  :map (lambda (x) (x :make-string))
-                  :make-string))))
-
-(define (%for-each f)
-  ((%to-rich-vector) :for-each f))
-
-(define (%count pred?)
-  ((%to-rich-vector) :count pred?))
-
-(define (%index-where pred)
-  (let ((bytes (string->utf8 data))
-        (len (bytevector-length (string->utf8 data))))
-    (let loop ((byte-pos 0) (char-index 0))
-      (cond
-        ((>= byte-pos len) -1)
-        (else
-         (let* ((next-pos (bytevector-advance-u8 bytes byte-pos len))
-                (char-bytes (bytevector-copy bytes byte-pos next-pos))
-                (char (rich-char :from-bytevector char-bytes)))
-           (if (pred char)
-               char-index
-               (loop next-pos (+ char-index 1)))))))))
-
-(define (%take-while pred . args)
-  (chain-apply args
-    (let ((stop-index (%index-where (lambda (c) (not (pred c))))))
-      (if (= stop-index -1)
-          (%this)
-          (%slice 0 stop-index)))))
-
-(define (%drop-while pred . args)
-  (chain-apply args
-    (let ((index (%index-where (lambda (c) (not (pred c))))))
-      (if (= index -1)
-          (rich-string "")
-          (%slice index N)))))
-
-(define (%to-string)
-  data)
-
-(define (%to-vector)
-  (if (string-null? data)
-      (vector)
-      (let* ((bv (string->utf8 data))
-             (bv-size (length bv))
-             (result (make-vector N)))
-        (let loop ((i 0) (j 0))
-          (if (>= i N)
-              result
-              (let* ((next-j (bytevector-advance-u8 bv j bv-size))
-                     (ch (rich-char :from-bytevector (bytevector-copy bv j next-j))))
-                (vector-set! result i ch)
-                (loop (+ i 1) next-j)))))))
-
-(define (%to-rich-vector)
-  (rich-vector (%to-vector)))
-
-(define (%+ s . args)
-  (chain-apply args
-    (cond
-      ((string? s)
-       (rich-string (string-append data s)))
-      ((rich-string :is-type-of s)
-       (rich-string (string-append data (s :get))))
-      ((number? s)
-       (rich-string (string-append data (number->string s))))
-      (else
-        (type-error (string-append (object->string s) "is not string or rich-string or number"))))))
-
-(define (%strip-left . args)
-  (chain-apply args
-    (rich-string (string-trim data))))
-
-(define (%strip-right . args)
-  (chain-apply args
-    (rich-string (string-trim-right data))))
-
-(define (%strip-both . args)
-  (chain-apply args
-    (rich-string (string-trim-both data))))
-
-(define (%strip-prefix prefix . args)
-  (chain-apply args
-    (rich-string (string-remove-prefix data prefix))))
-
-(define (%strip-suffix suffix . args)
-  (chain-apply args
-    (rich-string (string-remove-suffix data suffix))))
-
-(define (%replace-first old new . args)
-  (chain-apply args
-    (let ((next-pos (%index-of old)))
-      (if (= next-pos -1)
-          (%this)
-          ((%slice 0 next-pos)
-           :+ new
-           :+ (%drop (+ next-pos ($ old :length))))))))
-
-(define (%replace old new . args)
-  (define (replace-helper str old new start)
-    (let ((next-pos ((rich-string str) :index-of old start)))
-      (if (= next-pos -1)
-          str
-          (replace-helper ((rich-string str) :replace-first old new :get)
-                          old new next-pos))))
-  (chain-apply args
-    (rich-string (replace-helper data old new 0))))
-
-(define* (%pad-left len (char #\space) . args)
-  (let ((result (rich-string (string-pad data len char))))
-    (if (null? args)
-        result
-        (apply result args))))
-
-(define* (%pad-right len (char #\space) . args)
-  (let ((result (rich-string (string-pad-right data len char))))
-    (if (null? args)
-        result
-        (apply result args))))
-
-(define (%split sep)
-  (let ((str-len N)
-        (sep-len (u8-string-length sep)))
-    
-    (define (split-helper start acc)
-      (let ((next-pos (%index-of sep start)))
-        (if (= next-pos -1)
-            (cons (%drop start :get) acc)
-            (split-helper (+ next-pos sep-len) (cons (%slice start next-pos :get) acc)))))
-    
-    (if (zero? sep-len)
-        ((%to-rich-vector) :map (lambda (c) (c :make-string)))
-        (rich-vector (reverse-list->vector (split-helper 0 '()))))))
-
-)
-
-)
-)
diff --git a/tests/resources/r7rs/liii/set.scm.txt b/tests/resources/r7rs/liii/set.scm.txt
deleted file mode 100644
index c351f20e..00000000
--- a/tests/resources/r7rs/liii/set.scm.txt
+++ /dev/null
@@ -1,69 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii set)
-(import (liii lang)(liii hash-table)(srfi srfi-128))
-(export hash-set)
-(begin
-
-
-(define-case-class hash-set ((data hash-table?))
-
-;; Factory methods
-(chained-define (@empty) 
-  (hash-set (make-hash-table)))
-                   
-;; Basic operations
-(define (%size) (hash-table-size data))
-
-(define (%empty?) (hash-table-empty? data))
-
-(define (%contains element)
-  (hash-table-contains? data element))
-
-;; Modification operations
-(chained-define (%add-one! element)
-  (hash-table-set! data element #t)
-  (%this))
-
-(chained-define (%remove! element)
-  (hash-table-delete! data element)
-  (%this))
-
-(chained-define (%add-one element)
-  (let ((ht (make-hash-table)))
-    (hash-table-for-each
-      (lambda (k v) (hash-table-set! ht k v))
-      data)
-    (hash-table-set! ht element #t)
-    (hash-set ht)))
-
-(chained-define (%remove element)
-  (let ((ht (make-hash-table)))
-    (hash-table-for-each
-      (lambda (k v) (hash-table-set! ht k v))
-      data)
-    (hash-table-delete! ht element)
-    (hash-set ht)))
-
-(chained-define (%clear!)
-  (hash-table-clear! data)
-  (%this))
-
-) ; end of define-case-class
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/sort.scm.txt b/tests/resources/r7rs/liii/sort.scm.txt
deleted file mode 100644
index 50beef81..00000000
--- a/tests/resources/r7rs/liii/sort.scm.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii sort)
-(export list-sorted? vector-sorted?
-        list-merge  list-sort  list-stable-sort  vector-merge  vector-sort  vector-stable-sort
-        list-merge! list-sort! list-stable-sort! vector-merge! vector-sort! vector-stable-sort!)
-(import (srfi srfi-132)))
-
diff --git a/tests/resources/r7rs/liii/stack.scm.txt b/tests/resources/r7rs/liii/stack.scm.txt
deleted file mode 100644
index cecab660..00000000
--- a/tests/resources/r7rs/liii/stack.scm.txt
+++ /dev/null
@@ -1,60 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii stack)
-(import (liii rich-list) (liii oop))
-(export stack)
-(begin
-
-(define-case-class stack ((data list?))
-                   
-(define (%length) (length data))
-
-(define (%size) (length data))
-
-(define (%top)
-  (if (null? data)
-      (error 'out-of-range)
-      (car data)))
-
-(define (%to-list) data)
-
-(define (%to-rich-list) (rich-list data))
-
-(define (@empty) (stack (list )))
-
-(chained-define (%pop)
-  (if (null? data)
-      (error 'out-of-range "Cannot pop from an empty stack")
-      (stack (cdr data))))
-
-(chained-define (%pop!)
-  (if (null? data)
-      (error 'out-of-range)
-      (stack (set! data (cdr data))))
-  (%this))
-
-(chained-define (%push element)
-  (stack (cons element data)))
-
-(chained-define (%push! element) 
-                (stack (set! data (cons element data))) 
-                (%this))
-
-) ; end of define-case-class
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/string.scm.txt b/tests/resources/r7rs/liii/string.scm.txt
deleted file mode 100644
index 7cc37c9a..00000000
--- a/tests/resources/r7rs/liii/string.scm.txt
+++ /dev/null
@@ -1,64 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii string)
-(export
-  ; S7 built-in
-  string? string-ref string-length
-  ; from (scheme base)
-  string-copy string-for-each string-map
-  ; from (srfi srfi-13)
-  string-null? string-join
-  string-every string-any
-  string-take string-take-right string-drop string-drop-right
-  string-pad string-pad-right
-  string-trim string-trim-right string-trim-both
-  string-index string-index-right
-  string-contains string-count
-  string-upcase string-downcase
-  string-fold string-fold-right string-for-each-index
-  string-reverse
-  string-tokenize
-  ; Liii extras
-  string-starts? string-ends?
-  string-remove-prefix string-remove-suffix
-)
-(import (srfi srfi-13)
-        (liii base)
-        (liii error))
-(begin
-
-(define (string-starts? str prefix)
-  (string-prefix? prefix str))
-
-(define (string-ends? str suffix)
-  (string-suffix? suffix str))
-
-(define string-remove-prefix
-  (typed-lambda ((str string?) (prefix string?))
-    (if (string-prefix? prefix str)
-        (substring str (string-length prefix))
-        str)))
-
-(define string-remove-suffix
-  (typed-lambda ((str string?) (suffix string?))
-    (if (string-suffix? suffix str)
-        (substring str 0 (- (string-length str) (string-length suffix)))
-        (string-copy str))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/sys.scm.txt b/tests/resources/r7rs/liii/sys.scm.txt
deleted file mode 100644
index 4f0efad1..00000000
--- a/tests/resources/r7rs/liii/sys.scm.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii sys)
-(export argv executable)
-(import (scheme process-context))
-(begin
-
-(define (argv) (command-line))
-
-(define (executable) (g_executable))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/uuid.scm.txt b/tests/resources/r7rs/liii/uuid.scm.txt
deleted file mode 100644
index daff1986..00000000
--- a/tests/resources/r7rs/liii/uuid.scm.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii uuid)
-(export uuid4)
-(begin
-
-(define (uuid4) (g_uuid4))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/liii/vector.scm.txt b/tests/resources/r7rs/liii/vector.scm.txt
deleted file mode 100644
index bcff52ad..00000000
--- a/tests/resources/r7rs/liii/vector.scm.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (liii vector)
-(import (srfi srfi-133)
-        (srfi srfi-13)
-        (liii base))
-(export
-  ; S7 Scheme built-in
-  make-vector vector vector-length vector-ref vector-set! vector->list list->vector
-  ; from (scheme base)
-  vector-copy vector-fill! vector-copy! vector->string string->vector
-  vector-map vector-for-each
-  ; from (srfi srfi-133)
-  vector-empty?
-  vector-fold vector-fold-right
-  vector-count
-  vector-any vector-every vector-copy vector-copy!
-  vector-index vector-index-right vector-skip vector-skip-right vector-partition
-  vector-swap! vector-reverse! vector-cumulate reverse-list->vector
-  vector=
-  ; Liii Extras
-  vector-filter
-)
-(begin
-
-(define (vector-filter pred vec)
-  (let* ((result-list (vector-fold (lambda (elem acc)
-                                     (if (pred elem)
-                                         (cons elem acc)
-                                         acc))
-                                   '()
-                                   vec))
-         (result-length (length result-list))
-         (result-vec (make-vector result-length)))
-    (let loop ((i (- result-length 1)) (lst result-list))
-      (if (null? lst)
-          result-vec
-          (begin
-            (vector-set! result-vec i (car lst))
-            (loop (- i 1) (cdr lst)))))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-1.scm.txt b/tests/resources/r7rs/srfi/srfi-1.scm.txt
deleted file mode 100644
index 3c64546c..00000000
--- a/tests/resources/r7rs/srfi/srfi-1.scm.txt
+++ /dev/null
@@ -1,355 +0,0 @@
-;;; SRFI-1 list-processing library                      -*- Scheme -*-
-;;; Reference implementation
-;;;
-;;; SPDX-License-Identifier: MIT
-;;;
-;;; Copyright (c) 1998, 1999 by Olin Shivers. You may do as you please with
-;;; this code as long as you do not remove this copyright notice or
-;;; hold me liable for its use. Please send bug reports to shivers@ai.mit.edu.
-;;;     -Olin
-;;;
-;;; Copyright (c) 2024 The Goldfish Scheme Authors
-;;; Follow the same License as the original one
-
-(define-library (srfi srfi-1)
-(import (liii error)
-        (liii base))
-(export
-  ; SRFI 1: Constructors
-  circular-list iota list-copy xcons cons*
-  ; SRFI 1: Predicates
-  circular-list? null-list? proper-list? dotted-list?
-  ; SRFI 1: Selectors
-  first second third fourth fifth
-  sixth seventh eighth ninth tenth
-  take drop take-right drop-right fold fold-right split-at
-  reduce reduce-right append-map filter partition remove find
-  delete delete-duplicates
-  ; SRFI 1: Miscellaneous: length, append, concatenate, reverse, zip & count
-  zip count
-  ; SRFI 1: Association List
-  assoc assq assv alist-cons
-  take-while drop-while list-index any every
-  last-pair last)
-(begin
-
-(define (xcons a b)
-         (cons b a))
-
-(define (cons* a . b)
-  (if (null? b)
-      a
-      (cons a (apply cons* b))))
-
-; 0 clause BSD, from S7 repo stuff.scm
-(define* (iota count (start 0) (step 1))
-  (when (not (integer? count))
-    (type-error "iota: count must be an integer"))
-  (when (< count 0)
-    (value-error "iota: count must be non-negative but received ~d" count))
-  (do ((i count (- i 1))
-       (val (+ start (* (- count 1) step)) (- val step))
-       (result '() (cons val result)))
-      ((zero? i) result)))
-
-(define (proper-list? x)
-  (let loop ((x x) (lag x))
-    (if (pair? x)
-        (let ((x (cdr x)))
-          (if (pair? x)
-              (let ((x   (cdr x))
-                    (lag (cdr lag)))
-                (and (not (eq? x lag)) (loop x lag)))
-              (null? x)))
-        (null? x))))
-
-(define (dotted-list? x)
-  (let loop ((x x) (lag x))
-    (if (pair? x)
-        (let ((x (cdr x)))
-          (if (pair? x)
-              (let ((x   (cdr x))
-                    (lag (cdr lag)))
-                (and (not (eq? x lag)) (loop x lag)))
-              (not (null? x))))
-        (not (null? x)))))
-
-(define (null-list? l)
-  (cond ((pair? l) #f)
-        ((null? l) #t)
-        (else
-         (error 'wrong-type-arg "null-list?: argument out of domain" l))))
-
-(define first car)
-
-(define second cadr)
-
-(define third caddr)
-
-(define (fourth x) (list-ref x 3))
-
-(define (fifth x) (list-ref x 4))
-
-(define (sixth x) (list-ref x 5))
-
-(define (seventh x) (list-ref x 6))
-
-(define (eighth x) (list-ref x 7))
-
-(define (ninth x) (list-ref x 8))
-
-(define (tenth x) (list-ref x 9))
-
-(define (take l k)
-  (let loop ((l l) (k k))
-    (if (zero? k)
-        '()
-        (cons (car l)
-              (loop (cdr l) (- k 1))))))
-
-(define drop list-tail)
-
-(define (take-right l k)
-  (let loop ((lag l)
-             (lead (drop l k)))
-    (if (pair? lead)
-        (loop (cdr lag) (cdr lead))
-        lag)))
-
-(define (drop-right l k)
-  (let loop ((lag l) (lead (drop l k)))
-    (if (pair? lead)
-        (cons (car lag) (loop (cdr lag) (cdr lead)))
-        '())))
-
-(define (split-at lst i)
-  (when (< i 0)
-    (value-error "require a index greater than 0, but got ~A -- split-at" i))
-  (let ((result (cons #f '())))
-    (do ((j i (- j 1))
-         (rest lst (cdr rest))
-         (node result (cdr node)))
-        ((zero? j)
-         (values (cdr result) rest))
-      (when (not (pair? rest))
-        (value-error "lst length cannot be greater than i, where lst is ~A, but i is ~A-- split-at" lst i))
-      (set-cdr! node (cons (car rest) '())))))
-
-
-(define (last-pair l)
-  (if (pair? (cdr l))
-      (last-pair (cdr l))
-      l))
-
-(define (last l)
-  (car (last-pair l)))
-
-(define (count pred list1 . lists)
-  (let lp ((lis list1) (i 0))
-    (if (null-list? lis) i
-        (lp (cdr lis) (if (pred (car lis)) (+ i 1) i)))))
-
-(define (zip . lists)
-  (apply map list lists))
-
-(define (fold f initial . lists)
-  (unless (procedure? f)
-    (error 'type-error "expected procedure, got ~S" f))
-  
-  (cond
-    ((null? lists) initial)
-    
-    ((and (pair? lists) (null? (cdr lists)) (list? (car lists)))
-     (let loop ((acc initial) (lst (car lists)))
-       (if (null? lst)
-           acc
-           (loop (f (car lst) acc) (cdr lst)))))
-    
-    (else
-     (let loop ((acc initial) (lsts lists))
-       (if (any null? lsts)
-           acc
-           (let* ((cars (map car lsts))
-                  (cdrs (map cdr lsts)))
-             (loop (apply f (append cars (list acc))) cdrs)))))))
-
-(define (fold-right f initial . lists)
-  (unless (procedure? f)
-    (error 'type-error "expected procedure, got ~S" f))
-  
-  (cond
-    ((null? lists) initial)
-    ((and (pair? lists) (null? (cdr lists)) (list? (car lists)))
-     (let loop ((lst (car lists)))
-       (if (null? lst)
-           initial
-           (f (car lst) (loop (cdr lst))))))
-    (else
-     (let loop ((lsts lists))
-       (if (any null? lsts)
-           initial
-           (let* ((cars (map car lsts))
-                  (cdrs (map cdr lsts)))
-             (apply f (append cars (list (loop cdrs))))))))))
-
-(define (reduce f initial l)
-  (if (null-list? l) initial
-      (fold f (car l) (cdr l))))
-
-(define (reduce-right f initial l)
-  (if (null-list? l) initial
-      (let recur ((head (car l)) (l (cdr l)))
-        (if (pair? l)
-            (f head (recur (car l) (cdr l)))
-            head))))
-
-(define (append-map proc . lists)
-  (unless (procedure? proc)
-    (error 'type-error "expected procedure, got ~S" proc))
-  (for-each 
-    (lambda (lst)
-      (unless (list? lst)
-        (error 'type-error "expected list, got ~S" lst)))
-    lists)
-  (apply append (apply map proc lists)))
-
-(define (filter pred l)
-  (let recur ((l l))
-    (if (null-list? l) l
-        (let ((head (car l))
-              (tail (cdr l)))
-          (if (pred head)
-              (let ((new-tail (recur tail)))
-                (if (eq? tail new-tail) l
-                    (cons head new-tail)))
-              (recur tail))))))
-
-(define (partition pred l)
-  (let loop ((lst l) (satisfies '()) (dissatisfies '()))
-    (cond ((null? lst)
-           (cons satisfies dissatisfies))
-          ((pred (car lst))
-           (loop (cdr lst) (cons (car lst) satisfies) dissatisfies))
-          (else
-           (loop (cdr lst) satisfies (cons (car lst) dissatisfies))))))
-
-(define (remove pred l)
-  (filter (lambda (x) (not (pred x))) l))
-
-(define (find pred l)
-  (cond ((null? l) #f)
-        ((pred (car l)) (car l)) 
-        (else (find pred (cdr l)))))
-
-(define (take-while pred lst)
-  (if (null? lst) 
-      '()
-      (if (pred (car lst))
-          (cons (car lst) (take-while pred (cdr lst)))
-          '())))
-
-(define (drop-while pred l)
-  (if (null? l)
-      '()
-      (if (pred (car l))
-          (drop-while pred (cdr l))
-          l)))
-
-(define (list-index pred l)
-    (let loop ((index 0) (l l))
-      (if (null? l)
-          #f
-          (if (pred (car l))
-              index
-              (loop (+ index 1) (cdr l))))))
-
-(define (any pred? l)
-  (cond ((null? l) #f)
-        ((pred? (car l)) #t)
-        (else (any pred? (cdr l)))))
-
-(define (every pred? l)
-  (cond ((null? l) #t)
-        ((not (pred? (car l))) #f)
-        (else (every pred? (cdr l)))))
-
-(define (%extract-maybe-equal maybe-equal)
-  (let ((my-equal (if (null-list? maybe-equal)
-                      equal?
-                      (car maybe-equal))))
-    (if (procedure? my-equal)
-        my-equal
-        (error 'wrong-type-arg "maybe-equal must be procedure"))))
-
-(define (delete x l . maybe-equal)
-  (let ((my-equal (%extract-maybe-equal maybe-equal)))
-    (filter (lambda (y) (not (my-equal x y))) l)))
-
-;; Check if equality function is supported by s7 hash-table
-(define (%can-use-hash-table? eq-func)
-  (memq eq-func '(eq? eqv? equal? equivalent? = string=? string-ci=? char=? char-ci=?)))
-
-;; Fast hash-table based deduplication using s7's native hash-table
-(define (%delete-duplicates-hash lis eq-func)
-  (let ((seen (make-hash-table 8 eq-func))
-        (result '()))
-    (for-each 
-      (lambda (x)
-        (unless (hash-table-ref seen x)
-          (hash-table-set! seen x #t)
-          (set! result (cons x result))))
-      lis)
-    (reverse result)))
-
-;; origin
-(define (%delete-duplicates-scan lis my-equal)
-  (let loop ((remaining lis) (seen '()) (result '()))
-    (cond
-      ((null? remaining)
-       (reverse result))
-      ((member (car remaining) seen my-equal)
-       (loop (cdr remaining) seen result))
-      (else
-       (loop (cdr remaining)
-             (cons (car remaining) seen)
-             (cons (car remaining) result))))))
-
-;;; right-duplicate deletion
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; delete-duplicates delete-duplicates!
-;;;
-;;; Hybrid strategy: Use hash table O(n) for supported functions and 
-;;; optimized scan O(n²) for other functions
-;;; 
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-
-(define (delete-duplicates lis . maybe-equal)
-  (let ((my-equal (%extract-maybe-equal maybe-equal)))
-    (cond
-      ((null? lis) lis)
-      ((%can-use-hash-table? my-equal)
-       (%delete-duplicates-hash lis my-equal))
-      (else
-       (%delete-duplicates-scan lis my-equal)))))
-
-(define (alist-cons key value alist)
-  (cons (cons key value) alist))
-
-(define (circular-list val1 . vals)
-  (let ((ans (cons val1 vals)))
-    (set-cdr! (last-pair ans) ans)
-    ans))
-
-(define (circular-list? x)
-  (let loop ((x x) (lag x))
-    (and (pair? x)
-         (let ((x (cdr x)))
-           (and (pair? x)
-                (let ((x   (cdr x))
-                      (lag (cdr lag)))
-                  (or (eq? x lag) (loop x lag))))))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-113.scm.txt b/tests/resources/r7rs/srfi/srfi-113.scm.txt
deleted file mode 100644
index b857d6e8..00000000
--- a/tests/resources/r7rs/srfi/srfi-113.scm.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-; Copyright (C) John Cowan (2015). All Rights Reserved.
-;
-; Permission is hereby granted, free of charge, to any person obtaining a copy of
-; this software and associated documentation files (the "Software"), to deal in
-; the Software without restriction, including without limitation the rights to
-; use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-; of the Software, and to permit persons to whom the Software is furnished to do
-; so, subject to the following conditions:
-;
-; The above copyright notice and this permission notice shall be included in all
-; copies or substantial portions of the Software.
-;
-; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-; SOFTWARE.
-;
-
-(define-library (srfi srfi-113)
-(import (scheme base))
-(export set?)
-(begin
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-125.scm.txt b/tests/resources/r7rs/srfi/srfi-125.scm.txt
deleted file mode 100644
index d1b18934..00000000
--- a/tests/resources/r7rs/srfi/srfi-125.scm.txt
+++ /dev/null
@@ -1,161 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-125)
-(import (srfi srfi-1)
-        (liii base)
-        (liii error))
-(export
-  make-hash-table hash-table hash-table-unfold alist->hash-table
-  hash-table? hash-table-contains? hash-table-empty? hash-table=?
-  hash-table-mutable?
-  hash-table-ref hash-table-ref/default
-  hash-table-set! hash-table-delete! hash-table-intern! hash-table-update!
-  hash-table-update!/default hash-table-pop! hash-table-clear!
-  hash-table-size hash-table-keys hash-table-values hash-table-entries
-  hash-table-find hash-table-count
-  hash-table-for-each hash-table-map->list
-  hash-table->alist
-)
-(begin
-
-(define (assert-hash-table-type ht f)
-  (when (not (hash-table? ht))
-    (error 'type-error f "this parameter must be typed as hash-table")))
-
-(define s7-hash-table-set! hash-table-set!)
-(define s7-make-hash-table make-hash-table)
-(define s7-hash-table-entries hash-table-entries)
-
-(define (make-hash-table . args)
-  (cond ((null? args) (s7-make-hash-table))
-        ((comparator? (car args))
-         (let* ((equiv (comparator-equality-predicate (car args)))
-                (hash-func (comparator-hash-function (car args))))
-           (s7-make-hash-table 8 (cons equiv hash-func) (cons #t #t))))
-        (else (type-error "make-hash-table"))))
-
-(define alist->hash-table
-  (typed-lambda ((lst list?))
-    (when (odd? (length lst))
-      (value-error "The length of lst must be even!"))
-    (let1 ht (make-hash-table)
-      (let loop ((rest lst))
-        (if (null? rest)
-            ht
-            (begin
-              (hash-table-set! ht (car rest) (cadr rest))
-              (loop (cddr rest))))))))
-
-(define (hash-table-contains? ht key)
-  (not (not (hash-table-ref ht key))))
-
-(define (hash-table-empty? ht)
-  (zero? (hash-table-size ht)))
-
-(define (hash-table=? ht1 ht2)
-  (equal? ht1 ht2))
-
-(define (hash-table-ref/default ht key default)
-  (or (hash-table-ref ht key)
-      (if (procedure? default) (default) default)))
-
-(define (hash-table-set! ht . rest)
-  (assert-hash-table-type ht hash-table-set!)
-  (let1 len (length rest)
-    (when (or (odd? len) (zero? len))
-      (error 'wrong-number-of-args len "but must be even and non-zero"))
-    
-    (s7-hash-table-set! ht (car rest) (cadr rest))
-    (when (> len 2)
-          (apply hash-table-set! (cons ht (cddr rest))))))
-
-(define (hash-table-delete! ht key . keys)
-  (assert-hash-table-type ht hash-table-delete!)
-  (let1 all-keys (cons key keys)
-    (length
-      (filter
-        (lambda (x)
-          (if (hash-table-contains? ht x)
-              (begin
-                (s7-hash-table-set! ht x #f)
-                #t)
-              #f))
-        all-keys))))
-
-(define (hash-table-update! ht key value)
-  (hash-table-set! ht key value))
-
-(define (hash-table-update!/default ht key updater default)
-  (hash-table-set! ht key (updater (hash-table-ref/default ht key default))))
-
-(define (hash-table-clear! ht)
-  (for-each
-    (lambda (key)
-      (hash-table-set! ht key #f))
-    (hash-table-keys ht)))
-
-(define hash-table-size s7-hash-table-entries)
-
-(define (hash-table-keys ht)
-  (map car ht))
-
-(define (hash-table-values ht)
-  (map cdr ht))
-
-(define hash-table-entries
-  (typed-lambda ((ht hash-table?))
-    (let ((ks (hash-table-keys ht))
-          (vs (hash-table-values ht)))
-      (values ks vs))))
-
-(define (hash-table-find proc ht failure)
-  (let ((keys (hash-table-keys ht)))
-    (let loop ((keys keys))
-      (if (null? keys)
-          (if (procedure? failure)
-              (failure)
-              failure)
-          (let* ((key (car keys))
-                 (value (hash-table-ref ht key)))
-            (if (proc key value)
-                value
-                (loop (cdr keys))))))))
-
-(define hash-table-count
-  (typed-lambda ((pred? procedure?) (ht hash-table?))
-    (count (lambda (x) (pred? (car x) (cdr x)))
-           (map values ht))))
-
-(define hash-table-for-each
-  (typed-lambda ((proc procedure?) (ht hash-table?))
-    (for-each (lambda (x) (proc (car x) (cdr x)))
-              ht)))
-
-(define hash-table-map->list
-  (typed-lambda ((proc procedure?) (ht hash-table?))
-    (map (lambda (x) (proc (car x) (cdr x)))
-         ht)))
-
-(define hash-table->alist
-  (typed-lambda ((ht hash-table?))
-    (append-map
-      (lambda (x) (list (car x) (cdr x)))
-      (map values ht))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-128.scm.txt b/tests/resources/r7rs/srfi/srfi-128.scm.txt
deleted file mode 100644
index 8a932dd3..00000000
--- a/tests/resources/r7rs/srfi/srfi-128.scm.txt
+++ /dev/null
@@ -1,376 +0,0 @@
-;;; SPDX-License-Identifier: MIT
-;;;
-;;; Copyright (C) John Cowan (2015). All Rights Reserved.
-;;; 
-;;; Permission is hereby granted, free of charge, to any person
-;;; obtaining a copy of this software and associated documentation
-;;; files (the "Software"), to deal in the Software without
-;;; restriction, including without limitation the rights to use,
-;;; copy, modify, merge, publish, distribute, sublicense, and/or
-;;; sell copies of the Software, and to permit persons to whom the
-;;; Software is furnished to do so, subject to the following
-;;; conditions:
-;;; 
-;;; The above copyright notice and this permission notice shall be
-;;; included in all copies or substantial portions of the Software.
-;;; 
-;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-;;; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-;;; FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-;;; OTHER DEALINGS IN THE SOFTWARE. 
-
-;;;; Main part of the SRFI 114 reference implementation
-
-;;; "There are two ways of constructing a software design: One way is to
-;;; make it so simple that there are obviously no deficiencies, and the
-;;; other way is to make it so complicated that there are no *obvious*
-;;; deficiencies." --Tony Hoare
-
-(define-library (srfi srfi-128)
-(import (scheme base)
-        (liii error))
-(export
-  comparator? comparator-ordered? comparator-hashable?
-  make-comparator make-pair-comparator make-list-comparator
-  make-vector-comparator make-eq-comparator make-eqv-comparator make-equal-comparator
-  boolean-hash char-hash char-ci-hash string-hash string-ci-hash
-  symbol-hash number-hash
-  make-default-comparator default-hash
-  comparator-type-test-predicate comparator-equality-predicate
-  comparator-ordering-predicate comparator-hash-function
-  comparator-test-type comparator-check-type comparator-hash
-  =? <? >? <=? >=?
-)
-(begin
-
-(define-record-type comparator
-  (make-raw-comparator type-test equality ordering hash ordering? hash?)
-  comparator?
-  (type-test comparator-type-test-predicate)
-  (equality comparator-equality-predicate)
-  (ordering comparator-ordering-predicate)
-  (hash comparator-hash-function)
-  (ordering? comparator-ordered?)
-  (hash? comparator-hashable?))
-
-;; Invoke the test type
-(define (comparator-test-type comparator obj)
-  ((comparator-type-test-predicate comparator) obj))
-
-(define (comparator-check-type comparator obj)
-  (if (comparator-test-type comparator obj)
-    #t
-    (type-error "comparator type check failed" comparator obj)))
-
-(define (comparator-hash comparator obj)
-  ((comparator-hash-function comparator) obj))
-
-(define (binary=? comparator a b)
-  ((comparator-equality-predicate comparator) a b))
-
-(define (binary<? comparator a b)
-  ((comparator-ordering-predicate comparator) a b))
-
-(define (binary>? comparator a b)
-  (binary<? comparator b a))
-
-(define (binary<=? comparator a b)
-  (not (binary>? comparator a b)))
-
-(define (binary>=? comparator a b)
-  (not (binary<? comparator a b)))
-
-(define (%salt%)
-  16064047)
-
-(define (hash-bound)
-  33554432)
-
-(define (make-hasher)
-  (let ((result (%salt%)))
-    (case-lambda
-     (() result)
-     ((n) (set! result (+ (modulo (* result 33) (hash-bound)) n))
-          result))))
-
-(define (make-comparator type-test equality ordering hash)
-  (make-raw-comparator
-    (if (eq? type-test #t) (lambda (x) #t) type-test)
-    (if (eq? equality #t) (lambda (x y) (eqv? (ordering x y) 0)) equality)
-    (if ordering ordering (lambda (x y) (error "ordering not supported")))
-    (if hash hash (lambda (x y) (error "hashing not supported")))
-    (if ordering #t #f)
-    (if hash #t #f)))
-
-(define (make-eq-comparator)
-  (make-comparator #t eq? #f default-hash))
-
-(define (make-eqv-comparator)
-  (make-comparator #t eqv? #f default-hash))
-
-(define (make-equal-comparator)
-  (make-comparator #t equal? #f default-hash))
-
-(define (make-pair-type-test car-comparator cdr-comparator)
-  (lambda (obj)
-    (and (pair? obj)
-         (comparator-test-type car-comparator (car obj))
-         (comparator-test-type cdr-comparator (cdr obj)))))
-
-(define (make-pair=? car-comparator cdr-comparator)
-   (lambda (a b)
-     (and ((comparator-equality-predicate car-comparator) (car a) (car b))
-          ((comparator-equality-predicate cdr-comparator) (cdr a) (cdr b)))))
-
-(define (make-pair<? car-comparator cdr-comparator)
-   (lambda (a b)
-      (if (=? car-comparator (car a) (car b))
-        (<? cdr-comparator (cdr a) (cdr b))
-        (<? car-comparator (car a) (car b)))))
-
-(define (make-pair-hash car-comparator cdr-comparator)
-   (lambda (obj)
-     (let ((acc (make-hasher)))
-       (acc (comparator-hash car-comparator (car obj)))
-       (acc (comparator-hash cdr-comparator (cdr obj)))
-       (acc))))
-
-(define (make-pair-comparator car-comparator cdr-comparator)
-   (make-comparator
-     (make-pair-type-test car-comparator cdr-comparator)
-     (make-pair=? car-comparator cdr-comparator)
-     (make-pair<? car-comparator cdr-comparator)
-     (make-pair-hash car-comparator cdr-comparator)))
-
-;; Cheap test for listness
-(define (norp? obj) (or (null? obj) (pair? obj)))
-
-(define (make-list-comparator element-comparator type-test empty? head tail)
-   (make-comparator
-     (make-list-type-test element-comparator type-test empty? head tail)
-     (make-list=? element-comparator type-test empty? head tail)
-     (make-list<? element-comparator type-test empty? head tail)
-     (make-list-hash element-comparator type-test empty? head tail)))
-
-(define (make-list-type-test element-comparator type-test empty? head tail)
-  (lambda (obj)
-    (and
-      (type-test obj)
-      (let ((elem-type-test (comparator-type-test-predicate element-comparator)))
-        (let loop ((obj obj))
-          (cond
-            ((empty? obj) #t)
-            ((not (elem-type-test (head obj))) #f)
-            (else (loop (tail obj)))))))))
-
-(define (make-list=? element-comparator type-test empty? head tail)
-  (lambda (a b)
-    (let ((elem=? (comparator-equality-predicate element-comparator)))
-      (let loop ((a a) (b b))
-        (cond
-          ((and (empty? a) (empty? b) #t))
-          ((empty? a) #f)
-          ((empty? b) #f)
-          ((elem=? (head a) (head b)) (loop (tail a) (tail b)))
-          (else #f))))))
-
-(define (make-list<? element-comparator type-test empty? head tail)
-  (lambda (a b)
-    (let ((elem=? (comparator-equality-predicate element-comparator))
-          (elem<? (comparator-ordering-predicate element-comparator)))
-      (let loop ((a a) (b b))
-        (cond
-          ((and (empty? a) (empty? b) #f))
-          ((empty? a) #t)
-          ((empty? b) #f)
-          ((elem=? (head a) (head b)) (loop (tail a) (tail b)))
-          ((elem<? (head a) (head b)) #t)
-          (else #f))))))
-
-(define (make-list-hash element-comparator type-test empty? head tail)
-  (lambda (obj)
-    (let ((elem-hash (comparator-hash-function element-comparator))
-          (acc (make-hasher)))
-      (let loop ((obj obj))
-        (cond
-          ((empty? obj) (acc))
-          (else (acc (elem-hash (head obj))) (loop (tail obj))))))))
-
-(define (make-vector-comparator element-comparator type-test length ref)
-  (make-comparator
-    (make-vector-type-test element-comparator type-test length ref)
-    (make-vector=? element-comparator type-test length ref)
-    (make-vector<? element-comparator type-test length ref)
-    (make-vector-hash element-comparator type-test length ref)))
-
-(define (make-vector-type-test element-comparator type-test length ref)
-  (lambda (obj)
-    (and
-      (type-test obj)
-      (let ((elem-type-test (comparator-type-test-predicate element-comparator))
-            (len (length obj)))
-        (let loop ((n 0))
-          (cond
-            ((= n len) #t)
-            ((not (elem-type-test (ref obj n))) #f)
-            (else (loop (+ n 1)))))))))
-
-(define (make-vector=? element-comparator type-test length ref)
-   (lambda (a b)
-     (and
-       (= (length a) (length b))
-       (let ((elem=? (comparator-equality-predicate element-comparator))
-             (len (length b)))
-         (let loop ((n 0))
-           (cond
-             ((= n len) #t)
-             ((elem=? (ref a n) (ref b n)) (loop (+ n 1)))
-             (else #f)))))))
-
-(define (make-vector<? element-comparator type-test length ref)
-   (lambda (a b)
-     (cond
-       ((< (length a) (length b)) #t)
-       ((> (length a) (length b)) #f)
-        (else
-         (let ((elem=? (comparator-equality-predicate element-comparator))
-             (elem<? (comparator-ordering-predicate element-comparator))
-             (len (length a)))
-         (let loop ((n 0))
-           (cond
-             ((= n len) #f)
-             ((elem=? (ref a n) (ref b n)) (loop (+ n 1)))
-             ((elem<? (ref a n) (ref b n)) #t)
-             (else #f))))))))
-
-(define (make-vector-hash element-comparator type-test length ref)
-  (lambda (obj)
-    (let ((elem-hash (comparator-hash-function element-comparator))
-          (acc (make-hasher))
-          (len (length obj)))
-      (let loop ((n 0))
-        (cond
-          ((= n len) (acc))
-          (else (acc (elem-hash (ref obj n))) (loop (+ n 1))))))))
-
-(define (object-type obj)
-  (cond
-    ((null? obj) 0)
-    ((pair? obj) 1)
-    ((boolean? obj) 2)
-    ((char? obj) 3)
-    ((string? obj) 4)
-    ((symbol? obj) 5)
-    ((number? obj) 6)
-    ((vector? obj) 7)
-    ((bytevector? obj) 8)
-    (else 65535)))
-
-(define (boolean<? a b)
-  ;; #f < #t but not otherwise
-  (and (not a) b))
-
-(define (complex<? a b)
-  (if (= (real-part a) (real-part b))
-    (< (imag-part a) (imag-part b))
-    (< (real-part a) (real-part b))))
-
-(define (symbol<? a b)
-  (string<? (symbol->string a) (symbol->string b)))
-
-(define boolean-hash hash-code)
-(define char-hash hash-code)
-(define char-ci-hash hash-code)
-(define string-hash hash-code)
-(define string-ci-hash hash-code)
-(define symbol-hash hash-code)
-(define number-hash hash-code)
-(define default-hash hash-code)
-
-(define (dispatch-ordering type a b)
-  (case type
-    ((0) 0) ; All empty lists are equal
-    ((1) ((make-pair<? (make-default-comparator) (make-default-comparator)) a b))
-    ((2) (boolean<? a b))
-    ((3) (char<? a b))
-    ((4) (string<? a b))
-    ((5) (symbol<? a b))
-    ((6) (complex<? a b))
-    ((7) ((make-vector<? (make-default-comparator) vector? vector-length vector-ref)
-          a b))
-    ((8) ((make-vector<? (make-comparator exact-integer? = < default-hash)
-                         bytevector? bytevector-length bytevector-u8-ref)
-          a b))
-    ; Add more here
-    (else (binary<? (registered-comparator type) a b))))
-
-(define (default-ordering a b)
-  (let ((a-type (object-type a))
-        (b-type (object-type b)))
-    (cond
-      ((< a-type b-type) #t)
-      ((> a-type b-type) #f)
-      (else (dispatch-ordering a-type a b)))))
-
-(define (dispatch-equality type a b)
-  (case type
-    ((0) #t) ; All empty lists are equal
-    ((1) ((make-pair=? (make-default-comparator) (make-default-comparator)) a b))
-    ((2) (boolean=? a b))
-    ((3) (char=? a b))
-    ((4) (string=? a b))
-    ((5) (symbol=? a b))
-    ((6) (= a b))
-    ((7) ((make-vector=? (make-default-comparator)
-                         vector? vector-length vector-ref) a b))
-    ((8) ((make-vector=? (make-comparator exact-integer? = < default-hash)
-                         bytevector? bytevector-length bytevector-u8-ref) a b))
-    ; Add more here
-    (else (binary=? (registered-comparator type) a b))))
-
-(define (default-equality a b)
-  (let ((a-type (object-type a))
-        (b-type (object-type b)))
-    (if (= a-type b-type)
-        (dispatch-equality a-type a b)
-        #f)))
-
-(define (make-default-comparator)
-  (make-comparator
-    (lambda (obj) #t)
-    default-equality
-    default-ordering
-    default-hash))
-
-(define (=? comparator a b . objs)
-  (let loop ((a a) (b b) (objs objs))
-    (and (binary=? comparator a b)
-         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
-
-(define (<? comparator a b . objs)
-  (let loop ((a a) (b b) (objs objs))
-    (and (binary<? comparator a b)
-         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
-
-(define (>? comparator a b . objs)
-  (let loop ((a a) (b b) (objs objs))
-    (and (binary>? comparator a b)
-         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
-
-(define (<=? comparator a b . objs)
-  (let loop ((a a) (b b) (objs objs))
-    (and (binary<=? comparator a b)
-         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
-
-(define (>=? comparator a b . objs)
-  (let loop ((a a) (b b) (objs objs))
-    (and (binary>=? comparator a b)
-         (if (null? objs) #t (loop b (car objs) (cdr objs))))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-13.scm.txt b/tests/resources/r7rs/srfi/srfi-13.scm.txt
deleted file mode 100644
index 75cfa0ef..00000000
--- a/tests/resources/r7rs/srfi/srfi-13.scm.txt
+++ /dev/null
@@ -1,380 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-13)
-  (import
-    (liii base)
-    (srfi srfi-1))
-  (export
-    string-null? string-copy string-join
-    string-every string-any
-    string-take string-take-right string-drop string-drop-right 
-    string-pad string-pad-right
-    string-trim string-trim-right string-trim-both
-    string-prefix? string-suffix? 
-    string-index string-index-right
-    string-contains string-count
-    string-upcase string-downcase
-    string-fold string-fold-right string-for-each-index
-    string-reverse
-    string-tokenize)
-(begin
-
-(define (%string-from-range str start_end)
-  (cond ((null-list? start_end) str)
-        ((= (length start_end) 1)
-          (substring str (car start_end)))
-        ((= (length start_end) 2)
-         (substring str (first start_end) (second start_end)))
-        (else (error 'wrong-number-of-args "%string-from-range"))))
-
-(define (%make-criterion char/pred?)
-  (cond ((char? char/pred?) (lambda (x) (char=? x char/pred?)))
-        ((procedure? char/pred?) char/pred?)
-        (else (error 'wrong-type-arg "%make-criterion"))))
-
-(define (string-join l . delim+grammer)
-  (define (extract-params params-l)
-    (cond ((null-list? params-l)
-           (list "" 'infix))
-          ((and (= (length params-l) 1)
-                (string? (car params-l)))
-           (list (car params-l) 'infix))
-          ((and (= (length params-l) 2)
-                (string? (first params-l))
-                (symbol? (second params-l)))
-           params-l)
-          ((> (length params-l) 2)
-           (error 'wrong-number-of-args "optional params in string-join"))
-          (else (error 'type-error "optional params in string-join"))))
-  
-  (define (string-join-sub l delim)
-    (cond ((null-list? l) "")
-          ((= (length l) 1) (car l))
-          (else
-            (string-append
-              (car l)
-              delim
-              (string-join-sub (cdr l) delim)))))
-  
-  (let* ((params  (extract-params delim+grammer))
-         (delim   (first params))
-         (grammer (second params))
-         (ret     (string-join-sub l delim)))
-    (case grammer
-      ('infix ret)
-      ('strict-infix
-       (if (null-list? l)
-           (error 'value-error "empty list not allowed")
-           ret))
-      ('suffix
-        (if (null-list? l) "" (string-append ret delim)))
-      ('prefix
-        (if (null-list? l) "" (string-append delim ret)))
-      (else (error 'value-error "invalid grammer")))))
-
-(define (string-null? str)
-  (and (string? str) 
-       ((lambda (x) (= x 0)) (string-length str))))
-
-(define (string-every char/pred? str . start+end)
-  (define (string-every-sub pred? str)
-    (let
-      loop ((i 0) (len (string-length str)))
-      (or (= i len)
-          (and (pred? (string-ref str i)) 
-               (loop (+ i 1) len)))))
-  
-  (let ((str-sub (%string-from-range str start+end))
-        (criterion (%make-criterion char/pred?)))
-    (string-every-sub criterion str-sub)))
-
-(define (string-any char/pred? str . start+end)
-  (define (string-any-sub pred? str)
-    (let loop ((i 0) (len (string-length str)))
-      (if (= i len)
-          #f   
-          (or (pred? (string-ref str i)) 
-              (loop (+ i 1) len)))))
-  
-  (let ((str_sub (%string-from-range str start+end))
-        (criterion (%make-criterion char/pred?)))
-    (string-any-sub criterion str_sub)))
-
-(define (string-take str k)
-  (substring str 0 k))
-
-(define (string-take-right str k)
-  (let ((N (string-length str)))
-    (if (> k N)
-        (error 'out-of-range "k must be <= N" k N))
-        (substring str (- N k) N)))
-
-(define string-drop
-  (typed-lambda ((str string?) (k integer?))
-    (when (< k 0)
-      (error 'out-of-range "k must be non-negative" k))
-    (let ((N (string-length str)))
-      (if (> k N)
-        (error 'out-of-range "k must be <= N" k N)
-        (substring str k N)))))
-
-(define string-drop-right
-  (typed-lambda ((str string?) (k integer?))
-    (when (< k 0)
-      (error 'out-of-range "k must be non-negative" k))
-    (let ((N (string-length str)))
-      (if (> k N)
-        (error 'out-of-range "k must be <= N" k N)
-        (substring str 0 (- N k))))))
-
-(define (string-pad str len . char+start+end)
-  (define (string-pad-sub str len ch)
-    (let ((orig-len (string-length str)))
-      (if (< len orig-len)
-          (string-take-right str len)
-          (string-append (make-string (- len orig-len) ch) str))))
-  
-  (cond ((null-list? char+start+end)
-         (string-pad-sub str len #\ ))
-        ((list? char+start+end)
-         (string-pad-sub
-           (%string-from-range str (cdr char+start+end))
-           len
-           (car char+start+end)))
-        (else (error 'wrong-type-arg "string-pad"))))
-
-(define (string-pad-right str len . char+start+end)
-  (define (string-pad-right-sub str len ch)
-    (let ((orig-len (string-length str)))
-      (if (< len orig-len)
-          (string-take str len)
-          (string-append str (make-string (- len orig-len) ch)))))
-  
-  (cond ((null-list? char+start+end)
-         (string-pad-right-sub str len #\ ))
-        ((list? char+start+end)
-         (string-pad-right-sub
-           (%string-from-range str (cdr char+start+end))
-           len
-           (car char+start+end)))
-        (else (error 'wrong-type-arg "string-pad"))))
-
-(define (string-trim str . opt)
-  (let ((predicate (cond
-                    ((null? opt) char-whitespace?)
-                    ((char? (car opt)) (lambda (c) (char=? c (car opt))))
-                    ((procedure? (car opt)) (car opt))
-                    (else (type-error "Invalid second argument: expected character or predicate" (car opt))))))
-    (let* ((start (if (and (> (length opt) 1) (number? (cadr opt))) (cadr opt) 0))
-           (end (if (and (> (length opt) 2) (number? (caddr opt))) (caddr opt) (string-length str)))
-           (str (substring str start end)))
-      (let loop ((i 0)
-                 (len (string-length str)))
-        (if (or (>= i len) (not (predicate (string-ref str i))))
-            (substring str i len)
-            (loop (+ i 1) len))))))
-
-(define (string-trim-right str . opt)
-  (let ((predicate (cond
-                    ((null? opt) char-whitespace?)
-                    ((char? (car opt)) (lambda (c) (char=? c (car opt))))
-                    ((procedure? (car opt)) (car opt))
-                    (else (type-error "Invalid second argument: expected character or predicate" (car opt))))))
-    (let* ((start (if (and (> (length opt) 1) (number? (cadr opt))) (cadr opt) 0))
-           (end (if (and (> (length opt) 2) (number? (caddr opt))) (caddr opt) (string-length str)))
-           (str (substring str start end)))
-      (let loop ((j (- (string-length str) 1)))
-        (if (or (< j 0) (not (predicate (string-ref str j))))
-            (substring str 0 (+ j 1))
-            (loop (- j 1)))))))
-
-(define (string-trim-both str . opt)
-  (let ((predicate (cond
-                    ((null? opt) char-whitespace?)
-                    ((char? (car opt)) (lambda (c) (char=? c (car opt))))
-                    ((procedure? (car opt)) (car opt))
-                    (else (type-error "Invalid second argument: expected character or predicate" (car opt))))))
-    (let* ((start (if (and (> (length opt) 1) (number? (cadr opt))) (cadr opt) 0))
-           (end (if (and (> (length opt) 2) (number? (caddr opt))) (caddr opt) (string-length str)))
-           (str (substring str start end)))
-      (let loop-left ((i 0)
-                      (len (string-length str)))
-        (if (or (>= i len) (not (predicate (string-ref str i))))
-            (let loop-right ((j (- len 1)))
-              (if (or (< j i) (not (predicate (string-ref str j))))
-                  (substring str i (+ j 1))
-                  (loop-right (- j 1))))
-            (loop-left (+ i 1) len))))))
-
-(define (string-prefix? prefix str)
-  (let* ((prefix-len (string-length prefix))
-         (str-len (string-length str)))
-    (and (<= prefix-len str-len)
-         (string=? prefix (substring str 0 prefix-len)))))
-
-(define (string-suffix? suffix str)
-  (let* ((suffix-len (string-length suffix))
-         (str-len (string-length str)))
-    (and (<= suffix-len str-len)
-         (string=? suffix (substring str (- str-len suffix-len) str-len)))))
-
-(define (string-index str char/pred? . start+end)
-  (define (string-index-sub str pred?)
-    (let loop ((i 0))
-      (cond ((>= i (string-length str)) #f)
-            ((pred? (string-ref str i)) i)
-            (else (loop (+ i 1))))))
-  
-  (let* ((start (if (null-list? start+end) 0 (car start+end)))
-         (str-sub (%string-from-range str start+end))
-         (pred? (%make-criterion char/pred?))
-         (ret (string-index-sub str-sub pred?)))
-    (if ret (+ start ret) ret)))
-
-(define (string-index-right str char/pred? . start+end)
-  (define (string-index-right-sub str pred?)
-    (let loop ((i (- (string-length str) 1)))
-      (cond ((< i 0) #f)
-            ((pred? (string-ref str i)) i)
-            (else (loop (- i 1))))))
-  
-  (let* ((start (if (null-list? start+end) 0 (car start+end)))
-        (str-sub (%string-from-range str start+end))
-        (pred? (%make-criterion char/pred?))
-        (ret (string-index-right-sub str-sub pred?)))
-    (if ret (+ start ret) ret)))
-
-(define (string-contains str sub-str)
-  (let loop ((i 0))
-    (let ((len (string-length str))
-          (sub-str-len (string-length sub-str)))
-      (if (> i (- len sub-str-len)) 
-          #f
-          (if (string=? 
-                (substring
-                  str
-                  i
-                  (+ i sub-str-len))
-                sub-str)
-              #t
-              (loop (+ i 1)))))))
-
-(define (string-count str char/pred? . start+end)
-  (when (not (string? str))
-    (type-error "string-count: first parameter must be string"))
-  (let ((str-sub (%string-from-range str start+end))
-        (criterion (%make-criterion char/pred?)))
-    (count criterion (string->list str-sub))))
-
-(define s7-string-upcase string-upcase)
-
-(define* (string-upcase str (start 0) (end (string-length str)))
-  (let* ((left (substring str 0 start))
-         (middle (substring str start end))
-         (right (substring str end)))
-    (string-append left (s7-string-upcase middle) right)))
-
-(define s7-string-downcase string-downcase)
-
-(define* (string-downcase str (start 0) (end (string-length str)))
-  (let* ((left (substring str 0 start))
-         (middle (substring str start end))
-         (right (substring str end)))
-    (string-append left (s7-string-downcase middle) right)))
-
-(define (string-reverse str . start+end)
-  (cond ((null-list? start+end)
-         (reverse str))
-        ((= (length start+end) 1)
-         (let ((start (first start+end)))
-           (string-append (substring str 0 start)
-                          (reverse (substring str start)))))
-        ((= (length start+end) 2)
-         (let ((start (first start+end))
-               (end (second start+end)))
-           (string-append (substring str 0 start)
-                          (reverse (substring str start end))
-                          (substring str end))))
-        (else (error 'wrong-number-of-args "string-reverse"))))
-
-(define (string-fold kons knil s . rest)
-  (when (not (procedure? kons))
-        (type-error "string-fold: first argument must be a procedure"))
-  (when (not (string? s))
-        (type-error "string-fold: second argument must be a string"))
-
-  (let ((substr (%string-from-range s rest)))
-    (let loop ((i 0)
-               (result knil))
-      (if (= i (string-length substr))
-          result
-          (loop (+ i 1)
-                (kons (string-ref substr i) result))))))
-
-(define (string-fold-right kons knil s . rest)
-  (when (not (procedure? kons))
-        (type-error "string-fold-right: first argument must be a procedure"))
-  (when (not (string? s))
-        (type-error "string-fold-right: second argument must be a string"))
-
-  (let ((substr (%string-from-range s rest)))
-    (let loop ((i (- (string-length substr) 1))
-               (result knil))
-      (if (< i 0)
-          result
-          (loop (- i 1)
-                (kons (string-ref substr i) result))))))
-
-(define (string-for-each-index proc str . start+end)
-  (when (not (procedure? proc))
-    (error 'type-error "string-for-each-index: first argument must be a procedure"))
-  (when (not (string? str))
-    (error 'type-error "string-for-each-index: expected a string"))
-  (let ((substr (%string-from-range str start+end)))
-    (let loop ((i 0) (len (string-length substr)) (acc '()))
-      (if (< i len)
-          (loop (+ i 1) len (proc i (string-ref substr i) acc))
-          (reverse acc)))))
-
-(define (string-tokenize str . char+start+end)
-  
-  (define (string-tokenize-sub str char)
-    
-    (define (tokenize-helper tokens cursor)
-      (let ((sep-pos/false (string-index str char cursor)))
-        (if (not sep-pos/false)
-            (reverse (cons (substring str cursor) tokens))
-            (let ((new-tokens
-                   (if (= cursor sep-pos/false)
-                       tokens
-                       (cons (substring str cursor sep-pos/false) tokens)))
-                  (next-cursor (+ sep-pos/false 1)))
-              (tokenize-helper new-tokens next-cursor)))))
-  
-      (tokenize-helper '() 0))
-  
-  (cond ((null-list? char+start+end)
-         (string-tokenize-sub str #\ ))
-        ((list? char+start+end)
-         (string-tokenize-sub
-               (%string-from-range str (cdr char+start+end))
-               (car char+start+end)))
-        (else (error 'wrong-type-arg "string-tokenize"))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-132.scm.txt b/tests/resources/r7rs/srfi/srfi-132.scm.txt
deleted file mode 100644
index da227609..00000000
--- a/tests/resources/r7rs/srfi/srfi-132.scm.txt
+++ /dev/null
@@ -1,188 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-132)
-(export list-sorted? vector-sorted?
-        list-merge  list-sort  list-stable-sort  vector-merge  vector-sort  vector-stable-sort
-        list-merge! list-sort! list-stable-sort! vector-merge! vector-sort! vector-stable-sort!)
-(import (liii list)
-        (liii error)
-        (scheme case-lambda))
-(begin
-
-
-(define (list-sorted? less-p lis)
-  (if (null? lis)
-    #t
-    (do ((first lis (cdr first))
-          (second (cdr lis) (cdr second))
-          (res #t (not (less-p (car second) (car first)))))
-      ((or (null? second) (not res)) res))))
-
-(define vector-sorted?
-  (case-lambda
-    ((less-p v) (vector-sorted? less-p v 0 (vector-length v)))
-    ((less-p v start) (vector-sorted? less-p v start (vector-length v)))
-    ((less-p v start end)
-      (if (or (< start 0) (> end (vector-length v)) (> start end))
-        (raise "Invalid start or end parameters") ; 使用 raise 抛出错误
-        (let loop ((i start))
-          (if (>= i (- end 1))
-            #t
-            (if (less-p (vector-ref v (+ i 1)) (vector-ref v i))
-              #f
-              (loop (+ i 1)))))))))
-
-(define (list-merge less-p lis1 lis2)
-  (let loop
-    ((res '())
-      (lis1 lis1)
-      (lis2 lis2))
-    (cond
-      ((and (null? lis1) (null? lis2)) (reverse res))
-      ((null? lis1) (loop (cons (car lis2) res) lis1 (cdr lis2)))
-      ((null? lis2) (loop (cons (car lis1) res) lis2 (cdr lis1)))
-      ((less-p (car lis2) (car lis1)) (loop (cons (car lis2) res) lis1 (cdr lis2)))
-      (else (loop (cons (car lis1) res) (cdr lis1) lis2)))))
-
-(define list-merge!
-  (lambda (less-p lis1 lis2)
-    (define (merge! left right prev)
-      (let loop ((left left) (right right) (prev prev))
-        (cond
-          ((null? left) (set-cdr! prev right))
-          ((null? right) (set-cdr! prev left))
-          ((less-p (car left) (car right))
-            (set-cdr! prev left)
-            (loop (cdr left) right left))
-          (else
-            (set-cdr! prev right)
-            (loop left (cdr right) right)))))
-    (let ((dummy (cons '() '())))
-      (merge! lis1 lis2 dummy)
-      (cdr dummy))))
-
-(define (list-stable-sort less-p lis)
-  (define (sort l r)
-    (cond
-      ((= l r) '())
-      ((= (+ l 1) r) (list (list-ref lis l)))
-      (else
-        (let* ((mid (quotient (+ l r) 2))
-                (l-sorted (sort l mid))
-                (r-sorted (sort mid r)))
-          (list-merge less-p l-sorted r-sorted)))))
-  (sort 0 (length lis)))
-
-(define (list-sort less-p lis)
-  (if (or (null? lis) (null? (cdr lis)))
-      lis
-      (let ((pivot (car lis))
-            (rest (cdr lis)))
-        (let ((smaller (filter (lambda (x) (less-p x pivot)) rest))
-              (larger (filter (lambda (x) (not (less-p x pivot))) rest)))
-          (append (list-sort less-p smaller)
-                  (list pivot)
-                  (list-sort less-p larger))))))
-
-(define (list-sort! less-p lst)
-  ;; 辅助函数：返回列表的最后一个元素
-  (define (last-pair lst)
-    (if (null? (cdr lst))
-        lst
-        (last-pair (cdr lst))))
-  ;; 辅助函数：将列表分成小于和大于 pivot 的部分
-  (define (partition! lst pivot less-p)
-    (let loop ((lst lst) (less '()) (greater '()))
-      (cond
-        ((null? lst) (values (reverse less) (reverse greater)))  ;; 返回小于和大于部分
-        ((less-p (car lst) pivot)
-          (loop (cdr lst) (cons (car lst) less) greater))
-        (else
-          (loop (cdr lst) less (cons (car lst) greater))))))
-  ;; 排序函数：原地排序
-  (if (or (null? lst) (null? (cdr lst)))  ;; 如果列表为空或只有一个元素，已经排序好
-      lst
-      (let* ((pivot (car lst)))
-        (call-with-values 
-          (lambda () (partition! (cdr lst) pivot less-p))  ;; 调用 partition 并返回小于和大于部分
-          (lambda (less greater)
-            ;; 对小于和大于部分递归排序
-            (let ((sorted-less (list-sort! less-p less))
-                  (sorted-greater (list-sort! less-p greater)))
-              ;; 如果 sorted-less 是空，直接返回 sorted-greater
-              (if (null? sorted-less)
-                  sorted-greater
-                  (begin
-                    ;; 原地连接两个部分和 pivot
-                    (set-cdr! (last-pair sorted-less) (cons pivot sorted-greater))
-                    sorted-less))))))))  ;; 返回排序后的列表
-
-(define list-stable-sort!
-  (lambda (less-p lis)
-    (define (split! lis)
-      (let loop ((slow lis) (fast (cdr lis)))
-        (if (or (null? fast) (null? (cdr fast)))
-            (let ((mid (cdr slow)))
-              (set-cdr! slow '())
-              (values lis mid))
-            (loop (cdr slow) (cddr fast)))))
-    (if (or (null? lis) (null? (cdr lis)))
-        lis
-        (let-values (((left right) (split! lis)))
-          (list-merge! less-p
-                      (list-stable-sort! less-p left)
-                      (list-stable-sort! less-p right))))))
-
-(define vector-stable-sort
-  (case-lambda
-    ((less-p v)
-      (list->vector (list-stable-sort less-p (vector->list v))))
-    ((less-p v start)
-      (list->vector (list-stable-sort less-p (subvector->list v start (vector-length v)))))
-    ((less-p v start end)
-      (list->vector (list-stable-sort less-p (subvector->list v start end))))))
-
-(define vector-sort vector-stable-sort)
-
-(define (vector-sort! . r) (???))
-
-(define (vector-stable-sort! . r) (???))
-
-(define (subvector->list v start end)
-  (do ((r '() (cons (vector-ref v p) r))
-        (p start (+ 1 p)))
-    ((>= p end) (reverse r))))
-
-(define vector-merge
-  (case-lambda
-    ((less-p v1 v2)
-      (list->vector (list-merge less-p (vector->list v1) (vector->list v2))))
-    ((less-p v1 v2 start1)
-      (list->vector (list-merge less-p (subvector->list v1 start1 (vector-length v1)) (vector->list v2))))
-    ((less-p v1 v2 start1 end1)
-      (list->vector (list-merge less-p (subvector->list v1 start1 end1) (vector->list v2))))
-    ((less-p v1 v2 start1 end1 start2)
-      (list->vector (list-merge less-p (subvector->list v1 start1 end1) (subvector->list v2 start2 (vector-length v2)))))
-    ((less-p v1 v2 start1 end1 start2 end2)
-      (list->vector (list-merge less-p (subvector->list v1 start1 end1) (subvector->list v2 start2 end2))))))
-
-(define (vector-merge! . r) (???))
-
-
-) ; end of begin
-) ; end of library
-
diff --git a/tests/resources/r7rs/srfi/srfi-133.scm.txt b/tests/resources/r7rs/srfi/srfi-133.scm.txt
deleted file mode 100644
index 66accba0..00000000
--- a/tests/resources/r7rs/srfi/srfi-133.scm.txt
+++ /dev/null
@@ -1,183 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-133)
-(import (liii base))
-(export
-  vector-empty?
-  vector-fold vector-fold-right
-  vector-count
-  vector-any vector-every vector-copy vector-copy!
-  vector-index vector-index-right vector-skip vector-skip-right vector-partition
-  vector-swap! vector-reverse! vector-cumulate reverse-list->vector
-  vector=)
-(begin
-
-(define (vector-empty? v)
-  (when (not (vector? v))
-    (error 'type-error "v is not a vector"))
-  (zero? (vector-length v)))
-
-(define (vector= elt=? . rest)
-  (define compare2vecs
-    (typed-lambda ((cmp procedure?) (vec1 vector?) (vec2 vector?))
-       (let*  ((len1 (vector-length vec1))
-               (len2 (vector-length vec2)))
-         (if (not (= len1 len2)) #f
-             (let loop ((ilhs 0) (irhs 0) (len len1))
-                  (if (= ilhs len) #t
-                      (if (not (cmp (vec1 ilhs) (vec2 irhs))) #f 
-                          (loop (+ 1 ilhs) (+ 1 irhs) len))))))))
-  (when (not (procedure? elt=?)) (error 'type-error "elt=? should be a procedure"))
-  (if (or(null? rest) (= 1 (length rest))) #t
-      (let loop ((vec1 (car rest)) (vec2 (car (cdr rest))) (vrest (cdr (cdr rest))))
-        (let1 rst (compare2vecs elt=? vec1 vec2)
-           (when (not (boolean? rst)) (error 'type-error "elt=> should return bool"))
-           (if (compare2vecs elt=? vec1 vec2)
-               (if (null? vrest) #t
-                   (loop vec2 (car vrest) (cdr vrest)))
-               #f)))))
-(define (vector-fold f initial vec)
-  (let loop ((i 0) (acc initial))
-    (if (< i (vector-length vec))
-        (loop (+ i 1) (f (vector-ref vec i) acc))
-        acc)))
-
-(define (vector-fold-right f initial vec)
-  (let loop ((i (- (vector-length vec) 1)) (acc initial))
-    (if (>= i 0)
-        (loop (- i 1) (f (vector-ref vec i) acc))
-        acc)))
-
-; TODO optional parameters
-(define (vector-count pred v)
-  (let loop ((i 0) (count 0))
-       (cond ((= i (vector-length v)) count)
-             ((pred (vector-ref v i)) 
-              (loop (+ i 1) (+ count 1)))
-             (else (loop (+ i 1) count)))))
-
-; Return a new vector v-rst with same length of input vector vec.
-; Every element of the result is the result the i-th iteration of fn cumu_i vec_i.
-;   Where fn should be a procedure with 2 args.
-;   The type of knil and vector could be different.
-; In the i-th iteration, cumu_i = fn cumu_(i-1) vec_i, with cumu_0 = fn knil vec_0.
-
-(define vector-cumulate
-  (typed-lambda ((fn procedure?) knil (vec vector?))
-    (let* ((len (vector-length vec))
-           (v-rst (make-vector len)))
-      (let loop ((i 0) (lhs knil))
-           (if (= i len)
-               v-rst
-               (let1 cumu-i (fn lhs (vec i))
-                 (begin
-                   (vector-set! v-rst i cumu-i)
-                   (loop (+ 1 i) cumu-i))))))))
-; TODO optional parameters
-(define (vector-any pred v)
-  (let loop ((i 0))
-       (cond ((= i (vector-length v)) #f)
-             ((pred (vector-ref v i)) #t)
-             (else (loop (+ i 1))))))
-
-; TODO optional parameters
-(define (vector-every pred v)
-  (let loop ((i 0))
-       (cond ((= i (vector-length v)) #t)
-             ((not (pred (vector-ref v i))) #f)
-             (else (loop (+ i 1))))))
-
-(define vector-index
-  (typed-lambda ((pred procedure?) (v vector?))
-    (let loop ((i 0))
-       (cond ((= i (vector-length v)) #f)
-             ((pred (vector-ref v i)) i)
-             (else (loop (+ i 1)))))))
-
-(define vector-index-right
-  (typed-lambda ((pred procedure?) (v vector?))
-    (let ((len (vector-length v)))
-      (let loop ((i (- len 1)))
-        (cond ((< i 0) #f)
-               ((pred (vector-ref v i)) i)
-               (else (loop (- i 1))))))))
-
-(define (vector-skip pred v)
-  (vector-index (lambda (x) (not (pred x))) v))
-
-(define (vector-skip-right pred v)
-  (vector-index-right (lambda (x) (not (pred x))) v))
-
-(define (vector-partition pred v)
-  (let* ((len (vector-length v))
-         (cnt (vector-count pred v))
-         (ret (make-vector len)))
-    (let loop ((i 0) (yes 0) (no cnt))
-      (if (= i len)
-        (values ret cnt)
-        (let ((elem (vector-ref v i)))
-          (if (pred elem)
-            (begin
-              (vector-set! ret yes elem)
-              (loop (+ i 1) (+ yes 1) no))
-            (begin
-              (vector-set! ret no elem)
-              (loop (+ i 1) yes (+ no 1)))))))))
-
-(define (vector-swap! vec i j)
-  (let ((elem-i (vector-ref vec i))
-        (elem-j (vector-ref vec j)))
-    (vector-set! vec i elem-j)
-    (vector-set! vec j elem-i)
-    ))
-
-(define (vector-reverse! vec . args)
-  (let* ((args-length (length args))
-        (start (if (null? args) 0 (car args)))  
-        (end  (if (<= args-length 1) 
-                  (vector-length vec)          
-                  (cadr args))))
-
-      (unless (and (< args-length 3) (>= args-length 0))
-        (error 'wrong-number-of-args "#<vector-reverse!>: too many args" args-length))
-      (unless (and (integer? start) (integer? end))
-        (error 'type-error "#<vector-reverse!>: *start* and *end* must be an integer" start end))
-      (when (< start 0)
-        (error 'out-of-range "#<vector-reverse!>: *start* cannot be negative" start))
-      (when (> end (vector-length vec))
-        (error 'out-of-range "#<vector-reverse!>: *end* exceeds vector length" end))
-      (when (> start end)
-        (error 'out-of-range "#<vector-reverse!>: *start* must be less than or equal to *end*" start end))
-    
-    (let loop ((i start) (j (- end 1)))
-      (when (< i j)
-        (vector-swap! vec i j)
-        (loop (+ i 1) (- j 1))))))
-
-; Input a proper-list, return a vector with inversed order elements.
-(define reverse-list->vector
-  (typed-lambda ((lst proper-list?))
-    (let* ((len (length lst)) (v-rst (make-vector len)))
-      (let loop ((l lst) (i (- len 1)))
-        (if (null? l) v-rst
-            (begin
-              (vector-set! v-rst i (car l))
-              (loop (cdr l) (- i 1))))))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-151.scm.txt b/tests/resources/r7rs/srfi/srfi-151.scm.txt
deleted file mode 100644
index f739fcbc..00000000
--- a/tests/resources/r7rs/srfi/srfi-151.scm.txt
+++ /dev/null
@@ -1,168 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-151)
-(import (liii base))
-(export
-  bitwise-not bitwise-and bitwise-ior bitwise-xor bitwise-eqv bitwise-nor bitwise-nand 
-  bit-count bitwise-orc1 bitwise-orc2 bitwise-andc1 bitwise-andc2
-  arithmetic-shift integer-length bitwise-if
-  bit-set? copy-bit bit-swap any-bit-set? every-bit-set? first-set-bit
-  bit-field bit-field-any? bit-field-every? bit-field-clear bit-field-set
-)
-(begin
-
-(define bitwise-not lognot)
-
-(define bitwise-and logand)
-
-(define bitwise-ior logior)
-
-(define bitwise-xor logxor)
-
-(define (bitwise-eqv a b)
-        (= (bitwise-xor a b) 0))
-
-(define (bitwise-nor a b)  
-        (lognot (bitwise-ior a b)))
-
-(define (bitwise-nand a b)  
-        (lognot (bitwise-and a b)))
-
-(define bit-count 
-  (typed-lambda ((i integer?))
-    (define (bit-count-positive i)
-      (let loop ((n i) (cnt 0))
-        (if (= n 0)
-            cnt
-            (loop (logand n (- n 1)) (+ cnt 1)))))
-
-    (cond ((zero? i) 0)
-          ((positive? i) (bit-count-positive i))
-          (else (bit-count-positive (lognot i))))))
-
-(define (bitwise-orc1 i j)
-  (bitwise-ior (bitwise-not i) j))
-
-(define (bitwise-orc2  i j) 
-  (bitwise-ior i (bitwise-not j)))
-
-(define (bitwise-andc1 i j)  
-  (bitwise-and (bitwise-not i) j))
-
-(define (bitwise-andc2 i j) 
-  (bitwise-and i (bitwise-not j)))
-
-(define arithmetic-shift ash)
-
-(define (integer-length n)
-  (if (zero? n)
-      0
-      (let loop ((value (abs n)) (count 1))
-           (if (<= value 1)
-               count
-               (loop (ash value -1) (+ count 1))))))
-
-(define (bitwise-if mask a b)
-  (bitwise-ior
-   (bitwise-and mask a)
-   (bitwise-and (bitwise-not mask) b)))
-
-(define (bit-set? index n)
-  (cond
-    ((negative? index)
-     (error 'out-of-range "bit-set?: Index cannot be negative" index))
-    ((> index 63)
-     (error 'out-of-range "bit-set?: Index cannot exceed 63" index))
-    ((= index 63)
-     (negative? n))
-    (else
-     (not (zero? (bitwise-and n (arithmetic-shift 1 index)))))))
-
-(define (copy-bit index n boolean)
-  (cond
-    ((negative? index)
-     (error 'out-of-range "copy-bit: Index cannot be negative" index))
-    ((> index 63)
-     (error 'out-of-range "copy-bit: Index cannot exceed 63" index))
-    ((= index 63)
-     (if boolean
-         (bitwise-ior n #x8000000000000000)
-         (bitwise-and n #x7FFFFFFFFFFFFFFF)))
-    (else
-     (if boolean
-         (bitwise-ior n (arithmetic-shift 1 index))
-         (bitwise-and n (bitwise-not (arithmetic-shift 1 index)))))))
-
-(define (bit-swap index1 index2 n)
- (cond
-  ((or (negative? index1) (negative? index2))
-   (error 'out-of-range "bit-swap: Index cannot be negative" index1 index2))
-  ((or (> index1 63) (> index2 63))
-   (error 'out-of-range "bit-swap: Index cannot exceed 63" index1 index2))
-  (else 
-   (copy-bit index2
-        (copy-bit index1 n (bit-set? index2 n))
-        (bit-set? index1 n)))))
-
-(define (any-bit-set? test-bits n)
-  (not (zero? (bitwise-and test-bits n))))
-
-(define (every-bit-set? test-bits n)
-  (= (bitwise-and test-bits n) test-bits))
-
-(define (first-set-bit n)
-  (if (zero? n)
-      -1
-      (let ((lsb (bitwise-and n (- n))))
-        (- (integer-length lsb) 1))))
-
-(define (bit-field i start end)
-  (let* ((bits (integer-length i)))
-    (if (>= start bits)
-        (error 'out-of-range "bit-field: Start cannot be greater than or equal to the integer length" start)
-        (let* ((end (min end bits))
-               (width (- end start)))
-          (if (<= width 0)
-              0
-              (let ((mask (arithmetic-shift (- (expt 2 width) 1) start)))
-                (arithmetic-shift (bitwise-and i mask) (- start))))))))
-
-(define (bit-field-any? i start end)
-  (not (zero?
-         (bitwise-and
-           (arithmetic-shift i (- start))
-           (- (arithmetic-shift 1 (- end start)) 1)))))
-
-(define (bit-field-every? i start end)
-  (= (bitwise-and (arithmetic-shift i (- start)) 
-                  (- (arithmetic-shift 1 (- end start)) 1)) 
-     (- (arithmetic-shift 1 (- end start)) 1)))
-
-(define (bit-field-clear i start end)
-  (bitwise-and i
-    (bitwise-not
-      (arithmetic-shift
-        (- (arithmetic-shift 1 (- end start)) 1) start))))
-
-(define (bit-field-set i start end)
-  (bitwise-ior i
-    (arithmetic-shift
-       (- (arithmetic-shift 1 (- end start)) 1) start)))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-16.scm.txt b/tests/resources/r7rs/srfi/srfi-16.scm.txt
deleted file mode 100644
index 6f159a54..00000000
--- a/tests/resources/r7rs/srfi/srfi-16.scm.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-16)
-  (import (scheme case-lambda))
-  (export case-lambda))
-
diff --git a/tests/resources/r7rs/srfi/srfi-2.scm.txt b/tests/resources/r7rs/srfi/srfi-2.scm.txt
deleted file mode 100644
index 8a63b5c6..00000000
--- a/tests/resources/r7rs/srfi/srfi-2.scm.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-; 0-clause BSD by Bill Schottstaedt from S7 source repo: s7test.scm
-(define-library (srfi srfi-2)
-(export and-let*)
-(begin
-
-(define-macro (and-let* vars . body)
-  `(let () (and ,@(map (lambda (v) `(define ,@v)) vars) (begin ,@body))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-216.scm.txt b/tests/resources/r7rs/srfi/srfi-216.scm.txt
deleted file mode 100644
index 05cb4e45..00000000
--- a/tests/resources/r7rs/srfi/srfi-216.scm.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-216)
-(export true false nil runtime)
-(import (scheme time))
-(begin
-
-(define true #t)
-
-(define false #f)
-
-(define nil '())
-
-(define (runtime)
-  (round (* 1000 (current-second))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-26.scm.txt b/tests/resources/r7rs/srfi/srfi-26.scm.txt
deleted file mode 100644
index e59988c0..00000000
--- a/tests/resources/r7rs/srfi/srfi-26.scm.txt
+++ /dev/null
@@ -1,70 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-26)
-(export cut cute)
-(import (liii list)
-        (liii error))
-(begin
-
-(define-macro (cut . paras)
-  (letrec*
-    ((slot? (lambda (x) (equal? '<> x)))
-     (more-slot? (lambda (x) (equal? '<...> x)))
-     (slots (filter slot? paras))
-     (more-slots (filter more-slot? paras))
-     (xs (map (lambda (x) (gensym)) slots))
-     (rest (gensym))
-     (parse
-       (lambda (xs paras)
-         (cond
-           ((null? paras) paras)
-           ((not (list? paras)) paras)
-           ((more-slot? (car paras)) `(,rest ,@(parse xs (cdr paras))))
-           ((slot? (car paras)) `(,(car xs) ,@(parse (cdr xs) (cdr paras))))
-           (else `(,(car paras) ,@(parse xs (cdr paras))))))))
-    (cond
-      ((null? more-slots)
-       `(lambda ,xs ,(parse xs paras)))
-      (else
-        (when
-          (or (> (length more-slots) 1)
-              (not (more-slot? (last paras))))
-          (error 'syntax-error "<...> must be the last parameter of cut"))
-        (let ((parsed (parse xs paras)))
-          `(lambda (,@xs . ,rest) (apply ,@parsed)))))))
-
-(define-macro (cute . paras)
-  (letrec*
-    ((slot? (lambda (x) (equal? '<> x)))
-     (more-slot? (lambda (x) (equal? '<...> x)))
-     (exprs (filter (lambda (x) (not (or (slot? x) (more-slot? x))))
-                    paras))
-     (xs (map (lambda (x) (gensym)) exprs))
-     (lets (map list xs exprs))
-     (parse
-       (lambda (xs paras)
-         (cond
-           ((null? paras) paras)
-           ((not (list? paras)) paras)
-           ((not (or (slot? (car paras)) (more-slot? (car paras))))
-            `(,(car xs) ,@(parse (cdr xs) (cdr paras))))
-           (else `(,(car paras) ,@(parse xs (cdr paras))))))))
-    `(let ,lets (cut ,@(parse xs paras)))))
-
-) ; end of begin
-) ; end of library
-
diff --git a/tests/resources/r7rs/srfi/srfi-39.scm.txt b/tests/resources/r7rs/srfi/srfi-39.scm.txt
deleted file mode 100644
index 9ad50e3d..00000000
--- a/tests/resources/r7rs/srfi/srfi-39.scm.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-; 0-clause BSD
-; Bill Schottstaedt
-; from S7 source repo: r7rs.scm
-
-(define-library (srfi srfi-39)
-(export make-parameter parameterize)
-(begin
-
-;; parameters
-;;   s7 has no built-in parameter objects
-(define* (make-parameter init converter)
-  (let* ((convert (or converter (lambda (x) x)))
-         (old-values ()) ; see below -- this is part of the funclet
-         (value (convert init)))
-    (lambda () value)))
-
-(define-macro (parameterize vars . body)
-  `(dynamic-wind
-       (lambda ()
-         ,@(map (lambda (var)
-                  `(with-let (funclet ,(car var))
-                     (set! old-values (cons value old-values))
-                     (set! value (convert ,(cadr var)))))
-                vars))
-       (lambda () 
-         ,@body)
-       (lambda ()
-         ,@(map (lambda (var)
-                  `(with-let (funclet ,(car var))
-                     (set! value (car old-values))
-                     (set! old-values (cdr old-values))))
-                vars))))
-
-) ; end of begin
-) ; end of define-library
diff --git a/tests/resources/r7rs/srfi/srfi-78.scm.txt b/tests/resources/r7rs/srfi/srfi-78.scm.txt
deleted file mode 100644
index ae14ffb7..00000000
--- a/tests/resources/r7rs/srfi/srfi-78.scm.txt
+++ /dev/null
@@ -1,165 +0,0 @@
-; <PLAINTEXT>
-; Copyright (c) 2005-2006 Sebastian Egner.
-; 
-; Permission is hereby granted, free of charge, to any person obtaining
-; a copy of this software and associated documentation files (the
-; ''Software''), to deal in the Software without restriction, including
-; without limitation the rights to use, copy, modify, merge, publish,
-; distribute, sublicense, and/or sell copies of the Software, and to
-; permit persons to whom the Software is furnished to do so, subject to
-; the following conditions:
-; 
-; The above copyright notice and this permission notice shall be
-; included in all copies or substantial portions of the Software.
-; 
-; THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
-; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-; OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-; WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-; 
-; -----------------------------------------------------------------------
-; 
-; Lightweight testing (reference implementation)
-; ==============================================
-;
-; Sebastian.Egner@philips.com
-; in R5RS + SRFI 23 (error) + SRFI 42 (comprehensions)
-;
-; history of this file:
-;   SE, 25-Oct-2004: first version based on code used in SRFIs 42 and 67
-;   SE, 19-Jan-2006: (arg ...) made optional in check-ec
-;
-; Naming convention "check:<identifier>" is used only internally.
-;
-; Copyright (c) 2024 The Goldfish Scheme Authors
-; Follow the same License as the original one
-
-(define-library (srfi srfi-78)
-(import (liii lang))
-(export check check-set-mode! check-report check-reset!
-        check-passed? check-failed?
-        check:proc)
-(begin
-
-(define check:write display*)
-
-(define check:mode #f)
-
-(define (check-set-mode! mode)
-  (set! check:mode
-        (case mode
-          ((off)           0)
-          ((summary)       1)
-          ((report-failed) 10)
-          ((report)        100)
-          (else (error "unrecognized mode" mode)))))
-
-
-(check-set-mode! 'report)
-
-(define check:correct 0)
-(define check:failed '())
-
-(define (check-reset!)
-  (set! check:correct 0)
-  (set! check:failed '()))
-
-(define (check:add-correct!)
-  (set! check:correct (+ check:correct 1)))
-
-(define (check:add-failed! expression actual-result expected-result)
-  (set! check:failed
-        (cons (list expression actual-result expected-result)
-              check:failed)))
-
-(define (check:report-expression expression)
-  (newline)
-  (check:write expression)
-  (display " => "))
-
-(define (check:report-actual-result actual-result)
-  (check:write actual-result)
-  (display " ; "))
-
-(define (check:report-correct cases)
-  (display "correct")
-  (if (not (= cases 1))
-      (begin (display " (")
-             (display cases)
-             (display " cases checked)")))
-  (newline))
-
-(define (check:report-failed expected-result)
-  (display "*** failed ***")
-  (newline)
-  (display "; expected result: ")
-  (check:write expected-result)
-  (newline))
-
-(define (check-passed? expected-total-count)
-  (and (= (length check:failed) 0)
-       (= check:correct expected-total-count)))
-
-(define (check-failed?)
-  (>= (length check:failed) 1))
-
-(define* (check:proc expression thunk expected-result (equal class=?))
-  (case check:mode
-    ((0) #f)
-    ((1)
-     (let ((actual-result (thunk)))
-       (if (equal actual-result expected-result)
-           (check:add-correct!)
-           (check:add-failed! expression actual-result expected-result))))
-    ((10)
-     (let ((actual-result (thunk)))
-       (if (equal actual-result expected-result)
-           (check:add-correct!)
-           (begin
-             (check:report-expression expression)
-             (check:report-actual-result actual-result)
-             (check:report-failed expected-result)
-             (check:add-failed! expression actual-result expected-result)))))
-    ((100)
-     (check:report-expression expression)
-     (let ((actual-result (thunk)))
-       (check:report-actual-result actual-result)
-       (if (equal actual-result expected-result)
-           (begin (check:report-correct 1)
-                  (check:add-correct!))
-           (begin (check:report-failed expected-result)
-                  (check:add-failed! expression 
-                                     actual-result 
-                                     expected-result)))))
-    (else (error "unrecognized check:mode" check:mode))))
-
-(define-macro (check expr => expected)
-  `(check:proc ',expr (lambda () ,expr) ,expected))
-
-(define (check-report)
-  (if (>= check:mode 1)
-      (begin
-        (newline)
-        (display "; *** checks *** : ")
-        (display check:correct)
-        (display " correct, ")
-        (display (length check:failed))
-        (display " failed.")
-        (if (or (null? check:failed) (<= check:mode 1))
-            (newline)
-            (let* ((w (car (reverse check:failed)))
-                   (expression (car w))
-                   (actual-result (cadr w))
-                   (expected-result (caddr w)))
-              (display " First failed example:")
-              (newline)
-              (check:report-expression expression)
-              (check:report-actual-result actual-result)
-              (check:report-failed expected-result))))))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-8.scm.txt b/tests/resources/r7rs/srfi/srfi-8.scm.txt
deleted file mode 100644
index c8c952ff..00000000
--- a/tests/resources/r7rs/srfi/srfi-8.scm.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-;
-; Copyright (C) 2024 The Goldfish Scheme Authors
-;
-; Licensed under the Apache License, Version 2.0 (the "License");
-; you may not use this file except in compliance with the License.
-; You may obtain a copy of the License at
-;
-; http://www.apache.org/licenses/LICENSE-2.0
-;
-; Unless required by applicable law or agreed to in writing, software
-; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-; License for the specific language governing permissions and limitations
-; under the License.
-;
-
-(define-library (srfi srfi-8)
-(export receive)              
-(begin
-
-(define-macro (receive formals expression . body)
-  `(call-with-values
-    (lambda () (values ,expression))
-    (lambda ,formals ,@body)))
-
-) ; end of begin
-) ; end of define-library
-
diff --git a/tests/resources/r7rs/srfi/srfi-9.scm.txt b/tests/resources/r7rs/srfi/srfi-9.scm.txt
deleted file mode 100644
index 20b1c647..00000000
--- a/tests/resources/r7rs/srfi/srfi-9.scm.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-(define-library (srfi srfi-9)
-(import (scheme base))
-(export define-record-type)
-(begin
-) ; end of begin
-) ; end of define-library
-

From 734cacf0c60235e9077d5998150d3b7736b31732 Mon Sep 17 00:00:00 2001
From: VSteveHL <hzq1283014604@163.com>
Date: Wed, 16 Jul 2025 14:46:31 +0800
Subject: [PATCH 4/6] Add top-envrionment parameter to init-library-node
 function and modify related commits

---
 .../dependency/rules/library-import-r7rs.sls  | 44 +++++++++++++++++++
 analysis/util.sls                             | 32 +++++++++-----
 analysis/workspace.sls                        | 20 ++++-----
 3 files changed, 74 insertions(+), 22 deletions(-)
 create mode 100644 analysis/dependency/rules/library-import-r7rs.sls

diff --git a/analysis/dependency/rules/library-import-r7rs.sls b/analysis/dependency/rules/library-import-r7rs.sls
new file mode 100644
index 00000000..2415105d
--- /dev/null
+++ b/analysis/dependency/rules/library-import-r7rs.sls
@@ -0,0 +1,44 @@
+(library (scheme-langserver analysis dependency rules library-import-r7rs)
+  (export 
+    library-import-process-r7rs)
+  (import 
+    (chezscheme) 
+    (ufo-match)
+
+    (scheme-langserver analysis identifier reference)
+    (ufo-try)
+
+    (scheme-langserver virtual-file-system index-node)
+    (scheme-langserver virtual-file-system document)
+    (scheme-langserver virtual-file-system file-node))
+
+(define (library-import-process-r7rs index-node)
+  (apply append 
+    (let* ([ann (index-node-datum/annotations index-node)]
+        [expression (annotation-stripped ann)])
+      (match expression
+        [('define-library _ **1 ) (map match-import (index-node-children index-node))]
+        [else (list (match-import index-node))]))))
+
+(define (match-import index-node)
+  (filter 
+    (lambda (item) (not (null? item)))
+    (let* ([ann (index-node-datum/annotations index-node)]
+        [expression (annotation-stripped ann)])
+      (match expression
+        [('import dummy **1 ) (map match-clause (index-node-children index-node))]
+        [else '()]))))
+
+(define (match-clause index-node)
+  (filter 
+    (lambda (item) (not (null? item)))
+    (let* ([ann (index-node-datum/annotations index-node)]
+        [expression (annotation-stripped ann)])
+      (match expression 
+        [('only (identifier **1) _ ...) identifier]
+        [('except (identifier **1) _ ...) identifier]
+        [('prefix (identifier **1) _ ...) identifier]
+        [('rename (identifier **1) _ ...) identifier]
+        [(identifier **1) identifier]
+        [else '()]))))
+)
\ No newline at end of file
diff --git a/analysis/util.sls b/analysis/util.sls
index 2aecd297..4274b089 100644
--- a/analysis/util.sls
+++ b/analysis/util.sls
@@ -17,18 +17,26 @@
 
 (define (do-nothing . fuzzy) (void))
 
-(define (get-library-identifiers-list document)
-    (if (null? document)
-        '()
-        (let ([index-node-list (document-index-node-list document)])
-            (dedupe
-                (map 
-                    (lambda (index-node)
-                        (match (annotation-stripped (index-node-datum/annotations index-node))
-                            [('library (name **1) _ ... ) name]
-                            [('define-library (name **1) _ ... ) name]
-                            [else '()]))
-                    index-node-list)))))
+(define get-library-identifiers-list
+    (case-lambda
+        [(document) (get-library-identifiers-list document 'r6rs)]
+        [(document top-environment)
+            (let [(func (case top-environment
+                            ['r6rs
+                                (lambda (index-node)
+                                (match (annotation-stripped (index-node-datum/annotations index-node))
+                                    [('library (name **1) _ ... ) name]
+                                    [else '()]))]
+                            ['r7rs
+                                (lambda (index-node)
+                                (match (annotation-stripped (index-node-datum/annotations index-node))
+                                    [('define-library (name **1) _ ... ) name]
+                                    [else '()]))]))]
+                (if (null? document)
+                    '()
+                    (let ([index-node-list (document-index-node-list document)])
+                        (dedupe
+                            (map func index-node-list)))))]))
 
 (define (get-nearest-ancestor-library-identifier index-node)
     (if (null? index-node)
diff --git a/analysis/workspace.sls b/analysis/workspace.sls
index fb358c80..790d1403 100644
--- a/analysis/workspace.sls
+++ b/analysis/workspace.sls
@@ -74,7 +74,7 @@
 (define (refresh-workspace workspace-instance)
   (let* ([path (file-node-path (workspace-file-node workspace-instance))]
       [root-file-node (init-virtual-file-system path '() (workspace-facet workspace-instance) (workspace-top-environment workspace-instance))]
-      [root-library-node (init-library-node root-file-node)]
+      [root-library-node (init-library-node root-file-node (workspace-top-environment workspace-instance))]
       [file-linkage (init-file-linkage root-file-node root-library-node)]
       [batches (get-init-reference-batches file-linkage)])
     (init-references workspace-instance batches)
@@ -97,7 +97,7 @@
               [akku (generate-akku-acceptable-file-filter (string-append path "/.akku/list"))]
               [else (generate-akku-acceptable-file-filter (string-append path "/.akku/list"))])]
           [root-file-node (init-virtual-file-system path '() facet top-environment)]
-          [root-library-node (init-library-node root-file-node)]
+          [root-library-node (init-library-node root-file-node top-environment)]
           [file-linkage (init-file-linkage root-file-node root-library-node)]
           [batches (get-init-reference-batches file-linkage)])
         (init-references root-file-node root-library-node file-linkage threaded? batches type-inference?)
@@ -159,8 +159,7 @@
       [linkage (workspace-file-linkage workspace-instance)]
       [target-document (file-node-document target-file-node)]
       [root-library-node (workspace-library-node workspace-instance)]
-
-      [old-library-identifiers-list (get-library-identifiers-list (file-node-document target-file-node))]
+      [old-library-identifiers-list (get-library-identifiers-list (file-node-document target-file-node) (workspace-top-environment workspace-instance))]
       [old-library-node-list 
         (filter (lambda (item) (not (null? item)))
           (map (lambda (old-library-identifiers) (walk-library old-library-identifiers root-library-node))
@@ -177,7 +176,7 @@
     (document-line-length-vector-set! target-document (text->line-length-vector text))
     (document-index-node-list-set! target-document new-index-nodes)
 
-    (let ([new-library-identifiers-list (get-library-identifiers-list (file-node-document target-file-node))])
+    (let ([new-library-identifiers-list (get-library-identifiers-list (file-node-document target-file-node) (workspace-top-environment workspace-instance))])
       (if (not (equal? new-library-identifiers-list old-library-identifiers-list))
         (begin 
 ;; BEGINE: some file may change their library-identifier or even do not have library identifier, their should be process carefully.
@@ -211,7 +210,7 @@
     (let* ([linkage (workspace-file-linkage workspace-instance)]
         [root-file-node (workspace-file-node workspace-instance)]
         [root-library-node (workspace-library-node workspace-instance)]
-        [library-identifiers-list (get-library-identifiers-list (file-node-document target-file-node))])
+        [library-identifiers-list (get-library-identifiers-list (file-node-document target-file-node) (workspace-top-environment workspace-instance))])
       (if (null? library-identifiers-list)
         (init-references workspace-instance `((,(file-node-path target-file-node))))
         (let* ([path (refresh-file-linkage&get-refresh-path linkage root-library-node target-file-node (document-index-node-list (file-node-document target-file-node)) library-identifiers-list)]
@@ -321,15 +320,16 @@
 
 (define init-library-node
   (case-lambda 
-    [(file-node) (init-library-node file-node (make-library-node '() '() '() '())) ]
-    [(file-node root-library-node) 
+    [(file-node) (init-library-node file-node 'r6rs (make-library-node '() '() '() '()) )]
+    [(file-node top-environment) (init-library-node file-node top-environment (make-library-node '() '() '() '()))]
+    [(file-node top-environment root-library-node)
       (if (file-node-folder? file-node)
         (map 
-          (lambda (child-node) (init-library-node child-node root-library-node))
+          (lambda (child-node) (init-library-node child-node top-environment root-library-node))
           (file-node-children file-node))
         (map 
           (lambda (library-identifiers) (generate-library-node library-identifiers root-library-node file-node))
-          (get-library-identifiers-list (file-node-document file-node))))
+          (get-library-identifiers-list (file-node-document file-node) top-environment)))
       root-library-node]))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

From 3c700deed1e7045e50a3a6291abfe30cd68a7880 Mon Sep 17 00:00:00 2001
From: VSteveHL <hzq1283014604@163.com>
Date: Thu, 17 Jul 2025 10:02:17 +0800
Subject: [PATCH 5/6] revert to previous status, change
 tests/analysis/dependency/rules/test-library-import.sps

---
 analysis/dependency/rules/library-import.sls            | 2 +-
 tests/analysis/dependency/rules/test-library-import.sps | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/analysis/dependency/rules/library-import.sls b/analysis/dependency/rules/library-import.sls
index fcdf7a2b..7b5763ca 100644
--- a/analysis/dependency/rules/library-import.sls
+++ b/analysis/dependency/rules/library-import.sls
@@ -18,7 +18,7 @@
         [expression (annotation-stripped ann)])
       (match expression
         [('library _ **1 ) (map match-import (index-node-children index-node))]
-        [('define-library _ **1 ) (map match-import (index-node-children index-node))]
+        ; [('define-library _ **1 ) (map match-import (index-node-children index-node))]
         [else (list (match-import index-node))]))))
 
 (define (match-import index-node)
diff --git a/tests/analysis/dependency/rules/test-library-import.sps b/tests/analysis/dependency/rules/test-library-import.sps
index e4106c64..743e05ab 100755
--- a/tests/analysis/dependency/rules/test-library-import.sps
+++ b/tests/analysis/dependency/rules/test-library-import.sps
@@ -12,6 +12,7 @@
     (scheme-langserver virtual-file-system index-node)
 
     (scheme-langserver analysis dependency rules library-import)
+    (scheme-langserver analysis dependency rules library-import-r7rs)
     (scheme-langserver analysis package-manager akku)
     (scheme-langserver analysis workspace)
     (scheme-langserver analysis dependency file-linkage))
@@ -31,13 +32,13 @@
 (test-begin "library-import-process for r7rs liii")
     (let* ([root-file-node (init-virtual-file-system "./tests/resources/r7rs/liii/rich-vector.scm.txt" '() (lambda (fuzzy) #t) 'r7rs)]
             [root-index-nodes (document-index-node-list (file-node-document root-file-node))])
-        (test-equal '((liii string) (liii hash-table) (liii sort) (liii list) (liii vector) (liii oop) (srfi srfi-8)) (car (map library-import-process root-index-nodes))))
+        (test-equal '((liii string) (liii hash-table) (liii sort) (liii list) (liii vector) (liii oop) (srfi srfi-8)) (car (map library-import-process-r7rs root-index-nodes))))
 (test-end)
 
 (test-begin "library-import-process for r7rs srfi")
     (let* ([root-file-node (init-virtual-file-system "./tests/resources/r7rs/srfi/sicp.scm.txt" '() (lambda (fuzzy) #t) 'r7rs)]
             [root-index-nodes (document-index-node-list (file-node-document root-file-node))])
-        (test-equal '((srfi srfi-216)) (car (map library-import-process root-index-nodes))))
+        (test-equal '((srfi srfi-216)) (car (map library-import-process-r7rs root-index-nodes))))
 (test-end)
 
 (exit (if (zero? (test-runner-fail-count (test-runner-get))) 0 1))

From 8b776544bb3f1f9d7168139c6ebfa4ed90a922ca Mon Sep 17 00:00:00 2001
From: VSteveHL <hzq1283014604@163.com>
Date: Thu, 17 Jul 2025 10:50:15 +0800
Subject: [PATCH 6/6] modify many files to apply library-import-process-r7rs
 add tests for r7rs in tests/analysis/dependency/test-file-linkage.sps

---
 analysis/dependency/file-linkage.sls          | 179 ++++++++++--------
 analysis/workspace.sls                        |   8 +-
 .../analysis/dependency/test-file-linkage.sps |  30 +++
 tests/resources/r7rs/srfi/srfi-8.scm.txt      |  28 +++
 4 files changed, 161 insertions(+), 84 deletions(-)
 create mode 100644 tests/resources/r7rs/srfi/srfi-8.scm.txt

diff --git a/analysis/dependency/file-linkage.sls b/analysis/dependency/file-linkage.sls
index c811f9ee..95a303dc 100644
--- a/analysis/dependency/file-linkage.sls
+++ b/analysis/dependency/file-linkage.sls
@@ -25,6 +25,7 @@
     (scheme-langserver analysis util)
 
     (scheme-langserver analysis dependency rules library-import)
+    (scheme-langserver analysis dependency rules library-import-r7rs)
     (scheme-langserver analysis dependency rules load)
 
     (scheme-langserver util dedupe)
@@ -42,13 +43,16 @@
     (mutable id->path-map)
     (mutable matrix)))
 
-(define (init-file-linkage root-file-node root-library-node)
-  (let ([id->path-map (make-eq-hashtable)]
-        [path->id-map (make-hashtable string-hash equal?)])
-    (init-maps root-library-node id->path-map path->id-map)
-    (let ([matrix (make-vector (* (hashtable-size id->path-map) (hashtable-size id->path-map)))])
-      (init-matrix root-library-node root-file-node root-library-node path->id-map matrix)
-      (make-file-linkage path->id-map id->path-map matrix))))
+(define init-file-linkage
+  (case-lambda
+    [(root-file-node root-library-node) (init-file-linkage root-file-node root-library-node 'r6rs)]
+    [(root-file-node root-library-node top-environment)
+      (let ([id->path-map (make-eq-hashtable)]
+            [path->id-map (make-hashtable string-hash equal?)])
+        (init-maps root-library-node id->path-map path->id-map)
+        (let ([matrix (make-vector (* (hashtable-size id->path-map) (hashtable-size id->path-map)))])
+          (init-matrix root-library-node root-file-node root-library-node path->id-map matrix top-environment)
+          (make-file-linkage path->id-map id->path-map matrix)))]))
 
 (define (init-maps current-library-node id->path-map path->id-map)
   (let loop ([file-nodes (library-node-file-nodes current-library-node)])
@@ -59,41 +63,45 @@
         (loop (cdr file-nodes)))))
   (map (lambda (node) (init-maps node id->path-map path->id-map)) (library-node-children current-library-node)))
 
-(define (refresh-file-linkage&get-refresh-path linkage root-library-node file-node new-index-node-list new-library-identifier-list)
-  (let* ([path (file-node-path file-node)]
-      [path->id-map (file-linkage-path->id-map linkage)]
-      [id->path-map (file-linkage-id->path-map linkage)]
-      [old-node-count (sqrt (vector-length (file-linkage-matrix linkage)))]
-      [id (if (hashtable-ref path->id-map path #f)
-        (hashtable-ref path->id-map path #f)
-        (if (null? new-library-identifier-list)
-          '()
-          (begin
-            (hashtable-set! path->id-map path old-node-count)
-            (hashtable-set! id->path-map old-node-count path)
-            (file-linkage-matrix-set! linkage (matrix-expand (file-linkage-matrix linkage)))
-            old-node-count)))]
-      [reference-id-to (if (null? id) '() (filter (lambda (inner-id) (not (= inner-id id))) (linkage-matrix-to-recursive (file-linkage-matrix linkage) id)))]
-      [reference-id-from (if (null? id) '() (filter (lambda (inner-id) (not (= inner-id id))) (linkage-matrix-from-recursive (file-linkage-matrix linkage) id)))]
-      [matrix (file-linkage-matrix linkage)]
-      [old-imported-file-ids
-        (map 
-          (lambda(p) (hashtable-ref path->id-map p #f)) 
-          (get-reference-path-from linkage path))]
-      [new-imported-file-ids
-        (map 
-          (lambda(p) (hashtable-ref path->id-map p #f)) 
-          (apply append 
+(define refresh-file-linkage&get-refresh-path
+  (case-lambda
+    [(linkage root-library-node file-node new-index-node-list new-library-identifier-list)
+      (refresh-file-linkage&get-refresh-path linkage root-library-node file-node new-index-node-list new-library-identifier-list 'r6rs)]
+    [(linkage root-library-node file-node new-index-node-list new-library-identifier-list top-environment)
+      (let* ([path (file-node-path file-node)]
+          [path->id-map (file-linkage-path->id-map linkage)]
+          [id->path-map (file-linkage-id->path-map linkage)]
+          [old-node-count (sqrt (vector-length (file-linkage-matrix linkage)))]
+          [id (if (hashtable-ref path->id-map path #f)
+            (hashtable-ref path->id-map path #f)
+            (if (null? new-library-identifier-list)
+              '()
+              (begin
+                (hashtable-set! path->id-map path old-node-count)
+                (hashtable-set! id->path-map old-node-count path)
+                (file-linkage-matrix-set! linkage (matrix-expand (file-linkage-matrix linkage)))
+                old-node-count)))]
+          [reference-id-to (if (null? id) '() (filter (lambda (inner-id) (not (= inner-id id))) (linkage-matrix-to-recursive (file-linkage-matrix linkage) id)))]
+          [reference-id-from (if (null? id) '() (filter (lambda (inner-id) (not (= inner-id id))) (linkage-matrix-from-recursive (file-linkage-matrix linkage) id)))]
+          [matrix (file-linkage-matrix linkage)]
+          [old-imported-file-ids
             (map 
-              (lambda (index-node) (get-imported-libraries-from-index-node root-library-node index-node))
-              new-index-node-list)))])
-    (if (null? id)
-      ;;todo shrink matrix
-      '()
-      (begin 
-        (map (lambda(row-id) (matrix-set! matrix row-id id 0)) old-imported-file-ids)
-        (map (lambda(column-id) (matrix-set! matrix id column-id 1)) (dedupe new-imported-file-ids))
-        (map (lambda(current-id) (hashtable-ref id->path-map current-id #f)) `(,@reference-id-from ,id ,@reference-id-to))))))
+              (lambda(p) (hashtable-ref path->id-map p #f)) 
+              (get-reference-path-from linkage path))]
+          [new-imported-file-ids
+            (map 
+              (lambda(p) (hashtable-ref path->id-map p #f)) 
+              (apply append 
+                (map 
+                  (lambda (index-node) (get-imported-libraries-from-index-node root-library-node index-node top-environment))
+                  new-index-node-list)))])
+        (if (null? id)
+          ;;todo shrink matrix
+          '()
+          (begin 
+            (map (lambda(row-id) (matrix-set! matrix row-id id 0)) old-imported-file-ids)
+            (map (lambda(column-id) (matrix-set! matrix id column-id 1)) (dedupe new-imported-file-ids))
+            (map (lambda(current-id) (hashtable-ref id->path-map current-id #f)) `(,@reference-id-from ,id ,@reference-id-to)))))]))
 
 (define (get-reference-path-to linkage to-path)
   (let* ([matrix (file-linkage-matrix linkage)]
@@ -234,45 +242,56 @@
     (hashtable-ref (file-linkage-path->id-map linkage) from #f) 
     (hashtable-ref (file-linkage-path->id-map linkage) to #f)))
 
-(define (get-imported-libraries-from-index-node root-library-node index-node)
-  (apply append 
-    (map 
-      (lambda (l) (map file-node-path (library-node-file-nodes l)))
-      (filter (lambda (l) 
-          (if (null? l) #f (not (null? (library-node-file-nodes l)))))
-        (map 
-          (lambda (id) (walk-library id root-library-node))
-          (library-import-process index-node))))))
-
-(define (init-matrix current-library-node root-file-node root-library-node path->id-map matrix)
-  (let loop ([file-nodes (library-node-file-nodes current-library-node)])
-    (if (pair? file-nodes)
-      (let* ([file-node (car file-nodes)]
-          [path (file-node-path file-node)]
-          [imported-libraries 
-            (dedupe (apply append 
-              (map (lambda (index-node) (get-imported-libraries-from-index-node root-library-node index-node))
-                (document-index-node-list (file-node-document file-node)))))]
-          [loaded-files 
-            (dedupe (apply append 
-              (map (lambda (index-node) (load-process root-file-node (file-node-document file-node) index-node))
-                (document-index-node-list (file-node-document file-node)))))])
-
-        (map (lambda (imported-library-path) 
-                (if (not (null? imported-library-path))
-                  (matrix-set! matrix 
-                    (hashtable-ref path->id-map path #f) 
-                    (hashtable-ref path->id-map imported-library-path #f))))
-          imported-libraries)
+(define get-imported-libraries-from-index-node
+  (case-lambda
+    [(root-library-node index-node) (get-imported-libraries-from-index-node root-library-node index-node 'r6rs)]
+    [(root-library-node index-node top-environment)
+      (let ([func (case top-environment
+                    ['r6rs library-import-process]
+                    ['r7rs library-import-process-r7rs])])
+        (apply append 
+          (map 
+            (lambda (l) (map file-node-path (library-node-file-nodes l)))
+            (filter (lambda (l) 
+                (if (null? l) #f (not (null? (library-node-file-nodes l)))))
+              (map 
+                (lambda (id) (walk-library id root-library-node))
+                (func index-node))))))]))
 
-        (map (lambda (file-node) 
-                (matrix-set! matrix 
-                  (hashtable-ref path->id-map path #f) 
-                  (hashtable-ref path->id-map (file-node-path file-node) #f)))
-          loaded-files)
+(define init-matrix
+  (case-lambda
+    [(current-library-node root-file-node root-library-node path->id-map matrix) (init-matrix current-library-node root-file-node root-library-node path->id-map matrix 'r6rs)]
+    [(current-library-node root-file-node root-library-node path->id-map matrix top-environment)
+      (let loop ([file-nodes (library-node-file-nodes current-library-node)])
+        (if (pair? file-nodes)
+          (let* ([file-node (car file-nodes)]
+              [path (file-node-path file-node)]
+              [imported-libraries 
+                (dedupe (apply append 
+                  (map (lambda (index-node) (get-imported-libraries-from-index-node root-library-node index-node top-environment))
+                    (document-index-node-list (file-node-document file-node)))))]
+              [loaded-files 
+                (dedupe (apply append 
+                  (map (lambda (index-node) (load-process root-file-node (file-node-document file-node) index-node))
+                    (document-index-node-list (file-node-document file-node)))))])
+    
+            (map (lambda (imported-library-path) 
+                    (if (not (null? imported-library-path))
+                      (matrix-set! matrix 
+                        (hashtable-ref path->id-map path #f) 
+                        (hashtable-ref path->id-map imported-library-path #f))))
+              imported-libraries)
+    
+            (map (lambda (file-node) 
+                    (matrix-set! matrix 
+                      (hashtable-ref path->id-map path #f) 
+                      (hashtable-ref path->id-map (file-node-path file-node) #f)))
+              loaded-files)
+            
+            (loop (cdr file-nodes)))))  
         
-        (loop (cdr file-nodes)))))
-  (map  (lambda (node) 
-          (init-matrix node root-file-node root-library-node path->id-map matrix)) 
-    (library-node-children current-library-node)))
+      (map  (lambda (node) 
+              (init-matrix node root-file-node root-library-node path->id-map matrix top-environment)) 
+        (library-node-children current-library-node))  
+        ]))
 )
\ No newline at end of file
diff --git a/analysis/workspace.sls b/analysis/workspace.sls
index 790d1403..0eb9aa66 100644
--- a/analysis/workspace.sls
+++ b/analysis/workspace.sls
@@ -75,7 +75,7 @@
   (let* ([path (file-node-path (workspace-file-node workspace-instance))]
       [root-file-node (init-virtual-file-system path '() (workspace-facet workspace-instance) (workspace-top-environment workspace-instance))]
       [root-library-node (init-library-node root-file-node (workspace-top-environment workspace-instance))]
-      [file-linkage (init-file-linkage root-file-node root-library-node)]
+      [file-linkage (init-file-linkage root-file-node root-library-node (workspace-top-environment workspace-instance))]
       [batches (get-init-reference-batches file-linkage)])
     (init-references workspace-instance batches)
     (workspace-file-node-set! workspace-instance root-file-node)
@@ -98,7 +98,7 @@
               [else (generate-akku-acceptable-file-filter (string-append path "/.akku/list"))])]
           [root-file-node (init-virtual-file-system path '() facet top-environment)]
           [root-library-node (init-library-node root-file-node top-environment)]
-          [file-linkage (init-file-linkage root-file-node root-library-node)]
+          [file-linkage (init-file-linkage root-file-node root-library-node top-environment)]
           [batches (get-init-reference-batches file-linkage)])
         (init-references root-file-node root-library-node file-linkage threaded? batches type-inference?)
         (make-workspace root-file-node root-library-node file-linkage facet threaded? type-inference? top-environment))]))
@@ -198,7 +198,7 @@
               (if (walk-library library-identifiers root-library-node)
                 (generate-library-node library-identifiers root-library-node target-file-node)))
             new-library-identifiers-list)
-          (workspace-file-linkage-set! workspace-instance (init-file-linkage root-file-node root-library-node))
+          (workspace-file-linkage-set! workspace-instance (init-file-linkage root-file-node root-library-node (workspace-top-environment workspace-instance)))
 ;;For new dependency
           (map (lambda (document) (document-refreshable?-set! document #t))
             (map (lambda (path) (file-node-document (walk-file root-file-node path))) 
@@ -213,7 +213,7 @@
         [library-identifiers-list (get-library-identifiers-list (file-node-document target-file-node) (workspace-top-environment workspace-instance))])
       (if (null? library-identifiers-list)
         (init-references workspace-instance `((,(file-node-path target-file-node))))
-        (let* ([path (refresh-file-linkage&get-refresh-path linkage root-library-node target-file-node (document-index-node-list (file-node-document target-file-node)) library-identifiers-list)]
+        (let* ([path (refresh-file-linkage&get-refresh-path linkage root-library-node target-file-node (document-index-node-list (file-node-document target-file-node)) library-identifiers-list (workspace-top-environment workspace-instance))]
             [path-aheadof `(,@(list-ahead-of path (file-node-path target-file-node)) ,(file-node-path target-file-node))]
             [refreshable-path (filter (lambda (single) (document-refreshable? (file-node-document (walk-file root-file-node single)))) path-aheadof)]
             ;target-file-node may don't have library-identifiers-list
diff --git a/tests/analysis/dependency/test-file-linkage.sps b/tests/analysis/dependency/test-file-linkage.sps
index 73312798..271a62c0 100755
--- a/tests/analysis/dependency/test-file-linkage.sps
+++ b/tests/analysis/dependency/test-file-linkage.sps
@@ -10,6 +10,7 @@
     (scheme-langserver virtual-file-system file-node)
     (scheme-langserver analysis workspace)
     (scheme-langserver analysis package-manager akku)
+    (scheme-langserver analysis package-manager txt-filter)
     (scheme-langserver analysis dependency file-linkage))
 
 (test-begin "init-linkage-matrix")
@@ -41,4 +42,33 @@
             (car paths)))
 (test-end)
 
+(test-begin "init-linkage-matrix-r7rs")
+    (let* ([root-file-node (init-virtual-file-system (current-directory) '() (generate-txt-file-filter) 'r7rs)]
+            [root-library-node (init-library-node root-file-node 'r7rs)]
+            [file-linkage (init-file-linkage root-file-node root-library-node 'r7rs)]
+            [from-path (string-append (current-directory) "/tests/resources/r7rs/liii/rich-vector.scm.txt")]
+            [to-path (string-append (current-directory) "/tests/resources/r7rs/srfi/srfi-8.scm.txt")])
+        (test-equal 1 (file-linkage-take file-linkage from-path to-path)))
+(test-end)
+
+(test-begin "get-init-inference-path-r7rs")
+    (let* ([root-file-node (init-virtual-file-system (current-directory) '() (generate-txt-file-filter) 'r7rs)]
+            [root-library-node (init-library-node root-file-node 'r7rs)]
+            [file-linkage (init-file-linkage root-file-node root-library-node 'r7rs)]
+            [paths (apply append (get-init-reference-batches file-linkage))]
+            [target-path (string-append (current-directory) "/tests/resources/r7rs/scheme/base.scm.txt")])
+        (test-equal target-path (find (lambda (p) (equal? target-path p)) paths)))
+(test-end)
+
+(test-begin "file-linkage-to-r7rs")
+    (let* ([root-file-node (init-virtual-file-system (current-directory) '() (generate-txt-file-filter) 'r7rs)]
+            [root-library-node (init-library-node root-file-node 'r7rs)]
+            [file-linkage (init-file-linkage root-file-node root-library-node 'r7rs)]
+            [to-path (string-append (current-directory) "/tests/resources/r7rs/srfi/srfi-8.scm.txt")]
+            [paths (file-linkage-to file-linkage to-path)])
+        (test-equal 
+            (string-append (current-directory) "/tests/resources/r7rs/liii/rich-vector.scm.txt")
+            (car paths)))
+(test-end)
+
 (exit (if (zero? (test-runner-fail-count (test-runner-get))) 0 1))
diff --git a/tests/resources/r7rs/srfi/srfi-8.scm.txt b/tests/resources/r7rs/srfi/srfi-8.scm.txt
new file mode 100644
index 00000000..c8c952ff
--- /dev/null
+++ b/tests/resources/r7rs/srfi/srfi-8.scm.txt
@@ -0,0 +1,28 @@
+;
+; Copyright (C) 2024 The Goldfish Scheme Authors
+;
+; Licensed under the Apache License, Version 2.0 (the "License");
+; you may not use this file except in compliance with the License.
+; You may obtain a copy of the License at
+;
+; http://www.apache.org/licenses/LICENSE-2.0
+;
+; Unless required by applicable law or agreed to in writing, software
+; distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+; WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+; License for the specific language governing permissions and limitations
+; under the License.
+;
+
+(define-library (srfi srfi-8)
+(export receive)              
+(begin
+
+(define-macro (receive formals expression . body)
+  `(call-with-values
+    (lambda () (values ,expression))
+    (lambda ,formals ,@body)))
+
+) ; end of begin
+) ; end of define-library
+