X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Finterface.pure.lisp;h=2a5c3d6c882221b0afe102346bfb841f4108f476;hb=d06e99b8e2f7901a6774b2d7da0f1ae1bc6dd8d5;hp=7c600c6d41fd10bdc9155394c8c711ce25af42a0;hpb=4c81c652cdc32faefee1bccb84c3c9a7854e3edd;p=sbcl.git

diff --git a/tests/interface.pure.lisp b/tests/interface.pure.lisp
index 7c600c6..2a5c3d6 100644
--- a/tests/interface.pure.lisp
+++ b/tests/interface.pure.lisp
@@ -12,6 +12,10 @@
 ;;;; more information.
 
 (in-package :cl-user)
+
+(load "test-util.lisp")
+(load "compiler-test-util.lisp")
+(use-package :test-util)
 
 ;;;; properties of symbols, e.g. presence of doc strings for public symbols
 
@@ -63,9 +67,16 @@
       (sleep 2)
       (sleep 2))))
 
-;;; SLEEP should work with large integers as well -- no timers
-;;; on win32, so don't test there.
-(with-test (:name (sleep pretty-much-forever) :skipped-on :win32)
+;;; SLEEP should not cons
+(with-test (:name (sleep :non-consing) :fails-on :win32)
+  (ctu:assert-no-consing (sleep 0.00001s0))
+  (locally (declare (notinline sleep))
+    (ctu:assert-no-consing (sleep 0.00001s0))
+    (ctu:assert-no-consing (sleep 0.00001d0))
+    (ctu:assert-no-consing (sleep 1/100000000000000))))
+
+;;; SLEEP should work with large integers as well
+(with-test (:name (sleep pretty-much-forever))
   (assert (eq :timeout
               (handler-case
                   (sb-ext:with-timeout 1
@@ -116,3 +127,30 @@
 (loop repeat 2
       do (compile nil '(lambda (x) x))
       do (sb-ext:gc :full t))
+
+;;; On x86-64, the instruction definitions for CMP*[PS][SD] were broken
+;;; so that the disassembler threw an error when they were used with
+;;; one operand in memory.
+(with-test (:name :bug-814702)
+  (disassemble (lambda (x)
+                 (= #C(2.0f0 3.0f0)
+                    (the (complex single-float) x))))
+  (disassemble (lambda (x y)
+                 (= (the (complex single-float) x)
+                    (the (complex single-float) y)))))
+
+;;; Check that SLEEP called with ratios (with no common factors with
+;;; 1000000000, and smaller than 1/1000000000) works more or less as
+;;; expected.
+(with-test (:name :sleep-ratios)
+  (let ((fun0a (compile nil '(lambda () (sleep 1/7))))
+        (fun0b (compile nil '(lambda () (sleep 1/100000000000000000000000000))))
+        (fun1 (compile nil '(lambda (x) (sleep x))))
+        (start-time (get-universal-time)))
+    (sleep 1/7)
+    (sleep 1/100000000000000000000000000)
+    (funcall fun0a)
+    (funcall fun0b)
+    (funcall fun1 1/7)
+    (funcall fun1 1/100000000000000000000000000)
+    (assert (< (- (get-universal-time) start-time) 2))))