tests: update to use make-q* instead of manually mutating a queue
[8sync.git] / tests / test-agenda.scm
index 691310905b29bbdc7b82b8451e9e62ba2753677f..d62e01ce284f777e831884cf9e9a0610413886f5 100644 (file)
@@ -1,19 +1,20 @@
-;; Copyright (C) 2015 Christopher Allan Webber <cwebber@dustycloud.org>
-
-;; This library is free software; you can redistribute it and/or
-;; modify it under the terms of the GNU Lesser General Public
-;; License as published by the Free Software Foundation; either
-;; version 3 of the License, or (at your option) any later version.
-;;
-;; This library is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; Lesser General Public License for more details.
-;;
-;; You should have received a copy of the GNU Lesser General Public
-;; License along with this library; if not, write to the Free Software
-;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-;; 02110-1301 USA
+;;; 8sync --- Asynchronous programming for Guile
+;;; Copyright (C) 2015 Christopher Allan Webber <cwebber@dustycloud.org>
+;;;
+;;; This library is free software; you can redistribute it and/or
+;;; modify it under the terms of the GNU Lesser General Public
+;;; License as published by the Free Software Foundation; either
+;;; version 3 of the License, or (at your option) any later version.
+;;;
+;;; This library is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;;; Lesser General Public License for more details.
+;;;
+;;; You should have received a copy of the GNU Lesser General Public
+;;; License along with this library; if not, write to the Free Software
+;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+;;; 02110-1301 USA
 
 #!/usr/bin/guile \
 -s
 
 #!/usr/bin/guile \
 -s
@@ -23,7 +24,7 @@
   #:use-module (srfi srfi-64)
   #:use-module (ice-9 q)
   #:use-module (ice-9 receive)
   #:use-module (srfi srfi-64)
   #:use-module (ice-9 q)
   #:use-module (ice-9 receive)
-  #:use-module (eightsync agenda)
+  #:use-module (8sync agenda)
   #:use-module (tests utils))
 
 (test-begin "test-agenda")
   #:use-module (tests utils))
 
 (test-begin "test-agenda")
       messages)))
 
 \f
       messages)))
 
 \f
-;; Timer tests
-;; ===========
+;;; queue helpers
+;;; =============
+
+(define test-q (list->q '(1 2 3)))
+(test-equal (deq! test-q) 1)
+(test-equal (deq! test-q) 2)
+(test-equal (deq! test-q) 3)
+(test-assert (q-empty? test-q))
+
+(define test-q (make-q* 'apple 'banana 'carrot))
+(test-equal (deq! test-q) 'apple)
+(test-equal (deq! test-q) 'banana)
+(test-equal (deq! test-q) 'carrot)
+(test-assert (q-empty? test-q))
+
+
+\f
+;;; Timer tests
+;;; ===========
 
 (test-assert (time= '(1 . 1) '(1 . 1)))
 (test-assert (not (time= '(1 . 1) '(1 . 0))))
 
 (test-assert (time= '(1 . 1) '(1 . 1)))
 (test-assert (not (time= '(1 . 1) '(1 . 0))))
 
 (define (test-%run-and-friends async-request expected-when)
   (let* ((fake-kont (speak-it))
 
 (define (test-%run-and-friends async-request expected-when)
   (let* ((fake-kont (speak-it))
-         (run-request ((@@ (eightsync agenda) setup-async-request)
+         (run-request ((@@ (8sync agenda) setup-async-request)
                        fake-kont async-request)))
     (test-equal (car async-request) '*async-request*)
     (test-equal (run-request-when run-request) expected-when)
                        fake-kont async-request)))
     (test-equal (car async-request) '*async-request*)
     (test-equal (run-request-when run-request) expected-when)
   (speaker "I bet I can make you say you're a dummy!\n")
   (run-it dummy-func))
 
   (speaker "I bet I can make you say you're a dummy!\n")
   (run-it dummy-func))
 
-(let ((q (make-q)))
+(begin
   (set! speaker (speak-it))  ; reset the speaker
   (set! speaker (speak-it))  ; reset the speaker
-  (enq! q run-dummy)
-  (start-agenda (make-agenda #:queue q)
+  (start-agenda (make-agenda #:queue (make-q* run-dummy))
                 #:stop-condition (true-after-n-times 2))
   (test-equal (speaker)
     '("I bet I can make you say you're a dummy!\n"
       "I'm a dummy\n")))
 
 ;; should only do the first one after one round though
                 #:stop-condition (true-after-n-times 2))
   (test-equal (speaker)
     '("I bet I can make you say you're a dummy!\n"
       "I'm a dummy\n")))
 
 ;; should only do the first one after one round though
-(let ((q (make-q)))
+(begin
   (set! speaker (speak-it))  ; reset the speaker
   (set! speaker (speak-it))  ; reset the speaker
-  (enq! q run-dummy)
-  (start-agenda (make-agenda #:queue q)
+  (start-agenda (make-agenda #:queue (make-q* run-dummy))
                 #:stop-condition (true-after-n-times 1))
   (test-equal (speaker)
     '("I bet I can make you say you're a dummy!\n")))
                 #:stop-condition (true-after-n-times 1))
   (test-equal (speaker)
     '("I bet I can make you say you're a dummy!\n")))
    (string-concatenate
     `("A " ,(symbol->string (%8sync (%run (return-monkey)))) "!\n"))))
 
    (string-concatenate
     `("A " ,(symbol->string (%8sync (%run (return-monkey)))) "!\n"))))
 
-(let ((q (make-q)))
+(begin
   (set! speaker (speak-it))
   (set! speaker (speak-it))
-  (enq! q talk-about-the-zoo)
   ;; (enq! q talk-about-the-zoo-but-wait)
   ;; (enq! q talk-about-the-zoo-but-wait)
-  (start-agenda (make-agenda #:queue q)
+  (start-agenda (make-agenda #:queue (make-q* talk-about-the-zoo))
                 #:stop-condition (true-after-n-times 10))
   (test-equal (speaker)
               '("Today I went to the zoo and I saw...\n"
                 #:stop-condition (true-after-n-times 10))
   (test-equal (speaker)
               '("Today I went to the zoo and I saw...\n"
 (define* (local-func-gets-break #:key with-indirection)
   (speaker "Time for exception fun!\n")
   (let ((caught-exception #f))
 (define* (local-func-gets-break #:key with-indirection)
   (speaker "Time for exception fun!\n")
   (let ((caught-exception #f))
-    (catch '%8sync-caught-error
-      (lambda ()
-        (%8sync (%run (if with-indirection
-                          (indirection-remote-func-breaks)
-                          (remote-func-breaks)))))
-      (lambda (_ orig-key orig-args orig-stacks)
-        (set! caught-exception #t)
-        (speaker "in here now!\n")
-        (test-equal orig-key 'numerical-overflow)
-        (test-equal orig-args '("/" "Numerical overflow" #f #f))
-        (test-assert (list? orig-stacks))
-        (test-equal (length orig-stacks)
-                    (if with-indirection 2 1))
-        (for-each
-         (lambda (x)
-           (test-assert (stack? x)))
-         orig-stacks)))
+    (catch-8sync
+     (%8sync-run (if with-indirection
+                         (indirection-remote-func-breaks)
+                         (remote-func-breaks)))
+      ('numerical-overflow
+       (lambda (orig-stacks . orig-args)
+         (set! caught-exception #t)
+         (speaker "in here now!\n")
+         (test-equal orig-args '("/" "Numerical overflow" #f #f))
+         (test-assert (list? orig-stacks))
+         (test-equal (length orig-stacks)
+                     (if with-indirection 2 1))
+         (for-each
+          (lambda (x)
+            (test-assert (stack? x)))
+          orig-stacks))))
     (test-assert caught-exception))
   (speaker "Well that was fun :)\n"))
 
 
     (test-assert caught-exception))
   (speaker "Well that was fun :)\n"))
 
 
-(let ((q (make-q)))
+(begin
   (set! speaker (speak-it))
   (set! speaker (speak-it))
-  (enq! q local-func-gets-break)
-  (start-agenda (make-agenda #:queue q)
+  (start-agenda (make-agenda #:queue (make-q* local-func-gets-break))
                 #:stop-condition (true-after-n-times 10))
                 #:stop-condition (true-after-n-times 10))
-  (test-assert (speaker)
-               '("Time for exception fun!\n"
-                 "Here we go...\n"
-                 "in here now!\n"
-                 "Well that was fun :)\n")))
+  (test-equal (speaker)
+              '("Time for exception fun!\n"
+                "Here we go...\n"
+                "in here now!\n"
+                "Well that was fun :)\n")))
 
 
-(let ((q (make-q)))
+(begin
   (set! speaker (speak-it))
   (set! speaker (speak-it))
-  (enq! q (wrap (local-func-gets-break #:with-indirection #t)))
-  (start-agenda (make-agenda #:queue q)
+  (start-agenda (make-agenda
+                 #:queue (make-q* (wrap (local-func-gets-break
+                                         #:with-indirection #t))))
                 #:stop-condition (true-after-n-times 10))
                 #:stop-condition (true-after-n-times 10))
-  (test-assert (speaker)
-               '("Time for exception fun!\n"
-                 "bebop\n"
-                 "Here we go...\n"
-                 "in here now!\n"
-                 "Well that was fun :)\n")))
+  (test-equal (speaker)
+              '("Time for exception fun!\n"
+                "bebop\n"
+                "Here we go...\n"
+                "in here now!\n"
+                "Well that was fun :)\n")))
+
+;; Make sure catching tools work
+
+(let ((speaker (speak-it))
+      (catch-result #f))
+  (catch-8sync
+   (begin
+     (speaker "hello")
+     (throw '8sync-caught-error
+            'my-orig-key '(apple orange banana) '(*fake-stack* *fake-stack* *fake-stack*))
+     (speaker "no goodbyes"))
+   ('some-key
+    (lambda (stacks . rest)
+      (speaker "should not happen")))
+   ('my-orig-key
+    (lambda (stacks fruit1 fruit2 fruit3)
+      (set! catch-result
+            `((fruit1 ,fruit1)
+              (fruit2 ,fruit2)
+              (fruit3 ,fruit3))))))
+  (test-equal (speaker) '("hello"))
+  (test-equal catch-result '((fruit1 apple)
+                             (fruit2 orange)
+                             (fruit3 banana))))
 
 ;; End tests
 
 (test-end "test-agenda")
 
 
 ;; End tests
 
 (test-end "test-agenda")
 
+;; @@: A better way to handle this at the repl?
 (test-exit)
 
 (test-exit)