X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Ftype.pure.lisp;h=90205bc0a094951a9ae9b761055b3b94dd3656eb;hb=c41cb4c87eae7b04f844dca5f7edb5086c5d2d68;hp=9222e6a3701f5703f45af28e5fa3cef886c412ef;hpb=e62a03c99097db9454d66f32b5edbd6af874a539;p=sbcl.git

diff --git a/tests/type.pure.lisp b/tests/type.pure.lisp
index 9222e6a..90205bc 100644
--- a/tests/type.pure.lisp
+++ b/tests/type.pure.lisp
@@ -33,7 +33,8 @@
 ;;; SINGLE-FLOAT DOUBLE-FLOAT RATIONAL)".  We ideally want all of the
 ;;; defined-by-ANSI types to unparse as themselves or at least
 ;;; something similar (e.g. CHARACTER can unparse to BASE-CHAR, since
-;;; the types are equivalent in current SBCL).
+;;; the types are equivalent in current SBCL, and EXTENDED-CHAR can
+;;; unparse to NIL, since there are no EXTENDED-CHARs currently).
 (let ((standard-types '(;; from table 4-2 in section 4.2.3 in the
 			;; CLHS.
 			arithmetic-error
@@ -42,7 +43,15 @@
 			array
 			generic-function
 			simple-error
-			;; (NOT CONS)
+			;; so it might seem easy to change the HAIRY
+			;; :UNPARSE method to recognize that (NOT
+			;; CONS) should unparse as ATOM. However, we
+			;; then lose the nice (SUBTYPEP '(NOT ATOM)
+			;; 'CONS) => T,T behaviour that we get from
+			;; simplifying (NOT ATOM) -> (NOT (NOT CONS))
+			;; -> CONS. So, for now, we leave this
+			;; commented out.
+			;;
 			;; atom
 			hash-table
 			simple-string              
@@ -60,8 +69,7 @@
 			single-float               
 			bit-vector
 			long-float
-			;; MEMBER-TYPE #\a #\b ...
-			;; standard-char              
+			standard-char              
 			broadcast-stream
 			method
 			standard-class             
@@ -88,9 +96,7 @@
 			string                     
 			condition
 			pathname
-			;; OR STRING-INPUT-STREAM STRING-OUTPUT-STREAM
-			;; FILL-POINTER-OUTPUT-STREAM
-			;; string-stream
+			string-stream
 			cons
 			print-not-readable
 			structure-class            
@@ -112,24 +118,14 @@
 			error
 			readtable
 			two-way-stream
-			;; This one's hard: (AND BASE-CHAR (NOT BASE-CHAR))
-			;;
-			;; This is because it looks like
-			;;   (AND CHARACTER (NOT BASE-CHAR))
-			;; but CHARACTER is equivalent to
-			;; BASE-CHAR. So if we fix intersection of
-			;; obviously disjoint types and then do (the
-			;; extended-char foo), we'll get back FOO is
-			;; not a NIL. -- CSR, 2002-09-16.
-			;; extended-char
+			extended-char
 			real
 			type-error                 
 			file-error
 			restart
 			unbound-slot               
 			file-stream
-			;; (OR CONS NULL VECTOR)
-			;; sequence
+			sequence
 			unbound-variable           
 			fixnum
 			serious-condition
@@ -151,3 +147,62 @@
     (format t "~&~S~%" type)
     (assert (not (sb-kernel:unknown-type-p (sb-kernel:specifier-type type))))
     (assert (atom (sb-kernel:type-specifier (sb-kernel:specifier-type type))))))
+
+;;; a bug underlying the reported bug #221: The SB-KERNEL type code
+;;; signalled an error on this expression.
+(subtypep '(function (fixnum) (values package boolean))
+	  '(function (t) (values package boolean)))
+
+;;; bug reported by Valtteri Vuorik
+(compile nil '(lambda () (member (char "foo" 0) '(#\. #\/) :test #'char=)))
+(assert (not (equal (multiple-value-list
+                     (subtypep '(function ()) '(function (&rest t))))
+                    '(nil t))))
+
+(assert (not (equal (multiple-value-list
+                     (subtypep '(function (&rest t)) '(function ())))
+                    '(t t))))
+
+(assert (subtypep '(function)
+                  '(function (&optional * &rest t))))
+(assert (equal (multiple-value-list
+                (subtypep '(function)
+                          '(function (t &rest t))))
+               '(nil t)))
+(assert (and (subtypep 'function '(function))
+             (subtypep '(function) 'function)))
+
+;;; Absent any exciting generalizations of |R, the type RATIONAL is
+;;; partitioned by RATIO and INTEGER.  Ensure that the type system
+;;; knows about this.  [ the type system is permitted to return NIL,
+;;; NIL for these, so if future maintenance breaks these tests that
+;;; way, that's fine.  What the SUBTYPEP calls are _not_ allowed to
+;;; return is NIL, T, because that's completely wrong. ]
+(assert (subtypep '(or integer ratio) 'rational))
+(assert (subtypep 'rational '(or integer ratio)))
+;;; Likewise, these are allowed to return NIL, NIL, but shouldn't
+;;; return NIL, T:
+(assert (subtypep t '(or real (not real))))
+(assert (subtypep t '(or keyword (not keyword))))
+(assert (subtypep '(and cons (not (cons symbol integer)))
+		  '(or (cons (not symbol) *) (cons * (not integer)))))
+(assert (subtypep '(or (cons (not symbol) *) (cons * (not integer)))
+		  '(and cons (not (cons symbol integer)))))
+(assert (subtypep '(or (eql 0) (rational (0) 10))
+		  '(rational 0 10)))
+(assert (subtypep '(rational 0 10)
+		  '(or (eql 0) (rational (0) 10))))
+;;; Until sbcl-0.7.13.7, union of CONS types when the CDRs were the
+;;; same type gave exceedingly wrong results
+(assert (null (subtypep '(or (cons fixnum single-float)
+			     (cons bignum single-float))
+			'(cons single-float single-float))))
+(assert (subtypep '(cons integer single-float)
+		  '(or (cons fixnum single-float) (cons bignum single-float))))
+
+(assert (not (nth-value 1 (subtypep '(and null some-unknown-type)
+                                    'another-unknown-type))))
+
+;;; bug 46c
+(dolist (fun '(and if))
+  (assert (raises-error? (coerce fun 'function) type-error)))