1.0.45.31: make COPY-PPRINT-DISPATCH have access to a pristine table

[sbcl.git] / tests / timer.impure.lisp

diff --git a/tests/timer.impure.lisp b/tests/timer.impure.lisp
index 3f16fa1..150b696 100644 (file)
--- a/tests/timer.impure.lisp
+++ b/tests/timer.impure.lisp
@@ -13,10 +13,24 @@
 
 (use-package :test-util)
 
+(with-test (:name :heap)
+  (let* ((size 1000)
+         (heap (make-array size :adjustable t :fill-pointer 0))
+         (unsorted (loop for i below size collect (random size)))
+         (sorted (sort (copy-list unsorted) #'>=))
+         heap-sorted)
+    (map nil #'(lambda (val) (sb-impl::heap-insert heap val)) unsorted)
+    (setf heap-sorted (loop for i below size
+                            collect (sb-impl::heap-extract-maximum heap)))
+    (unless (equal sorted heap-sorted)
+      (error "Heap sort failure ~S" heap-sorted))))
+
 (sb-alien:define-alien-routine "check_deferrables_blocked_or_lose"
-    void)
+    void
+  (where sb-alien:unsigned-long))
 (sb-alien:define-alien-routine "check_deferrables_unblocked_or_lose"
-    void)
+    void
+  (where sb-alien:unsigned-long))
 
 (defun make-limited-timer (fn n &rest args)
   (let (timer)
@@ -47,33 +61,36 @@
                            time)
     (loop until finishedp)))
 
+#-win32
 (with-test (:name (:timer :deferrables-blocked))
   (make-and-schedule-and-wait (lambda ()
-                                (check-deferrables-blocked-or-lose))
+                                (check-deferrables-blocked-or-lose 0))
                               (random 0.1))
-  (check-deferrables-unblocked-or-lose))
+  (check-deferrables-unblocked-or-lose 0))
 
+#-win32
 (with-test (:name (:timer :deferrables-unblocked))
   (make-and-schedule-and-wait (lambda ()
                                 (sb-sys:with-interrupts
-                                  (check-deferrables-unblocked-or-lose)))
+                                  (check-deferrables-unblocked-or-lose 0)))
                               (random 0.1))
-  (check-deferrables-unblocked-or-lose))
+  (check-deferrables-unblocked-or-lose 0))
 
 #-win32
 (with-test (:name (:timer :deferrables-unblocked :unwind))
   (catch 'xxx
     (make-and-schedule-and-wait (lambda ()
-                                  (check-deferrables-blocked-or-lose)
+                                  (check-deferrables-blocked-or-lose 0)
                                   (throw 'xxx nil))
                                 (random 0.1))
     (sleep 1))
-  (check-deferrables-unblocked-or-lose))
+  (check-deferrables-unblocked-or-lose 0))
 
 (defmacro raises-timeout-p (&body body)
   `(handler-case (progn (progn ,@body) nil)
     (sb-ext:timeout () t)))
 
+#-win32
 (with-test (:name (:timer :relative)
             :fails-on '(and :sparc :linux))
   (let* ((has-run-p nil)
@@ -86,6 +103,7 @@
     (assert has-run-p)
     (assert (zerop (length (sb-impl::%pqueue-contents sb-impl::*schedule*))))))
 
+#-win32
 (with-test (:name (:timer :absolute)
             :fails-on '(and :sparc :linux))
   (let* ((has-run-p nil)
@@ -116,6 +134,7 @@
                  :thread t)))
     (schedule-timer timer 0.1)))
 
+#-win32
 (with-test (:name (:timer :repeat-and-unschedule)
             :fails-on '(and :sparc :linux))
   (let* ((run-count 0)
@@ -131,6 +150,7 @@
     (assert (not (timer-scheduled-p timer)))
     (assert (zerop (length (sb-impl::%pqueue-contents sb-impl::*schedule*))))))
 
+#-win32
 (with-test (:name (:timer :reschedule))
   (let* ((has-run-p nil)
          (timer (make-timer (lambda ()
@@ -141,29 +161,44 @@
     (assert has-run-p)
     (assert (zerop (length (sb-impl::%pqueue-contents sb-impl::*schedule*))))))
 
+#-win32
 (with-test (:name (:timer :stress))
   (let ((time (1+ (get-universal-time))))
     (loop repeat 200 do
-          (schedule-timer (make-timer (lambda ())) time :absolute-p t))
+             (schedule-timer (make-timer (lambda ())) time :absolute-p t))
     (sleep 2)
     (assert (zerop (length (sb-impl::%pqueue-contents sb-impl::*schedule*))))))
 
+#-win32
+(with-test (:name (:timer :stress2))
+  (let ((time (1+ (get-universal-time)))
+        (n 0))
+    (loop for time-n from time upto (+ 1/10 time) by (/ 1/10 200)
+          do (schedule-timer (make-timer (lambda ())) time-n :absolute-p t)
+             (incf n))
+    (sleep 2)
+    (assert (zerop (length (sb-impl::%pqueue-contents sb-impl::*schedule*))))))
+
+#-win32
 (with-test (:name (:with-timeout :timeout))
   (assert (raises-timeout-p
            (sb-ext:with-timeout 0.2
              (sleep 1)))))
 
+#-win32
 (with-test (:name (:with-timeout :fall-through))
   (assert (not (raises-timeout-p
                 (sb-ext:with-timeout 0.3
                   (sleep 0.1))))))
 
+#-win32
 (with-test (:name (:with-timeout :nested-timeout-smaller))
   (assert(raises-timeout-p
           (sb-ext:with-timeout 10
             (sb-ext:with-timeout 0.5
               (sleep 2))))))
 
+#-win32
 (with-test (:name (:with-timeout :nested-timeout-bigger))
   (assert(raises-timeout-p
           (sb-ext:with-timeout 0.5
@@ -226,7 +261,11 @@
 ;;; running out of stack (due to repeating timers being rescheduled
 ;;; before they ran) and dying threads were open interrupts.
 #+sb-thread
-(with-test (:name (:timer :parallel-unschedule))
+(with-test (:name (:timer :parallel-unschedule) :fails-on :ppc)
+  #+darwin
+  (error "Prone to hang on Darwin due to interrupt issues.")
+  #+ppc
+  (error "Prone to hang the host on linux/ppc for unknown reasons.")
   (let ((timer (sb-ext:make-timer (lambda () 42) :name "parallel schedulers"))
         (other nil))
     (flet ((flop ()
@@ -252,6 +291,7 @@
 ;;;;
 ;;;; Used to have problems in genereal, see comment on (:TIMER
 ;;;; :PARALLEL-UNSCHEDULE).
+#-win32
 (with-test (:name (:timer :schedule-stress))
   (flet ((test ()
          (let* ((slow-timers