;-*- Mode:     Lisp -*-
;;;; Author:   Paul Dietz
;;;; Created:  Thu Feb 12 04:34:42 2004
;;;; Contains: Tests of MAKE-ECHO-STREAM

(in-package :cl-test)

(deftest make-echo-stream.1
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (read-char s)
     (get-output-stream-string os)))
  #\f "f")

(deftest make-echo-stream.2
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (get-output-stream-string os))
  "")

(deftest make-echo-stream.3
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values (read-line s nil)
	    (get-output-stream-string os)))
  "foo" "foo")

;;; Tests of READ-BYTE on echo streams

(deftest make-echo-stream.4
  (let ((pn #p"tmp.dat")
	(pn2 #p"tmp2.dat")
	(element-type '(unsigned-byte 8)))
    (with-open-file (os pn
			:direction :output
			:element-type element-type
			:if-exists :supersede)
		    (loop for x in '(2 3 5 7 11)
			  do (write-byte x os)))
    (with-open-file
     (is pn :direction :input :element-type element-type)
     (values
      (with-open-file
       (os pn2 :direction :output :if-exists :supersede
	   :element-type element-type)
       (let ((s (make-echo-stream is os)))
	 (loop repeat 6 collect (read-byte s nil :eof1))))
      (with-open-file
       (s pn2 :direction :input :element-type element-type)
       (loop repeat 6 collect (read-byte s nil :eof2))))))
  (2 3 5 7 11 :eof1)
  (2 3 5 7 11 :eof2))

(deftest make-echo-stream.5
  (let ((pn #p"tmp.dat")
	(pn2 #p"tmp2.dat")
	(element-type '(unsigned-byte 8)))
    (with-open-file (os pn
			:direction :output
			:element-type element-type
			:if-exists :supersede)
		    (loop for x in '(2 3 5 7 11)
			  do (write-byte x os)))
    (with-open-file
     (is pn :direction :input :element-type element-type)
     (values
      (with-open-file
       (os pn2 :direction :output :if-exists :supersede
	   :element-type element-type)
       (let ((s (make-echo-stream is os)))
	 (loop repeat 6 collect (read-byte s nil 100))))
      (with-open-file
       (s pn2 :direction :input :element-type element-type)
       (loop repeat 6 collect (read-byte s nil 200))))))
  (2 3 5 7 11 100)
  (2 3 5 7 11 200))

(deftest make-echo-stream.6
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values (coerce (loop repeat 3 collect (read-char-no-hang s)) 'string)
	    (get-output-stream-string os)))
  "foo" "foo")

(deftest make-echo-stream.7
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values (coerce (loop repeat 4 collect (read-char-no-hang s nil '#\z))
		    'string)
	    (get-output-stream-string os)))
  "fooz" "foo")

;;; peek-char + echo streams is tested in peek-char.lsp
;;; unread-char + echo streams is tested in unread-char.lsp

(deftest make-echo-stream.8
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os))
	 (x (copy-seq "xxxxxx")))
    (values
     (read-sequence x s)
     x
     (get-output-stream-string os)))
  3
  "fooxxx"
  "foo")

(deftest make-echo-stream.9
  (let ((pn #p"tmp.dat")
	(pn2 #p"tmp2.dat")
	(element-type '(unsigned-byte 8)))
    (with-open-file (os pn
			:direction :output
			:element-type element-type
			:if-exists :supersede)
		    (loop for x in '(2 3 5 7 11)
			  do (write-byte x os)))
    (with-open-file
     (is pn :direction :input :element-type element-type)
     (values
      (with-open-file
       (os pn2 :direction :output :if-exists :supersede
	   :element-type element-type)
       (let ((s (make-echo-stream is os))
	     (x (vector 0 0 0 0 0 0 0 0)))
	 (list (read-sequence x s)
	       x)))
      (with-open-file
       (s pn2 :direction :input :element-type element-type)
       (loop repeat 8 collect (read-byte s nil nil))))))
  (5 #(2 3 5 7 11 0 0 0))
  (2 3 5 7 11 nil nil nil))

(deftest make-echo-stream.10
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (notnot (open-stream-p s))
     (close s)
     (open-stream-p s)
     (notnot (open-stream-p is))
     (notnot (open-stream-p os))))
  t t nil t t)

(deftest make-echo-stream.11
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (notnot (listen s))
     (read-char s)
     (notnot (listen s))
     (read-char s)
     (notnot (listen s))
     (read-char s)
     (listen s)))
  t #\f t #\o t #\o nil)

(deftest make-echo-stream.12
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (notnot (streamp s))
     (notnot (typep s 'stream))
     (notnot (typep s 'echo-stream))
     (notnot (input-stream-p s))
     (notnot (output-stream-p s))
     (notnot (stream-element-type s))))
  t t t t t t)

;;; FIXME
;;; Add tests for clear-input, file-position(?)
;;;  Also, add tests for output operations (since echo-streams are
;;;   bidirectional)

(deftest make-echo-stream.13
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (write-char #\0 s)
     (close s)
     (get-output-stream-string os)))
  #\0 t "0")

(deftest make-echo-stream.14
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (terpri s)
     (close s)
     (get-output-stream-string os)))
  nil t #.(string #\Newline))

(deftest make-echo-stream.15
  (let ((pn #p"tmp.dat")
	(pn2 #p"tmp2.dat")
	(element-type '(unsigned-byte 8)))
    (with-open-file (os pn
			:direction :output
			:element-type element-type
			:if-exists :supersede))
    (with-open-file
     (is pn :direction :input :element-type element-type)
     (values
      (with-open-file
       (os pn2 :direction :output :if-exists :supersede
	   :element-type element-type)
       (let ((s (make-echo-stream is os))
	     (x (mapcar #'char-code (coerce "abcdefg" 'list))))
	 (loop for b in x do
	       (assert (equal (list b)
			      (multiple-value-list (write-byte b s)))))
	 (close s)))))
    (with-open-file
     (is pn2 :direction :input :element-type element-type)
     (let ((x (vector 0 0 0 0 0 0 0)))
       (read-sequence x is)
       (values
	(read-byte is nil :done)
	(map 'string #'code-char x)))))
  :done
  "abcdefg")

(deftest make-echo-stream.16
  (let ((pn #p"tmp.dat")
	(pn2 #p"tmp2.dat")
	(element-type '(unsigned-byte 8)))
    (with-open-file (os pn
			:direction :output
			:element-type element-type
			:if-exists :supersede))
    (with-open-file
     (is pn :direction :input :element-type element-type)
     (values
      (with-open-file
       (os pn2 :direction :output :if-exists :supersede
	   :element-type element-type)
       (let ((s (make-echo-stream is os))
	     (x (map 'vector #'char-code "abcdefg")))
	 (assert (equal (multiple-value-list (write-sequence x s)) (list x)))
	 (close s)))))
    (with-open-file
     (is pn2 :direction :input :element-type element-type)
     (let ((x (vector 0 0 0 0 0 0 0)))
       (read-sequence x is)
       (values
	(read-byte is nil :done)
	(map 'string #'code-char x)))))
  :done
  "abcdefg")

(deftest make-echo-stream.17
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (write-char #\X s)
     (notnot (fresh-line s))
     (finish-output s)
     (force-output s)
     (close s)
     (get-output-stream-string os)))
 #\X t nil nil t #.(coerce '(#\X #\Newline) 'string))

(deftest make-echo-stream.18
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (write-string "159" s)
     (close s)
     (get-output-stream-string os)))
  "159" t "159")

(deftest make-echo-stream.20
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (write-string "0159X" s :start 1 :end 4)
     (close s)
     (get-output-stream-string os)))
  "0159X" t "159")

(deftest make-echo-stream.21
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (write-line "159" s)
     (close s)
     (get-output-stream-string os)))
  "159" t #.(concatenate 'string "159" (string #\Newline)))

(deftest make-echo-stream.22
  (let* ((is (make-string-input-stream "foo"))
	 (os (make-string-output-stream))
	 (s (make-echo-stream is os)))
    (values
     (write-char #\0 s)
     (clear-output s)))
  #\0 nil)

;;; Error tests

(deftest make-echo-stream.error.1
  (signals-error (make-echo-stream) program-error)
  t)

(deftest make-echo-stream.error.2
  (signals-error (make-echo-stream *standard-input*) program-error)
  t)

(deftest make-echo-stream.error.3
  (signals-error (make-echo-stream *standard-input* *standard-output* nil)
		 program-error)
  t)