Really restore clisp cross-compilation.
[sbcl.git] / tests / stream.impure.lisp
1 ;;;; tests related to Lisp streams
2
3 ;;;; This software is part of the SBCL system. See the README file for
4 ;;;; more information.
5 ;;;;
6 ;;;; While most of SBCL is derived from the CMU CL system, the test
7 ;;;; files (like this one) were written from scratch after the fork
8 ;;;; from CMU CL.
9 ;;;;
10 ;;;; This software is in the public domain and is provided with
11 ;;;; absolutely no warranty. See the COPYING and CREDITS files for
12 ;;;; more information.
13
14 (load "assertoid.lisp")
15 (use-package "ASSERTOID")
16
17 ;;; type errors for inappropriate stream arguments, fixed in
18 ;;; sbcl-0.7.8.19
19 (locally
20     (declare (optimize (safety 3)))
21   (assert (raises-error? (make-two-way-stream (make-string-output-stream)
22                                               (make-string-output-stream))
23                          type-error))
24   (assert (raises-error? (make-two-way-stream (make-string-input-stream "foo")
25                                               (make-string-input-stream "bar"))
26                          type-error))
27   ;; the following two aren't actually guaranteed, because ANSI, as it
28   ;; happens, doesn't say "should signal an error" for
29   ;; MAKE-ECHO-STREAM. It's still good to have, but if future
30   ;; maintenance work causes this test to fail because of these
31   ;; MAKE-ECHO-STREAM clauses, consider simply removing these clauses
32   ;; from the test. -- CSR, 2002-10-06
33   (assert (raises-error? (make-echo-stream (make-string-output-stream)
34                                            (make-string-output-stream))
35                          type-error))
36   (assert (raises-error? (make-echo-stream (make-string-input-stream "foo")
37                                            (make-string-input-stream "bar"))
38                          type-error))
39   (assert (raises-error? (make-concatenated-stream
40                           (make-string-output-stream)
41                           (make-string-input-stream "foo"))
42                          type-error)))
43
44 ;;; bug 225: STRING-STREAM was not a class
45 (eval `(defgeneric bug225 (s)
46          ,@(mapcar (lambda (class)
47                      `(:method :around ((s ,class)) (cons ',class (call-next-method))))
48                    '(stream string-stream sb-impl::string-input-stream
49                      sb-impl::string-output-stream))
50          (:method (class) nil)))
51
52 (assert (equal (bug225 (make-string-input-stream "hello"))
53                '(sb-impl::string-input-stream string-stream stream)))
54 (assert (equal (bug225 (make-string-output-stream))
55                '(sb-impl::string-output-stream string-stream stream)))
56
57 \f
58 ;;; improper buffering on (SIGNED-BYTE 8) streams (fixed by David Lichteblau):
59 (let ((p "signed-byte-8-test.data"))
60   (with-open-file (s p
61                      :direction :output
62                      :element-type '(unsigned-byte 8)
63                      :if-exists :supersede)
64     (write-byte 255 s))
65   (with-open-file (s p :element-type '(signed-byte 8))
66     (assert (= (read-byte s) -1)))
67   (delete-file p))
68 \f
69 ;;; :IF-EXISTS got :ERROR and NIL the wrong way round (reported by
70 ;;; Milan Zamazal)
71 (let* ((p "this-file-will-exist")
72        (stream (open p :direction :output :if-exists :error)))
73   (assert (null (with-open-file (s p :direction :output :if-exists nil) s)))
74   (assert (raises-error?
75            (with-open-file (s p :direction :output :if-exists :error))))
76   (close stream)
77   (delete-file p))
78 \f
79 (assert (raises-error? (read-byte (make-string-input-stream "abc"))
80                        type-error))
81 (assert (raises-error? (with-open-file (s "/dev/zero")
82                          (read-byte s))
83                        #-win32 type-error
84                        #+win32 sb-int:simple-file-error))
85 ;;; bidirectional streams getting confused about their position
86 (let ((p "bidirectional-stream-test"))
87   (with-open-file (s p :direction :output :if-exists :supersede)
88     (with-standard-io-syntax
89       (format s "~S ~S ~S~%" 'these 'are 'symbols)))
90   (with-open-file (s p :direction :io :if-exists :overwrite)
91     (read s)
92     (with-standard-io-syntax
93       (prin1 'insert s)))
94   (with-open-file (s p)
95     (let ((line (read-line s))
96           (want "THESE INSERTMBOLS"))
97       (unless (equal line want)
98         (error "wanted ~S, got ~S" want line))))
99   (delete-file p))
100 \f
101 ;;; :DIRECTION :IO didn't work on non-existent pathnames
102 (let ((p "direction-io-test"))
103   (ignore-errors (delete-file p))
104   (with-open-file (s p :direction :io)
105     (format s "1")
106     (finish-output s)
107     (file-position s :start)
108     (assert (char= (read-char s) #\1)))
109   (delete-file p))
110 \f
111 ;;; FILE-POSITION on broadcast-streams is mostly uncontroversial
112 (assert (= 0 (file-position (make-broadcast-stream))))
113 (assert (file-position (make-broadcast-stream) :start))
114 (assert (file-position (make-broadcast-stream) 0))
115 (assert (not (file-position (make-broadcast-stream) 1)))
116 (let ((s (make-broadcast-stream)))
117   (write-char #\a s)
118   (assert (not (file-position s 1)))
119   (assert (= 0 (file-position s))))
120
121 (let ((p "broadcast-stream-test"))
122   (ignore-errors (delete-file p))
123   (with-open-file (f p :direction :output)
124     (let ((s (make-broadcast-stream f)))
125       (assert (= 0 (file-position s)))
126       (assert (file-position s :start))
127       (assert (file-position s 0))
128       (write-char #\a s)
129       (assert (= 1 (file-position s))) ; unicode...
130       (assert (file-position s 0))))
131   (delete-file p))
132
133 ;;; CLOSING a non-new streams should not delete them, and superseded
134 ;;; files should be restored.
135 (with-test (:name :test-file-for-close-should-not-delete :fails-on :win32)
136   (let ((test "test-file-for-close-should-not-delete"))
137     (macrolet ((test-mode (mode)
138                           `(progn
139                              (catch :close-test-exit
140                                (with-open-file (f test :direction :output :if-exists ,mode)
141                                                (write-line "test" f)
142                                                (throw :close-test-exit t)))
143                              (assert (and (probe-file test) ,mode)))))
144       (unwind-protect
145           (progn
146             (with-open-file (f test :direction :output)
147                             (write-line "test" f))
148             (test-mode :append)
149             (test-mode :overwrite)
150             ;; FIXME: We really should recover supersede files as well, according to
151             ;; CLOSE in CLHS, but at the moment we don't.
152             ;; (test-mode :supersede)
153             (test-mode :rename)
154             (test-mode :rename-and-delete))
155         (when (probe-file test)
156           (delete-file test))))))
157
158 ;;; test for read-write invariance of signed bytes, from Bruno Haible
159 ;;; cmucl-imp 2004-09-06
160 (defun bin-stream-test (&key (size (integer-length most-positive-fixnum))
161                         (type 'unsigned-byte) (file-name "stream-impure.tmp")
162                         (num-bytes 10)
163                         (bytes (if (eq type 'signed-byte)
164                                    (loop :repeat num-bytes :collect
165                                          (- (random (ash 1 size))
166                                             (ash 1 (1- size))))
167                                    (loop :repeat num-bytes :collect
168                                          (random (ash 1 size))))))
169   (with-open-file (foo file-name :direction :output :if-exists :supersede
170                        :element-type (list type size))
171     (dolist (byte bytes)
172       (write-byte byte foo)))
173   (unwind-protect
174        (with-open-file (foo file-name :direction :input
175                             :element-type (list type size))
176          (list (stream-element-type foo) (file-length foo) bytes
177                (loop :for byte :in bytes :for nb = (read-byte foo) :collect nb
178                      :unless (= nb byte) :do
179                      (flet ((by-out (sz by)
180                               (format nil "~v,'0,' ,4:b"
181                                       (+ sz (floor sz 4)) by)))
182                        (error "~& * [(~s ~s)] ~a != ~a~%" type size
183                               (by-out size byte) (by-out size nb))))))
184     (delete-file file-name)))
185 (loop for size from 2 to 40 do (bin-stream-test :size size :type 'signed-byte))
186 \f
187 ;;; Check READ-SEQUENCE signals a TYPE-ERROR when the sequence can't
188 ;;; contain a stream element.
189 ;;;
190 ;;; These tests check READ-SEQUENCE correctness, not whether the fast
191 ;;; or slow paths are being taken for each element type.  To check the
192 ;;; fast or slow paths, trace ANSI-STREAM-READ-BYTE (slow path) and/or
193 ;;; READ-N-BYTES:
194 ;;;
195 ;;; (trace sb-impl::ansi-stream-read-byte sb-impl::read-n-bytes)
196 ;;;
197 ;;; The order should be ANSI-STREAM-READ-BYTE, READ-N-BYTES,
198 ;;; READ-N-BYTES, ANSI-STREAM-READ-BYTE, ANSI-STREAM-READ-BYTE.
199
200 (let ((pathname "read-sequence.data"))
201
202   ;; Create the binary data.
203   (with-open-file (stream pathname
204                           :direction :output
205                           :if-exists :supersede
206                           :element-type '(unsigned-byte 8))
207     (write-byte 255 stream))
208
209   ;; Check the slow path for generic vectors.
210   (let ((sequence (make-array 1)))
211     (with-open-file (stream pathname
212                             :direction :input
213                             :element-type '(unsigned-byte 8))
214     (read-sequence sequence stream)
215     (assert (equalp sequence #(255)))))
216
217   (let ((sequence (make-array 1)))
218     (with-open-file (stream pathname
219                             :direction :input
220                             :external-format :latin-1
221                             :element-type 'character)
222       (read-sequence sequence stream)
223       (assert (equalp sequence #(#.(code-char 255))))))
224
225   ;; Check the fast path works for (UNSIGNED-BYTE 8) and (SIGNED-BYTE
226   ;; 8) vectors.
227   (let ((sequence (make-array 1 :element-type '(unsigned-byte 8))))
228     (with-open-file (stream pathname
229                             :direction :input
230                             :element-type '(unsigned-byte 8))
231       (read-sequence sequence stream)
232       (assert (equalp sequence #(255)))))
233
234   (let ((sequence (make-array 1 :element-type '(signed-byte 8))))
235     (with-open-file (stream pathname
236                             :direction :input
237                             :element-type '(signed-byte 8))
238     (read-sequence sequence stream)
239     (assert (equalp sequence #(-1)))))
240
241   ;; A bivalent stream can be read to a unsigned-byte vector, a
242   ;; string, or a generic vector
243
244   (let ((sequence (make-array 1 :element-type '(unsigned-byte 8))))
245     (with-open-file (stream pathname
246                             :direction :input
247                             :element-type :default)
248       (read-sequence sequence stream)
249       (assert (equalp sequence #(255)))))
250
251   (let ((sequence (make-array 1 :element-type 'character)))
252     (with-open-file (stream pathname
253                             :direction :input
254                             :external-format :latin-1
255                             :element-type :default)
256       (read-sequence sequence stream)
257       (assert (equalp sequence #(#.(code-char 255))))))
258
259   (let ((sequence (make-array 1)))
260     (with-open-file (stream pathname
261                             :direction :input
262                             :external-format :latin-1
263                             :element-type :default)
264       (read-sequence sequence stream)
265       (assert (equalp sequence #(#.(code-char 255))))))
266
267   ;; Check that a TYPE-ERROR is signalled for incompatible (sequence,
268   ;; stream) pairs.
269
270   (let ((sequence (make-array 1 :element-type '(signed-byte 8))))
271     (with-open-file (stream pathname
272                             :direction :input
273                             :element-type '(unsigned-byte 8))
274       (handler-case (progn
275                       (read-sequence sequence stream)
276                       (error "READ-SEQUENCE didn't signal an error"))
277         (type-error (condition)
278           (assert (= (type-error-datum condition) 255))
279           (assert (subtypep (type-error-expected-type condition)
280                             '(signed-byte 8)))))))
281
282   (let ((sequence (make-array 1 :element-type '(unsigned-byte 8))))
283     (with-open-file (stream pathname
284                             :direction :input
285                             :element-type '(signed-byte 8))
286       (handler-case (progn
287                       (read-sequence sequence stream)
288                       (error "READ-SEQUENCE didn't signal an error"))
289         (type-error (condition)
290           (assert (= (type-error-datum condition) -1))
291           (assert (subtypep (type-error-expected-type condition)
292                             '(unsigned-byte 8)))))))
293
294   ;; Can't read a signed-byte from a bivalent stream
295
296   (let ((sequence (make-array 1 :element-type '(signed-byte 8))))
297     (with-open-file (stream pathname
298                             :direction :input
299                             :external-format :latin1
300                             :element-type :default)
301       (handler-case (progn
302                       (read-sequence sequence stream)
303                       (error "READ-SEQUENCE didn't signal an error"))
304         (type-error (condition)
305           (assert (eql (type-error-datum condition) (code-char 255)))
306           (assert (subtypep (type-error-expected-type condition)
307                             '(signed-byte 8)))))))
308   (delete-file pathname))
309 \f
310 ;;; Check WRITE-SEQUENCE signals a TYPE-ERROR when the stream can't
311 ;;; write a sequence element.
312 ;;;
313 ;;; These tests check WRITE-SEQUENCE correctness, not whether the fast
314 ;;; or slow paths are being taken for each element type.  See the
315 ;;; READ-SEQUENCE tests above for more information.
316 ;;;
317 ;;; (trace sb-impl::output-unsigned-byte-full-buffered sb-impl::output-signed-byte-full-buffered sb-impl::output-raw-bytes)
318
319 (let ((pathname "write-sequence.data")
320       (generic-sequence (make-array 1 :initial-contents '(255)))
321       (generic-character-sequence (make-array 1 :initial-element #\a))
322       (generic-mixed-sequence (make-array 2 :initial-element #\a))
323       (string (make-array 1 :element-type 'character
324                           :initial-element (code-char 255)))
325       (unsigned-sequence (make-array 1
326                                      :element-type '(unsigned-byte 8)
327                                      :initial-contents '(255)))
328       (signed-sequence (make-array 1
329                                    :element-type '(signed-byte 8)
330                                    :initial-contents '(-1))))
331
332   (setf (aref generic-mixed-sequence 1) 255)
333
334   ;; Check the slow path for generic vectors.
335   (with-open-file (stream pathname
336                            :direction :output
337                            :if-exists :supersede
338                            :element-type '(unsigned-byte 8))
339     (write-sequence generic-sequence stream))
340
341   (with-open-file (stream pathname
342                           :direction :output
343                           :if-exists :supersede
344                           :element-type 'character)
345     (write-sequence generic-character-sequence stream))
346
347   ;; Check the fast path for unsigned and signed vectors.
348   (with-open-file (stream pathname
349                           :direction :output
350                           :if-exists :supersede
351                           :element-type '(unsigned-byte 8))
352     (write-sequence unsigned-sequence stream))
353
354   (with-open-file (stream pathname
355                           :direction :output
356                           :if-exists :supersede
357                           :element-type '(signed-byte 8))
358     (write-sequence signed-sequence stream))
359
360   ;; Bivalent streams on unsigned-byte vectors, strings, and a simple
361   ;; vector with mixed characters and bytes
362
363   (with-open-file (stream pathname
364                           :direction :output
365                           :if-exists :supersede
366                           :element-type :default)
367     (write-sequence unsigned-sequence stream))
368
369   (with-open-file (stream pathname
370                           :direction :output
371                           :external-format :latin-1
372                           :if-exists :supersede
373                           :element-type :default)
374     (write-sequence string stream))
375
376   (with-open-file (stream pathname
377                           :direction :output
378                           :external-format :latin-1
379                           :if-exists :supersede
380                           :element-type :default)
381     (write-sequence generic-mixed-sequence stream))
382
383   ;; Check a TYPE-ERROR is signalled for unsigned and signed vectors
384   ;; which are incompatible with the stream element type.
385   (with-open-file (stream pathname
386                           :direction :output
387                           :if-exists :supersede
388                           :element-type '(signed-byte 8))
389     (handler-case (progn
390                     (write-sequence unsigned-sequence stream)
391                     (error "WRITE-SEQUENCE didn't signal an error"))
392       (type-error (condition)
393         (assert (= (type-error-datum condition) 255))
394         (assert (subtypep (type-error-expected-type condition)
395                           '(signed-byte 8))))))
396
397   (with-open-file (stream pathname
398                           :direction :output
399                           :if-exists :supersede
400                           :element-type '(unsigned-byte 8))
401     (handler-case (progn
402                     (write-sequence signed-sequence stream)
403                     (error "WRITE-SEQUENCE didn't signal an error"))
404       (type-error (condition)
405         (assert (= (type-error-datum condition) -1))
406         (assert (subtypep (type-error-expected-type condition)
407                           '(unsigned-byte 8))))))
408
409   (with-open-file (stream pathname
410                           :direction :output
411                           :if-exists :supersede
412                           :element-type :default)
413     (handler-case (progn
414                     (write-sequence signed-sequence stream)
415                     (error "WRITE-SEQUENCE didn't signal an error"))
416       (type-error (condition)
417         (assert (= (type-error-datum condition) -1))
418         (assert (subtypep (type-error-expected-type condition)
419                           '(unsigned-byte 8))))))
420
421   (delete-file pathname))
422
423 ;;; writing looong lines. takes way too long and way too much space
424 ;;; to test on 64 bit platforms
425 #-#.(cl:if (cl:= sb-vm:n-word-bits 64) '(and) '(or))
426 (let ((test "long-lines-write-test.tmp"))
427     (unwind-protect
428          (with-open-file (f test
429                             :direction :output
430                             :external-format :ascii
431                             :element-type 'character
432                             :if-does-not-exist :create
433                             :if-exists :supersede)
434            (let* ((n (truncate most-positive-fixnum 16))
435                   (m 18)
436                   (p (* n m))
437                   (buffer (make-string n)))
438              (dotimes (i m)
439                (write-char #\.)
440                (finish-output)
441                (write-sequence buffer f))
442              (assert (= p (sb-impl::fd-stream-char-pos f)))
443              (write-char #\! f)
444              (assert (= (+ 1 p) (sb-impl::fd-stream-char-pos f)))
445              (assert (typep p 'bignum))))
446       (when (probe-file test)
447         (delete-file test))))
448
449 ;;; read-sequence misreported the amount read and lost position
450 (let ((string (make-array (* 3 sb-impl::+ansi-stream-in-buffer-length+)
451                           :element-type 'character)))
452   (dotimes (i (length string))
453     (setf (char string i) (code-char (mod i char-code-limit))))
454   (with-open-file (f "read-sequence-character-test-data.tmp"
455                      :if-exists :supersede
456                      :direction :output
457                      :external-format :utf-8)
458     (write-sequence string f))
459   (let ((copy
460          (with-open-file (f "read-sequence-character-test-data.tmp"
461                             :if-does-not-exist :error
462                             :direction :input
463                             :external-format :utf-8)
464            (let ((buffer (make-array 128 :element-type 'character))
465                  (total 0))
466              (with-output-to-string (datum)
467                (loop for n-read = (read-sequence buffer f)
468                      do (write-sequence buffer datum :start 0 :end n-read)
469                         (assert (<= (incf total n-read) (length string)))
470                      while (and (= n-read 128))))))))
471     (assert (equal copy string)))
472   (delete-file "read-sequence-character-test-data.tmp"))
473
474 ;;; ANSI-STREAM-OUTPUT-STREAM-P used to assume that a SYNONYM-STREAM's
475 ;;; target was an ANSI stream, but it could be a user-defined stream,
476 ;;; e.g., a SLIME stream.
477 (defclass user-output-stream (fundamental-output-stream)
478   ())
479
480 (let ((*stream* (make-instance 'user-output-stream)))
481   (declare (special *stream*))
482   (with-open-stream (stream (make-synonym-stream '*stream*))
483     (assert (output-stream-p stream))))
484
485 (defclass user-input-stream (fundamental-input-stream)
486   ())
487
488 (let ((*stream* (make-instance 'user-input-stream)))
489   (declare (special *stream*))
490   (with-open-stream (stream (make-synonym-stream '*stream*))
491     (assert (input-stream-p stream))))
492
493 ;;; READ-LINE on ANSI-STREAM did not return T for the last line
494 ;;; (reported by Yoshinori Tahara)
495 (let ((pathname "test-read-line-eol"))
496   (with-open-file (out pathname :direction :output :if-exists :supersede)
497     (format out "a~%b"))
498   (let ((result (with-open-file (in pathname)
499                   (list (multiple-value-list (read-line in nil nil))
500                         (multiple-value-list (read-line in nil nil))
501                         (multiple-value-list (read-line in nil nil))))))
502     (delete-file pathname)
503     (assert (equal result '(("a" nil) ("b" t) (nil t))))))
504
505 ;;; READ-LINE used to work on closed streams because input buffers were left in place
506 (with-test (:name :bug-425)
507   ;; Normal close
508   (let ((f (open "stream.impure.lisp" :direction :input)))
509     (assert (stringp (read-line f)))
510     (close f)
511     (assert (eq :fii
512                 (handler-case
513                     (read-line f)
514                   (sb-int:closed-stream-error () :fii)))))
515   ;; Abort
516   (let ((f (open "stream.impure.lisp" :direction :input)))
517     (assert (stringp (read-line f nil nil)))
518     (close f :abort t)
519     (assert (eq :faa
520                 (handler-case
521                     (read-line f)
522                   (sb-int:closed-stream-error () :faa))))))
523
524 (with-test (:name :regression-1.0.12.22)
525   (with-open-file (s "stream.impure.lisp" :direction :input)
526     (let ((buffer (make-string 20)))
527       (assert (= 2 (read-sequence buffer s :start 0 :end 2)))
528       (assert (= 3 (read-sequence buffer s :start 2 :end 3)))
529       (file-position s :end)
530       (assert (= 3 (read-sequence buffer s :start 3))))))
531
532 ;;; In 1.0.27 (and also 0.9.16; presumably in between, too), binary
533 ;;; input operations on a bivalent stream did something bad after
534 ;;; unread-char: READ-BYTE would return the character, and
535 ;;; READ-SEQUENCE into a byte buffer would lose when attempting to
536 ;;; store the character in the vector.
537 (let ((pathname "bivalent-stream-unread-char-test.tmp"))
538   (with-open-file (s pathname
539                      :element-type :default
540                      :direction :io :if-exists :rename)
541     (write-char #\a s)
542     (file-position s :start)
543     (unread-char (read-char s) s)
544     (assert (integerp (read-byte s))))
545   (delete-file pathname))
546
547 (let ((pathname "bivalent-stream-unread-char-test.tmp"))
548   (with-open-file (s pathname
549                      :element-type :default
550                      :direction :io :if-exists :rename)
551     (write-char #\a s)
552     (file-position s :start)
553     (unread-char (read-char s) s)
554     (assert (let ((buffer (make-array 10 :element-type '(unsigned-byte 8))))
555               (read-sequence buffer s))))
556   (delete-file pathname))
557
558 #+sb-unicode
559 (let ((pathname "bivalent-stream-unread-char-test.tmp"))
560   (with-open-file (s pathname
561                      :element-type :default
562                      :direction :io :if-exists :rename
563                      :external-format :utf8)
564     (write-char (code-char 192) s)
565     (file-position s :start)
566     (unread-char (read-char s) s)
567     (assert (integerp (read-byte s))))
568   (delete-file pathname))
569
570 #+sb-unicode
571 (let ((pathname "bivalent-stream-unread-char-test.tmp"))
572   (with-open-file (s pathname
573                      :element-type :default
574                      :direction :io :if-exists :rename
575                      :external-format :utf8)
576     (write-char (code-char 192) s)
577     (file-position s :start)
578     (unread-char (read-char s) s)
579     (assert (let ((buffer (make-array 10 :element-type '(unsigned-byte 8))))
580               (read-sequence buffer s))))
581   (delete-file pathname))
582
583 (with-test (:name :delete-file-on-streams)
584   (with-open-file (f "delete-file-on-stream-test.tmp"
585                      :direction :io)
586     (delete-file f)
587     #-win32
588     (progn
589       (write-line "still open" f)
590       (file-position f :start)
591       (assert (equal "still open" (read-line f)))))
592   (assert (not (probe-file "delete-file-on-stream-test.tmp"))))
593 \f
594 ;;; READ-CHAR-NO-HANG on bivalent streams (as returned by RUN-PROGRAM)
595 ;;; was wrong.  CSR managed to promote the wrongness to all streams in
596 ;;; the 1.0.32.x series, breaking slime instantly.
597 (with-test (:name :read-char-no-hang-after-unread-char :skipped-on :win32)
598   (let* ((process (run-program "/bin/sh" '("-c" "echo a && sleep 10")
599                                :output :stream :wait nil))
600          (stream (process-output process))
601          (char (read-char stream)))
602     (assert (char= char #\a))
603     (unread-char char stream)
604     (assert (char= (read-char stream) #\a))
605     (assert (char= (read-char stream) #\Newline))
606     (let ((time (get-universal-time)))
607       ;; no input, not yet known to be at EOF: should return
608       ;; immediately
609       (read-char-no-hang stream)
610       (assert (< (- (get-universal-time) time) 2)))))
611
612 (require :sb-posix)
613 #-win32
614 (with-test (:name :interrupt-open :skipped-on :win32)
615   (let ((fifo nil)
616         (to 0))
617     (unwind-protect
618          (progn
619            ;; Make a FIFO
620            (setf fifo (sb-posix:mktemp "SBCL-fifo.XXXXXXX"))
621            (sb-posix:mkfifo fifo (logior sb-posix:s-iwusr sb-posix:s-irusr))
622            ;; Try to open it (which hangs), and interrupt ourselves with a timer,
623            ;; continue (this used to result in an error due to open(2) returning with
624            ;; EINTR, then interupt again and unwind.
625            (handler-case
626                (with-timeout 2
627                  (handler-bind ((timeout (lambda (c)
628                                            (when (eql 1 (incf to))
629                                              (continue c)))))
630                    (with-timeout 1
631                      (with-open-file (f fifo :direction :input)
632                        :open))))
633              (timeout ()
634                (if (eql 2 to)
635                    :timeout
636                    :wtf))
637              (error (e)
638                e)))
639       (when fifo
640         (ignore-errors (delete-file fifo))))))
641
642 #-win32
643 (with-test (:name :overeager-character-buffering :skipped-on :win32)
644   (let ((fifo nil)
645         (proc nil))
646     (maphash
647      (lambda (format _)
648        (declare (ignore _))
649        (format t "trying ~A~%" format)
650        (finish-output t)
651        (unwind-protect
652             (progn
653               (setf fifo (sb-posix:mktemp "SBCL-fifo-XXXXXXX"))
654               (sb-posix:mkfifo fifo (logior sb-posix:s-iwusr sb-posix:s-irusr))
655               ;; KLUDGE: because we have both ends in the same process, we would
656               ;; need to use O_NONBLOCK, but this works too.
657               (setf proc
658                     (run-program "/bin/sh"
659                                  (list "-c"
660                                        (format nil "cat > ~A" (native-namestring fifo)))
661                                  :input :stream
662                                  :wait nil
663                                  :external-format format))
664               (write-line "foobar" (process-input proc))
665               (finish-output (process-input proc))
666               (with-open-file (f fifo :direction :input :external-format format)
667                 (assert (equal "foobar" (read-line f)))))
668          (when proc
669            (ignore-errors
670              (close (process-input proc) :abort t)
671              (process-wait proc))
672            (ignore-errors (process-close proc))
673            (setf proc nil))
674          (when fifo
675            (ignore-errors (delete-file fifo))
676            (setf fifo nil))))
677      sb-impl::*external-formats*)))
678
679 (with-test (:name :bug-657183 :skipped-on '(not :sb-unicode))
680   #+sb-unicode
681   (let ((name (merge-pathnames "stream-impure.temp-test"))
682         (text '(#\GREEK_SMALL_LETTER_LAMDA
683                 #\JAPANESE_BANK_SYMBOL
684                 #\Space
685                 #\HEAVY_BLACK_HEART))
686         (positions '(2 5 6 9))
687         (sb-impl::*default-external-format* :utf-8))
688     (unwind-protect
689          (progn
690            (with-open-file (f name :external-format :default :direction :output
691                               :if-exists :supersede)
692              (assert (eql 0 (file-position f)))
693              (mapc (lambda (char pos)
694                      (write-char char f)
695                      (assert (eql pos (file-position f))))
696                    text
697                    positions))
698            (with-open-file (f name :external-format :default :direction :input)
699              (assert (eql 0 (file-position f)))
700              (assert (eql (pop text) (read-char f)))
701              (assert (eql (file-position f) 2))
702              (assert (eql (pop text) (read-char f)))
703              (assert (eql (file-position f) 5))
704              (assert (eql (pop text) (read-char f)))
705              (assert (eql (file-position f) 6))
706              (assert (eql (pop text) (read-char f)))
707              (assert (eql (file-position f) 9))
708              (assert (eql (file-length f) 9))))
709       (ignore-errors (delete-file name)))))
710
711 (with-test (:name :bug-561642)
712   (let ((p "bug-561642-test.tmp"))
713     (unwind-protect
714          (progn
715            (with-open-file (f p
716                               :if-exists :supersede
717                               :if-does-not-exist :create
718                               :direction :output)
719              (write-line "FOOBAR" f))
720            (with-open-file (f p
721                               :if-exists :append
722                               :direction :output)
723              (let ((p0 (file-position f))
724                    (p1 (progn
725                          (write-char #\newline f)
726                          (file-position f)))
727                    (p2 (progn
728                          (write-char #\newline f)
729                          (finish-output f)
730                          (file-position f))))
731                (assert (eql 7 p0))
732                (assert (eql 8 p1))
733                (assert (eql 9 p2)))))
734       (ignore-errors (delete-file p)))))
735
736 ;;; success