(define-module (tests test-agenda)
#:use-module (srfi srfi-64)
#:use-module (ice-9 q)
+ #:use-module (ice-9 match)
#:use-module (ice-9 receive)
#:use-module (8sync agenda)
#:use-module (tests utils))
(test-equal (run-request-when run-two-squared) '(88 . 0)))
-;;; %run, %8sync and friends tests
+;;; %run, 8sync and friends tests
;;; ==============================
-(define (test-%run-and-friends async-request expected-when)
- (let* ((fake-kont (speak-it))
- (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)
- ;; we're using speaker as a fake continuation ;p
- ((run-request-proc run-request))
- (test-equal (fake-kont)
- '("applesauce"))))
-
-(test-%run-and-friends (%run (string-concatenate '("apple" "sauce")))
+(define-syntax-rule (run-in-fake-agenda
+ code-to-run)
+ (let ((agenda (make-agenda)))
+ (parameterize ((%current-agenda agenda))
+ (call-with-prompt
+ (agenda-prompt-tag agenda)
+ (lambda ()
+ (list '*normal-result* code-to-run))
+ (lambda (kont async-request)
+ (list '*caught-kont*
+ kont async-request
+ ((@@ (8sync agenda) setup-async-request)
+ kont async-request)))))))
+
+(define (test-%run-and-friends run-result expected-when)
+ (match run-result
+ (('*caught-kont* kont async-request setup-request)
+ (let* ((fake-kont (speak-it))
+ (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)
+ ;; we're using speaker as a fake continuation ;p
+ ((run-request-proc run-request))
+ (test-equal (fake-kont)
+ '("applesauce"))))))
+
+(test-%run-and-friends (run-in-fake-agenda
+ (8sync (string-concatenate '("apple" "sauce"))))
#f)
-(test-%run-and-friends (%run-at (string-concatenate '("apple" "sauce"))
- '(8 . 0))
+(test-%run-and-friends (run-in-fake-agenda
+ (8sync (string-concatenate '("apple" "sauce"))
+ '(8 . 0)))
'(8 . 0))
-(test-%run-and-friends (%run-delay (string-concatenate '("apple" "sauce"))
- 8)
+(test-%run-and-friends (run-in-fake-agenda
+ (8sync-delay (string-concatenate '("apple" "sauce"))
+ 8))
;; whoa, I'm surprised equal? can
;; compare records like this
(tdelta 8))
;; TODO: test %port-request
-;; TODO: test %8sync and friends!
+;; TODO: test 8sync and friends!
;;; Agenda tests
(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
- (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
-(let ((q (make-q)))
+(begin
(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")))
(speaker "Today I went to the zoo and I saw...\n")
(speaker
(string-concatenate
- `("A " ,(symbol->string (%8sync (%run (return-monkey)))) "!\n"))))
+ `("A " ,(symbol->string (8sync (return-monkey))) "!\n"))))
-(let ((q (make-q)))
+(begin
(set! speaker (speak-it))
- (enq! q talk-about-the-zoo)
;; (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"
(define (indirection-remote-func-breaks)
(speaker "bebop\n")
- (%8sync (%run (remote-func-breaks)))
+ (8sync (remote-func-breaks))
(speaker "bidop\n"))
(define* (local-func-gets-break #:key with-indirection)
(speaker "Time for exception fun!\n")
(let ((caught-exception #f))
(catch-8sync
- (%8sync (%run (if with-indirection
- (indirection-remote-func-breaks)
- (remote-func-breaks))))
+ (8sync-run (if with-indirection
+ (indirection-remote-func-breaks)
+ (remote-func-breaks)))
('numerical-overflow
(lambda (orig-stacks . orig-args)
(set! caught-exception #t)
(speaker "Well that was fun :)\n"))
-(let ((q (make-q)))
+(begin
(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))
- (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))
- (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))
- (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