X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fstream.impure.lisp;h=f39e3c01f242341506818c4332b5b185e77834cf;hb=05854d6d554238cf3cfbe2b68e7ae8060f71b536;hp=64d589cd6f7c81549629fc843d7001a016ba0601;hpb=43ed30b023d8ea5d0cd9c6a8928b4169aa0275ef;p=sbcl.git

diff --git a/tests/stream.impure.lisp b/tests/stream.impure.lisp
index 64d589c..f39e3c0 100644
--- a/tests/stream.impure.lisp
+++ b/tests/stream.impure.lisp
@@ -421,16 +421,7 @@
 ;;; writing looong lines. takes way too long and way too much space
 ;;; to test on 64 bit platforms
 #-#.(cl:if (cl:= sb-vm:n-word-bits 64) '(and) '(or))
-(progn
-  (defun write-n-chars (n stream)
-    (format t "~&/writing ~D chars on a single line~%" n)
-    (finish-output t)
-    (loop repeat n
-       do (write-char #\x stream))
-    (terpri stream)
-    n)
-
-  (let ((test "long-lines-write-test.tmp"))
+(let ((test "long-lines-write-test.tmp"))
     (unwind-protect
          (with-open-file (f test
                             :direction :output
@@ -438,9 +429,20 @@
                             :element-type 'character
                             :if-does-not-exist :create
                             :if-exists :supersede)
-         (write-n-chars (+ most-positive-fixnum 7) f))
+           (let* ((n (truncate most-positive-fixnum 16))
+                  (m 18)
+                  (p (* n m))
+                  (buffer (make-string n)))
+             (dotimes (i m)
+               (write-char #\.)
+               (finish-output)
+               (write-sequence buffer f))
+             (assert (= p (sb-impl::fd-stream-char-pos f)))
+             (write-char #\! f)
+             (assert (= (+ 1 p) (sb-impl::fd-stream-char-pos f)))
+             (assert (typep p 'bignum))))
       (when (probe-file test)
-        (delete-file test)))))
+        (delete-file test))))
 
 ;;; read-sequence misreported the amount read and lost position
 (let ((string (make-array (* 3 sb-impl::+ansi-stream-in-buffer-length+)
@@ -467,4 +469,62 @@
     (assert (equal copy string)))
   (delete-file "read-sequence-character-test-data.tmp"))
 
+;;; ANSI-STREAM-OUTPUT-STREAM-P used to assume that a SYNONYM-STREAM's
+;;; target was an ANSI stream, but it could be a user-defined stream,
+;;; e.g., a SLIME stream.
+(defclass user-output-stream (fundamental-output-stream)
+  ())
+
+(let ((*stream* (make-instance 'user-output-stream)))
+  (declare (special *stream*))
+  (with-open-stream (stream (make-synonym-stream '*stream*))
+    (assert (output-stream-p stream))))
+
+(defclass user-input-stream (fundamental-input-stream)
+  ())
+
+(let ((*stream* (make-instance 'user-input-stream)))
+  (declare (special *stream*))
+  (with-open-stream (stream (make-synonym-stream '*stream*))
+    (assert (input-stream-p stream))))
+
+;;; READ-LINE on ANSI-STREAM did not return T for the last line
+;;; (reported by Yoshinori Tahara)
+(let ((pathname "test-read-line-eol"))
+  (with-open-file (out pathname :direction :output :if-exists :supersede)
+    (format out "a~%b"))
+  (let ((result (with-open-file (in pathname)
+                  (list (multiple-value-list (read-line in nil nil))
+                        (multiple-value-list (read-line in nil nil))
+                        (multiple-value-list (read-line in nil nil))))))
+    (delete-file pathname)
+    (assert (equal result '(("a" nil) ("b" t) (nil t))))))
+
+;;; READ-LINE used to work on closed streams because input buffers were left in place
+(with-test (:name :bug-425)
+  ;; Normal close
+  (let ((f (open "stream.impure.lisp" :direction :input)))
+    (assert (stringp (read-line f)))
+    (close f)
+    (assert (eq :fii
+                (handler-case
+                    (read-line f)
+                  (sb-int:closed-stream-error () :fii)))))
+  ;; Abort
+  (let ((f (open "stream.impure.lisp" :direction :input)))
+    (assert (stringp (read-line f nil nil)))
+    (close f :abort t)
+    (assert (eq :faa
+                (handler-case
+                    (read-line f)
+                  (sb-int:closed-stream-error () :faa))))))
+
+(with-test (:name :regression-1.0.12.22)
+  (with-open-file (s "stream.impure.lisp" :direction :input)
+    (let ((buffer (make-string 20)))
+      (assert (= 2 (read-sequence buffer s :start 0 :end 2)))
+      (assert (= 3 (read-sequence buffer s :start 2 :end 3)))
+      (file-position s :end)
+      (assert (= 3 (read-sequence buffer s :start 3))))))
+
 ;;; success