0.8alpha.0.4:

[sbcl.git] / tests / type.pure.lisp

diff --git a/tests/type.pure.lisp b/tests/type.pure.lisp
index e5bd13b..b97a0e9 100644 (file)
--- 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
@@ -117,17 +118,7 @@
                        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
@@ -167,6 +158,47 @@
 (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))))