;;; Test derivation of LOG{AND,IOR,XOR} bounds for unsigned arguments.
;;;
;;; Fear the Loop of Doom!
+;;;
+;;; (In fact, this is such a fearsome loop that executing it with the
+;;; evaluator would take ages... Disable it under those circumstances.)
+#+#.(cl:if (cl:eq sb-ext:*evaluator-mode* :compile) '(and) '(or))
(let* ((bits 5)
(size (ash 1 bits)))
(flet ((brute-force (a b c d op minimize)
(let ((deriver (intern (format nil "~A-DERIVE-UNSIGNED-~:[HIGH~;LOW~]-BOUND"
op minimize)
(find-package :sb-c))))
+ (format t "testing type derivation: ~A~%" deriver)
(loop for a from 0 below size do
(loop for b from a below size do
(loop for c from 0 below size do
(sb-kernel:type=
(sb-kernel:specifier-type '(simple-array an-unkown-type (7)))
(sb-kernel:specifier-type '(simple-array an-unkown-type (8))))))
+
+(assert
+ (sb-kernel:type/= (sb-kernel:specifier-type 'cons)
+ (sb-kernel:specifier-type '(cons single-float single-float))))
+
+(multiple-value-bind (match win)
+ (sb-kernel:type= (sb-kernel:specifier-type '(cons integer))
+ (sb-kernel:specifier-type '(cons)))
+ (assert (and (not match) win)))
+
+(assert (typep #p"" 'sb-kernel:instance))
+(assert (subtypep '(member #p"") 'sb-kernel:instance))
+
+(with-test (:name (:typep :character-set :negation))
+ (flet ((generate-chars ()
+ (loop repeat 100
+ collect (code-char (random char-code-limit)))))
+ (dotimes (i 1000)
+ (let* ((chars (generate-chars))
+ (type `(member ,@chars))
+ (not-type `(not ,type)))
+ (dolist (char chars)
+ (assert (typep char type))
+ (assert (not (typep char not-type))))
+ (let ((other-chars (generate-chars)))
+ (dolist (char other-chars)
+ (unless (member char chars)
+ (assert (not (typep char type)))
+ (assert (typep char not-type)))))))))
+
+(with-test (:name (:check-type :store-value :complex-place))
+ (let ((a (cons 0.0 2))
+ (handler-invoked nil))
+ (handler-bind ((error
+ (lambda (c)
+ (declare (ignore c))
+ (assert (not handler-invoked))
+ (setf handler-invoked t)
+ (invoke-restart 'store-value 1))))
+ (check-type (car a) integer))
+ (assert (eql (car a) 1))))
+
+;;; The VOP FIXNUMP/UNSIGNED-BYTE-64 was broken on x86-64, failing
+;;; the first ASSERT below. The second ASSERT takes care that the fix
+;;; doesn't overshoot the mark.
+(with-test (:name (:typep :fixnum-if-unsigned-byte))
+ (let ((f (compile nil
+ (lambda (x)
+ (declare (type (unsigned-byte #.sb-vm:n-word-bits) x))
+ (typep x (quote fixnum))))))
+ (assert (not (funcall f (1+ most-positive-fixnum))))
+ (assert (funcall f most-positive-fixnum))))
+
+(with-test (:name (:typep :member-uses-eql))
+ (assert (eval '(typep 1/3 '(member 1/3 nil))))
+ (assert (eval '(typep 1.0 '(member 1.0 t))))
+ (assert (eval '(typep #c(1.1 1.2) '(member #c(1.1 1.2)))))
+ (assert (eval '(typep #c(1 1) '(member #c(1 1)))))
+ (let ((bignum1 (+ 12 most-positive-fixnum))
+ (bignum2 (- (+ 15 most-positive-fixnum) 3)))
+ (assert (eval `(typep ,bignum1 '(member ,bignum2))))))
+
+(with-test (:name :opt+rest+key-canonicalization)
+ (let ((type '(function (&optional t &rest t &key (:x t) (:y t)) *)))
+ (assert (equal type (sb-kernel:type-specifier (sb-kernel:specifier-type type))))))