X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Ftype.pure.lisp;h=23e58502e34b96ca2c1561c943a1e6c941d3e570;hb=4c5a011ccc355e3653b9490de6a2b3df5777e55d;hp=80267338dc8394a5e939d4cf3c2b32fa42fe2ee7;hpb=4704aaa73743e936db4ffaeeb4331b33d58a1acf;p=sbcl.git

diff --git a/tests/type.pure.lisp b/tests/type.pure.lisp
index 8026733..23e5850 100644
--- a/tests/type.pure.lisp
+++ b/tests/type.pure.lisp
@@ -43,16 +43,7 @@
 			array
 			generic-function
 			simple-error
-			;; 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
+			atom
 			hash-table
 			simple-string              
 			base-char
@@ -169,6 +160,68 @@
                 (subtypep '(function)
                           '(function (t &rest t))))
                '(nil t)))
-#+nil
 (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)))
+
+(dotimes (i 100)
+  (let ((x (make-array 0 :element-type `(unsigned-byte ,(1+ i)))))
+    (eval `(typep ,x (class-of ,x)))))
+
+(assert (not (typep #c(1 2) '(member #c(2 1)))))
+(assert (typep #c(1 2) '(member #c(1 2))))
+(assert (subtypep 'nil '(complex nil)))
+(assert (subtypep '(complex nil) 'nil))
+(assert (subtypep 'nil '(complex (eql 0))))
+(assert (subtypep '(complex (eql 0)) 'nil))
+(assert (subtypep 'nil '(complex (integer 0 0))))
+(assert (subtypep '(complex (integer 0 0)) 'nil))
+(assert (subtypep 'nil '(complex (rational 0 0))))
+(assert (subtypep '(complex (rational 0 0)) 'nil))
+(assert (subtypep 'complex '(complex real)))
+(assert (subtypep '(complex real) 'complex))
+(assert (subtypep '(complex (eql 1)) '(complex (member 1 2))))
+(assert (equal (multiple-value-list
+		(subtypep '(complex (integer 1 2))
+			  '(member #c(1 1) #c(1 2) #c(2 1) #c(2 2))))
+	       '(nil t)))
+
+(assert (typep 0 '(real #.(ash -1 10000) #.(ash 1 10000))))
+(assert (subtypep '(real #.(ash -1 1000) #.(ash 1 1000))
+                  '(real #.(ash -1 10000) #.(ash 1 10000))))
+(assert (subtypep '(real (#.(ash -1 1000)) (#.(ash 1 1000)))
+                  '(real #.(ash -1 1000) #.(ash 1 1000))))