X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fprint.impure.lisp;h=9a3a2c3132c8f8ed0ed776a8bb2f3fc2d3758892;hb=bfa4310e41dcd011ca9d139f29be1c5757b41378;hp=c5e6d61f6c6eb68ff3b652fd3f600b8154a2bcd8;hpb=479ef26343b45753fc019b6535d3aa0ee54cb324;p=sbcl.git

diff --git a/tests/print.impure.lisp b/tests/print.impure.lisp
index c5e6d61..9a3a2c3 100644
--- a/tests/print.impure.lisp
+++ b/tests/print.impure.lisp
@@ -112,15 +112,22 @@
 		     (print (make-array '(1 2 0)) s)))))
 	       '(1 2 0)))
 
-(assert (multiple-value-bind (result error)
-	    (ignore-errors (read-from-string
-			    (with-output-to-string (s)
-			      (let ((*print-readably* t))
-				(print (make-array '(1 0 1)) s)))))
-	  ;; it might not be readably-printable
-	  (or (typep error 'print-not-readable)
-	      ;; or else it had better have the same dimensions
-	      (equal (array-dimensions result) '(1 0 1)))))
+(dolist (array (list (make-array '(1 0 1))
+		     (make-array 0 :element-type nil)
+		     (make-array 1 :element-type 'base-char)
+		     (make-array 1 :element-type 'character)))
+  (assert (multiple-value-bind (result error)
+	      (ignore-errors (read-from-string
+			      (with-output-to-string (s)
+				(let ((*print-readably* t))
+				  (print array s)))))
+	    ;; it might not be readably-printable
+	    (or (typep error 'print-not-readable)
+		(and
+		 ;; or else it had better have the same dimensions
+		 (equal (array-dimensions result) (array-dimensions array))
+		 ;; and the same element-type
+		 (equal (array-element-type result) (array-element-type array)))))))
 
 ;;; before 0.8.0.66 it signalled UNBOUND-VARIABLE
 (write #(1 2 3) :pretty nil :readably t)
@@ -129,5 +136,108 @@
 ;;; expanders.
 (funcall (formatter "~@<~A~:*~A~:>") nil 3)
 
+;;; the PPC floating point backend was at one point sufficiently
+;;; broken that this looped infinitely or caused segmentation
+;;; violations through stack corruption.
+(print 0.0001)
+
+;;; In sbcl-0.8.7, the ~W format directive interpreter implemented the
+;;; sense of the colon and at-sign modifiers exactly backwards.
+;;;
+;;; (Yes, the test for this *is* substantially hairier than the fix;
+;;; wanna make something of it?)
+(cl:in-package :cl-user)
+(defstruct wexerciser-0-8-7)
+(defun wexercise-0-8-7-interpreted (wformat)
+  (format t wformat (make-wexerciser-0-8-7)))
+(defmacro define-compiled-wexercise-0-8-7 (wexercise wformat)
+  `(defun ,wexercise ()
+    (declare (optimize (speed 3) (space 1)))
+    (format t ,wformat (make-wexerciser-0-8-7))
+    (values)))
+(define-compiled-wexercise-0-8-7 wexercise-0-8-7-compiled-without-atsign "~W")
+(define-compiled-wexercise-0-8-7 wexercise-0-8-7-compiled-with-atsign "~@W")
+(defmethod print-object :before ((wexerciser-0-8-7 wexerciser-0-8-7) stream)
+  (unless (and *print-level* *print-length*)
+    (error "gotcha coming")))
+(let ((*print-level* 11)
+      (*print-length* 12))
+  (wexercise-0-8-7-interpreted "~W")
+  (wexercise-0-8-7-compiled-without-atsign))
+(remove-method #'print-object
+	       (find-method #'print-object
+			    '(:before)
+			    (mapcar #'find-class '(wexerciser-0-8-7 t))))
+(defmethod print-object :before ((wexerciser-0-8-7 wexerciser-0-8-7) stream)
+  (when (or *print-level* *print-length*)
+    (error "gotcha going")))
+(let ((*print-level* 11)
+      (*print-length* 12))
+  (wexercise-0-8-7-interpreted "~@W")
+  (wexercise-0-8-7-compiled-with-atsign))
+
+;;; WRITE-TO-STRING was erroneously DEFKNOWNed as FOLDABLE
+;;;
+;;; This bug from PFD
+(defpackage "SCRATCH-WRITE-TO-STRING" (:use))
+(with-standard-io-syntax
+  (let* ((*package* (find-package "SCRATCH-WRITE-TO-STRING"))
+	 (answer (write-to-string 'scratch-write-to-string::x :readably nil)))
+    (assert (string= answer "X"))))
+;;; and a couple from Bruno Haible
+(defun my-pprint-reverse (out list)
+  (write-char #\( out)
+  (when (setq list (reverse list))
+    (loop
+     (write (pop list) :stream out)
+     (when (endp list) (return))
+     (write-char #\Space out)))
+  (write-char #\) out))
+(with-standard-io-syntax
+  (let ((*print-pprint-dispatch* (copy-pprint-dispatch)))
+    (set-pprint-dispatch '(cons (member foo)) 'my-pprint-reverse 0)
+    (let ((answer (write-to-string '(foo bar :boo 1) :pretty t :escape t)))
+      (assert (string= answer "(1 :BOO BAR FOO)")))))
+(defun my-pprint-logical (out list)
+  (pprint-logical-block (out list :prefix "(" :suffix ")")
+    (when list
+      (loop
+       (write-char #\? out)
+       (write (pprint-pop) :stream out)
+       (write-char #\? out)
+       (pprint-exit-if-list-exhausted)
+       (write-char #\Space out)))))
+(with-standard-io-syntax
+  (let ((*print-pprint-dispatch* (copy-pprint-dispatch)))
+    (set-pprint-dispatch '(cons (member bar)) 'my-pprint-logical 0)
+    (let ((answer (write-to-string '(bar foo :boo 1) :pretty t :escape t)))
+      (assert (string= answer "(?BAR? ?FOO? ?:BOO? ?1?)")))))
+
+;;; FORMAT string compile-time checker failure, reported by Thomas
+;;; F. Burdick
+(multiple-value-bind (f w-p f-p)
+    (compile nil '(lambda () (format nil "~{")))
+  (assert (and w-p f-p))
+  (assert (nth-value 1 (ignore-errors (funcall f)))))
+
+;;; floating point print/read consistency
+(let ((x (/ -9.349640046247849d-21 -9.381494249123696d-11)))
+  (let ((y (read-from-string (write-to-string x :readably t))))
+    (assert (eql x y))))
+
+(let ((x1 (float -5496527/100000000000000000))
+      (x2 (float -54965272/1000000000000000000)))
+  (assert (or (equal (multiple-value-list (integer-decode-float x1))
+		     (multiple-value-list (integer-decode-float x2)))
+	      (string/= (prin1-to-string x1) (prin1-to-string x2)))))
+
+;;; readable printing of arrays with *print-radix* t
+(let ((*print-radix* t) 
+      (*print-readably* t)
+      (*print-pretty* nil))
+  (let ((output (with-output-to-string (s)
+		  (write #2a((t t) (nil nil)) :stream s))))
+    (assert (equalp (read-from-string output) #2a((t t) (nil nil))))))
+
 ;;; success
 (quit :unix-status 104)