========================================
   Guile-Zlib 0.2.2: ./test-suite.log
========================================

# TOTAL: 141
# PASS:  140
# SKIP:  1
# XFAIL: 0
# FAIL:  0
# XPASS: 0
# ERROR: 0

System information (uname -a): Linux 6.8.12-11-pve #1 SMP PREEMPT_DYNAMIC PMX 6.8.12-11 (2025-05-22T09:39Z) x86_64
Distribution information (/etc/os-release):
NAME="Alpine Linux"
ID=alpine
VERSION_ID=3.22.2
PRETTY_NAME="Alpine Linux v3.22"
HOME_URL="https://alpinelinux.org/"
BUG_REPORT_URL="https://gitlab.alpinelinux.org/alpine/aports/-/issues"

.. contents:: :depth: 2

SKIP: tests/zlib
================

random seed for tests: 1763683662
test-name: port encoding is inherited
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:56
source:
+ (test-equal
+   "port encoding is inherited"
+   str
+   (let ((bv (call-with-output-bytevector
+               (lambda (o)
+                 (set-port-encoding! o "UTF-8")
+                 (call-with-zlib-output-port
+                   o
+                   (lambda (o)
+                     (set-port-encoding! o "UTF-8")
+                     (write str o)))))))
+     (with-fluids
+       ((%default-port-encoding "UTF-8"))
+       (call-with-input-bytevector
+         bv
+         (lambda (o)
+           (set-port-encoding! o "UTF-8")
+           (call-with-zlib-input-port o read))))))
expected-value: "αβγ"
actual-value: "αβγ"
result: PASS

test-name: compression/decompression pipe
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:76
source:
+ (test-assert
+   "compression/decompression pipe"
+   (let ((data (random-bytevector
+                 (+ (random 10000) (* 20 1024)))))
+     (match (pipe)
+            ((parent . child)
+             (match (primitive-fork)
+                    (0
+                     (dynamic-wind
+                       (const #t)
+                       (lambda ()
+                         (close-port parent)
+                         (call-with-gzip-output-port
+                           child
+                           (lambda (port) (put-bytevector port data))))
+                       (lambda () (primitive-exit 0))))
+                    (pid (begin
+                           (close-port child)
+                           (let ((received
+                                   (call-with-gzip-input-port
+                                     parent
+                                     (lambda (port) (get-bytevector-all port))
+                                     #:buffer-size
+                                     (* 64 1024))))
+                             (match (waitpid pid)
+                                    ((_ . status)
+                                     (and (zero? status)
+                                          (port-closed? parent)
+                                          (bytevector=?
+                                            received
+                                            data))))))))))))
test-name: port encoding is inherited
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:56
source:
+ (test-equal
+   "port encoding is inherited"
+   str
+   (let ((bv (call-with-output-bytevector
+               (lambda (o)
+                 (set-port-encoding! o "UTF-8")
+                 (call-with-zlib-output-port
+                   o
+                   (lambda (o)
+                     (set-port-encoding! o "UTF-8")
+                     (write str o)))))))
+     (with-fluids
+       ((%default-port-encoding "UTF-8"))
+       (call-with-input-bytevector
+         bv
+         (lambda (o)
+           (set-port-encoding! o "UTF-8")
+           (call-with-zlib-input-port o read))))))
expected-value: "αβγ"
actual-value: "αβγ"
result: PASS

test-name: compression/decompression pipe
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:76
source:
+ (test-assert
+   "compression/decompression pipe"
+   (let ((data (random-bytevector
+                 (+ (random 10000) (* 20 1024)))))
+     (match (pipe)
+            ((parent . child)
+             (match (primitive-fork)
+                    (0
+                     (dynamic-wind
+                       (const #t)
+                       (lambda ()
+                         (close-port parent)
+                         (call-with-gzip-output-port
+                           child
+                           (lambda (port) (put-bytevector port data))))
+                       (lambda () (primitive-exit 0))))
+                    (pid (begin
+                           (close-port child)
+                           (let ((received
+                                   (call-with-gzip-input-port
+                                     parent
+                                     (lambda (port) (get-bytevector-all port))
+                                     #:buffer-size
+                                     (* 64 1024))))
+                             (match (waitpid pid)
+                                    ((_ . status)
+                                     (and (zero? status)
+                                          (port-closed? parent)
+                                          (bytevector=?
+                                            received
+                                            data))))))))))))
actual-value: #t
result: PASS

test-name: gzip output port, error
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:106
source:
+ (test-assert
+   "gzip output port, error"
+   (catch 'zlib-error
+          (lambda ()
+            (call-with-output-file
+              "/dev/full"
+              (lambda (p)
+                (let ((p (make-gzip-output-port p)))
+                  (put-bytevector p (random-bytevector 262140))
+                  (force-output p)
+                  (close-port p))))
+            #f)
+          (lambda (key ret code message . _)
+            (and (= code Z_ERRNO)
+                 (string-contains message "No space left")
+                 (string-contains
+                   (call-with-output-string
+                     (lambda (port)
+                       (print-exception
+                         port
+                         #f
+                         key
+                         (list key ret code message))))
+                   "No space left")))))
result: SKIP

test-name: raw compress/decompress
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:125
source:
+ (test-assert
+   "raw compress/decompress"
+   (let* ((data (random-bytevector
+                  (+ (random 10000) (* 20 1024))))
+          (cdata (compress data))
+          (ucdata (uncompress cdata)))
+     (equal? data ucdata)))
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 450)

;;; (sizes 450 vs 450)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 506)

;;; (sizes 506 vs 506)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 445)

;;; (sizes 445 vs 445)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 301)

;;; (sizes 301 vs 301)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 446)

;;; (sizes 446 vs 446)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 485)

;;; (sizes 485 vs 485)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 426)

;;; (sizes 426 vs 426)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 428)

;;; (sizes 428 vs 428)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: deflate, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 259)

;;; (sizes 259 vs 259)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 261)

;;; (sizes 261 vs 261)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 499)

;;; (sizes 499 vs 499)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 267)

;;; (sizes 267 vs 267)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 419)

;;; (sizes 419 vs 419)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 409)

;;; (sizes 409 vs 409)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 320)

;;; (sizes 320 vs 320)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 492)

;;; (sizes 492 vs 492)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 265)

;;; (sizes 265 vs 265)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: zlib, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 426)

;;; (sizes 426 vs 426)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 257)

;;; (sizes 257 vs 257)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 317)

;;; (sizes 317 vs 317)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 344)

;;; (sizes 344 vs 344)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 315)

;;; (sizes 315 vs 315)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 462)

;;; (sizes 462 vs 462)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 461)

;;; (sizes 461 vs 461)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 273)

;;; (sizes 273 vs 273)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 405)

;;; (sizes 405 vs 405)
actual-value: #t
result: PASS

test-name: zlib ports [size: 256, format: gzip, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 370)

;;; (sizes 370 vs 370)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1225)

;;; (sizes 1225 vs 1225)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1137)

;;; (sizes 1137 vs 1137)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1956)

;;; (sizes 1956 vs 1956)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1707)

;;; (sizes 1707 vs 1707)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1209)

;;; (sizes 1209 vs 1209)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1765)

;;; (sizes 1765 vs 1765)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1270)

;;; (sizes 1270 vs 1270)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1154)

;;; (sizes 1154 vs 1154)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: deflate, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1899)

;;; (sizes 1899 vs 1899)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1062)

;;; (sizes 1062 vs 1062)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1642)

;;; (sizes 1642 vs 1642)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1788)

;;; (sizes 1788 vs 1788)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1653)

;;; (sizes 1653 vs 1653)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1437)

;;; (sizes 1437 vs 1437)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1413)

;;; (sizes 1413 vs 1413)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1951)

;;; (sizes 1951 vs 1951)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1046)

;;; (sizes 1046 vs 1046)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: zlib, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1743)

;;; (sizes 1743 vs 1743)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1318)

;;; (sizes 1318 vs 1318)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1455)

;;; (sizes 1455 vs 1455)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1090)

;;; (sizes 1090 vs 1090)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 2022)

;;; (sizes 2022 vs 2022)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1966)

;;; (sizes 1966 vs 1966)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1284)

;;; (sizes 1284 vs 1284)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1854)

;;; (sizes 1854 vs 1854)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1677)

;;; (sizes 1677 vs 1677)
actual-value: #t
result: PASS

test-name: zlib ports [size: 1024, format: gzip, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 1656)

;;; (sizes 1656 vs 1656)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 6953)

;;; (sizes 6953 vs 6953)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 6144)

;;; (sizes 6144 vs 6144)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7788)

;;; (sizes 7788 vs 7788)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7656)

;;; (sizes 7656 vs 7656)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 5328)

;;; (sizes 5328 vs 5328)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 5517)

;;; (sizes 5517 vs 5517)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 5416)

;;; (sizes 5416 vs 5416)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 6995)

;;; (sizes 6995 vs 6995)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: deflate, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7959)

;;; (sizes 7959 vs 7959)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 4352)

;;; (sizes 4352 vs 4352)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 4203)

;;; (sizes 4203 vs 4203)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 5427)

;;; (sizes 5427 vs 5427)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 6463)

;;; (sizes 6463 vs 6463)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7493)

;;; (sizes 7493 vs 7493)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 5269)

;;; (sizes 5269 vs 5269)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 6812)

;;; (sizes 6812 vs 6812)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7216)

;;; (sizes 7216 vs 7216)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: zlib, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 4570)

;;; (sizes 4570 vs 4570)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7098)

;;; (sizes 7098 vs 7098)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 6785)

;;; (sizes 6785 vs 6785)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7493)

;;; (sizes 7493 vs 7493)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 7978)

;;; (sizes 7978 vs 7978)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 4632)

;;; (sizes 4632 vs 4632)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 6911)

;;; (sizes 6911 vs 6911)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 8070)

;;; (sizes 8070 vs 8070)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 5268)

;;; (sizes 5268 vs 5268)
actual-value: #t
result: PASS

test-name: zlib ports [size: 4096, format: gzip, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 4598)

;;; (sizes 4598 vs 4598)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 18501)

;;; (sizes 18501 vs 18501)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 26900)

;;; (sizes 26900 vs 26900)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 17136)

;;; (sizes 17136 vs 17136)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 22626)

;;; (sizes 22626 vs 22626)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 31027)

;;; (sizes 31027 vs 31027)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 25862)

;;; (sizes 25862 vs 25862)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 18128)

;;; (sizes 18128 vs 18128)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 32287)

;;; (sizes 32287 vs 32287)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: deflate, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 19740)

;;; (sizes 19740 vs 19740)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 21681)

;;; (sizes 21681 vs 21681)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 29763)

;;; (sizes 29763 vs 29763)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 18932)

;;; (sizes 18932 vs 18932)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 20575)

;;; (sizes 20575 vs 20575)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 25160)

;;; (sizes 25160 vs 25160)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 31680)

;;; (sizes 31680 vs 31680)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 27057)

;;; (sizes 27057 vs 27057)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 30946)

;;; (sizes 30946 vs 30946)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: zlib, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 32378)

;;; (sizes 32378 vs 32378)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 29064)

;;; (sizes 29064 vs 29064)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 19531)

;;; (sizes 19531 vs 19531)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 30291)

;;; (sizes 30291 vs 30291)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 30737)

;;; (sizes 30737 vs 30737)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 23787)

;;; (sizes 23787 vs 23787)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 31876)

;;; (sizes 31876 vs 31876)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 29647)

;;; (sizes 29647 vs 29647)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 30216)

;;; (sizes 30216 vs 30216)
actual-value: #t
result: PASS

test-name: zlib ports [size: 16384, format: gzip, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 26816)

;;; (sizes 26816 vs 26816)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 316368)

;;; (sizes 316368 vs 316368)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 437695)

;;; (sizes 437695 vs 437695)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 412111)

;;; (sizes 412111 vs 412111)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 437944)

;;; (sizes 437944 vs 437944)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 513717)

;;; (sizes 513717 vs 513717)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 318098)

;;; (sizes 318098 vs 318098)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 272099)

;;; (sizes 272099 vs 272099)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 514307)

;;; (sizes 514307 vs 514307)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: deflate, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 318229)

;;; (sizes 318229 vs 318229)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 437857)

;;; (sizes 437857 vs 437857)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 429472)

;;; (sizes 429472 vs 429472)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 343313)

;;; (sizes 343313 vs 343313)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 519092)

;;; (sizes 519092 vs 519092)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 319514)

;;; (sizes 319514 vs 319514)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 436919)

;;; (sizes 436919 vs 436919)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 483473)

;;; (sizes 483473 vs 483473)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 429700)

;;; (sizes 429700 vs 429700)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: zlib, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 266704)

;;; (sizes 266704 vs 266704)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 1]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 385968)

;;; (sizes 385968 vs 385968)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 2]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 371525)

;;; (sizes 371525 vs 371525)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 3]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 301680)

;;; (sizes 301680 vs 301680)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 4]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 262512)

;;; (sizes 262512 vs 262512)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 5]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 441189)

;;; (sizes 441189 vs 441189)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 6]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 295088)

;;; (sizes 295088 vs 295088)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 7]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         random seed for tests: 1763683662
(bytevector=? data2 data)))))

;;; (size 413657)

;;; (sizes 413657 vs 413657)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 8]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 409033)

;;; (sizes 409033 vs 409033)
actual-value: #t
result: PASS

test-name: zlib ports [size: 262144, format: gzip, level: 9]
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:132
source:
+ (test-assert
+   (format
+     #f
+     "zlib ports [size: ~a, format: ~a, level: ~a]"
+     n
+     fmt
+     level)
+   (let* ((size (pk 'size (+ (random n %seed) n)))
+          (data (random-bytevector size)))
+     (let*-values
+       (((port get) (open-bytevector-output-port))
+        ((compressed)
+         (make-zlib-output-port
+           port
+           #:level
+           level
+           #:format
+           fmt)))
+       (put-bytevector compressed data)
+       (close-port compressed)
+       (let ((data2 (get-bytevector-all
+                      (make-zlib-input-port
+                        (open-bytevector-input-port (get))
+                        #:format
+                        fmt))))
+         (pk 'sizes size 'vs (bytevector-length data2))
+         (bytevector=? data2 data)))))

;;; (size 271051)

;;; (sizes 271051 vs 271051)
actual-value: #t
result: PASS

test-name: uncompress: High compression ratio
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:167
source:
+ (test-equal
+   "uncompress: High compression ratio"
+   data-length
+   (let ((compressed-data (compress data)))
+     (bytevector-length (uncompress compressed-data))))
expected-value: 100000
actual-value: 100000
result: PASS

test-name: uncompress: input size times 1.5 is a fraction
location: /home/udu/aports/community/guile-zlib/src/guile-zlib/tests/zlib.scm:174
source:
+ (test-equal
+   "uncompress: input size times 1.5 is a fraction"
+   #vu8(0)
+   (uncompress bv))
expected-value: #vu8(0)
actual-value: #vu8(0)
result: PASS