(use specialized-io
     numbers
     test)

(define FILENAME "testfile")

(define fixnums '(-3 -2 -1 0 1 2 3 5 7))
(define flonums '(-20.0 -10.1 -0.5 0.0 0.5 10.1 20.0 -2 -1 0 1 2))
(define complexes '(2+2i -1+0.5i -1-1i -2.0-2.0i -0.5+3i 0+5i 0-5i 0.0+9.0i 0 0.1))
(define chars   (string->list "abcdefghijklmnopqrstuvwxyz"))
;;(define strings "oh brave new world!")


(define write-fixnums
  (lambda ()
    (let ((p (open-output-file FILENAME)))
      (let loop ((nums fixnums))
        (cond ((not (null? nums))
               (write-fixnum (car nums) p)
               (newline p)
               (loop (cdr nums)))
              (else
               (close-output-port p)))))))

(define read-fixnums
  (lambda ()
    (test-group "reading fixnums"
      (let ((p (open-input-file FILENAME)))
        (let loop ((nums fixnums))
          (cond ((not (null? nums))
                 (let ((n (read-fixnum p)))
                   (test "read-fixnum" n (car nums)))
                 (loop (cdr nums)))
                (else
                 (close-output-port p))))))))


(define write-flonums
  (lambda ()
    (let ((p (open-output-file FILENAME)))
      (let loop ((nums flonums))
        (cond ((not (null? nums))
               (write-flonum  (car nums) p)
               (newline p)
               (loop (cdr nums)))
              (else
               (close-output-port p)))))))

(define read-flonums
  (lambda ()
    (test-group "reading flonums"
    (let ((p (open-input-file FILENAME)))
      (let loop ((nums flonums))
        (cond ((not (null? nums))
               (let ((n (read-flonum p)))
                 (test "read-flonum" n (car nums)))
               (loop (cdr nums)))
              (else
               (close-output-port p))))))))

(define write-complexes
  (lambda ()
    (let ((p (open-output-file FILENAME)))
      (let loop ((nums complexes))
        (cond ((not (null? nums))
               (write-complex (car nums) p)
               (newline p)
               (loop (cdr nums)))
              (else
               (close-output-port p)))))))

(define read-complexes
  (lambda ()
    (test-group "reading complexes"
    (let ((p (open-input-file FILENAME)))
      (let loop ((nums complexes))
        (cond ((not (null? nums))
               (let ((n (read-complex p)))
                 (test "read-complex" 0.0+0.0i (- n (car nums))))
               (loop (cdr nums)))
              (else
               (close-output-port p))))))))


(define write-chars
  (lambda ()
    (let ((p (open-output-file FILENAME)))
      (let loop ((char-list chars))
        (cond ((not (null? char-list))
               (write-one-char (car char-list) p)
               (loop (cdr char-list)))
              (else
               (close-output-port p)))))))

(define read-chars
  (lambda ()
    (test-group "reading chars"
    (let ((p (open-input-file FILENAME)))
      (let loop ((char-list chars))
        (cond ((not (null? char-list))
               (let ((n (read-one-char p)))
                 (test "read-char" n (car char-list)))
               (loop (cdr char-list)))
              (else
               (close-output-port p))))))))

;;(define write-strings #f)
;;(define read-strings #f)

(test-group "all tests"
            (write-fixnums)
            (read-fixnums)
            
            (write-flonums)
            (read-flonums)

            (write-complexes)
            (read-complexes)
            
            (write-chars)
            (read-chars))