Group tests/recurrence-simple to avoid warnings.

Previously a bunch of warnings about shadowing of 'ev' was emitted.

1 files changed, 133 insertions, 177 deletions

diff --git a/tests/unit/vcomponent/recurrence-simple.scm b/tests/unit/vcomponent/recurrence-simple.scm
index 1c778223..82573ee4 100644
--- a/tests/unit/vcomponent/recurrence-simple.scm
+++ b/tests/unit/vcomponent/recurrence-simple.scm
@@ -24,6 +24,10 @@
                         recur-rule
                         generate-recurrence-set)))
 
+;;; TODO many of these tests simply check that the procedures don't crash.
+;;; Actually check outputs.
+
+
 ;;; Test that basic parsing or recurrence rules work.
 
 (test-equal (recur-rule freq: 'HOURLY wkst: mon interval: 1)
@@ -49,180 +53,133 @@
 ;;; Test that basic recurrence works
 ;;; also see the neighbour test file recurrence.scm for more tests.
 
-(define ev
-  (vevent
-   dtstart: (date year: 2029 month: mars day: 2)
-   rrule: (recur-rule freq: 'DAILY)))
+(let ((ev (vevent
+           dtstart: (date year: 2029 month: mars day: 2)
+           rrule: (recur-rule freq: 'DAILY))))
 
-(test-assert "Generate at all"
-  (stream-car (generate-recurrence-set ev)))
+  (test-assert "Generate at all"
+    (stream-car (generate-recurrence-set ev)))
 
-(test-assert "Generate some"
-  (stream->list
-    (stream-take 5 (generate-recurrence-set ev))))
+  (test-assert "Generate some"
+    (stream->list
+     (stream-take 5 (generate-recurrence-set ev))))
 
-(test-equal "Generate First"
-  (stream->list
-    5
-    (stream-map
+  (test-equal "Generate First"
+    (stream->list
+     5
+     (stream-map
       (extract 'DTSTART)
       (generate-recurrence-set ev)))
-  (stream->list 5 (day-stream (prop ev 'DTSTART))))
+    (stream->list 5 (day-stream (prop ev 'DTSTART))))
 
-;; We run the exact same thing a secound time, since I had an error with
-;; that during development.
+  ;; We run the exact same thing a secound time, since I had an error with
+  ;; that during development.
 
-(test-equal "Generate Again"
-  (stream->list
-    (stream-take
+  (test-equal "Generate Again"
+    (stream->list
+     (stream-take
       5
       (stream-map
-        (extract 'DTSTART)
-        (generate-recurrence-set ev))))
-  (stream->list
-    (stream-take 5 (day-stream (prop ev 'DTSTART)))))
-
-(test-assert "Test 1" #t)
-
-(define ev
-  (vevent
-   dtstart: (datetime year: 2019 month: mars day: 2 hour: 10)
-   rrule: (recur-rule freq: 'DAILY)))
-
-(test-assert "Test 2" #t)
-
-(test-assert "daily 10:00"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (datetime year: 2019 month: mars day: 2 hour: 10)
-   dtend: (datetime year: 2019 month: mars day: 2 hour: 12)
-   rrule: (recur-rule freq: 'DAILY)))
-
-(test-assert "daily 10-12"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (datetime year: 2019 month: mars day: 2 hour: 10)
-   dtend: (datetime year: 2019 month: mars day: 2 hour: 12)
-   rrule: (recur-rule freq: 'WEEKLY)))
-
-(test-assert "weekly 10-12"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2019 month: mars day: 2 hour: 10))
-   dtend:   (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2019 month: mars day: 2 hour: 12))
-   rrule: (recur-rule freq: 'WEEKLY)))
-
-(test-assert "weekly TZ 10-12"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2019 month: mars day: 2 hour: 10))
-   dtend:   (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2019 month: mars day: 2 hour: 12))
-   rrule: (recur-rule freq: 'WEEKLY)
-   sequence: 1))
-
-
-(test-assert "weekly TZ SEQUENCE 10-12"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2019 month: mars day: 2 hour: 10))
-   dtend:   (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2019 month: mars day: 2 hour: 12))
-   rrule: (recur-rule freq: 'WEEKLY)
-   location: "Here"
-   sequence: 1))
-
-(test-assert "weekly TZ SEQUENCE LOCATION 10-12"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (datetime year: 2018 month: jan day: 17 hour: 17)
-   rrule: (recur-rule freq: 'WEEKLY)
-   location: "~"))
-
-(test-assert "Just location"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (datetime year: 2018 month: jan day: 17 hour: 17)
-   dtend: (datetime year: 2018 month: jan day: 17 hour: 20)
-   rrule: (recur-rule freq: 'WEEKLY)))
-
-(test-assert "Same times"
-  (stream-car (generate-recurrence-set ev)))
-
-(define ev
-  (vevent
-   dtstart: (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2018 month: jan day: 17 hour: 17))
-   dtend:   (with-parameters tzid: "Europe/Stockholm"
-                             (datetime year: 2018 month: jan day: 17 hour: 20))
-   rrule: (recur-rule freq: 'WEEKLY)))
-
-;; errer in dtend ?
-
-(test-assert "Full test"
-  (stream-car (generate-recurrence-set ev)))
+       (extract 'DTSTART)
+       (generate-recurrence-set ev))))
+    (stream->list
+     (stream-take 5 (day-stream (prop ev 'DTSTART))))))
+
+(let ((ev (vevent
+           dtstart: (datetime year: 2019 month: mars day: 2 hour: 10)
+           rrule: (recur-rule freq: 'DAILY))))
+  (test-assert "daily 10:00"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+           dtstart: (datetime year: 2019 month: mars day: 2 hour: 10)
+           dtend: (datetime year: 2019 month: mars day: 2 hour: 12)
+           rrule: (recur-rule freq: 'DAILY))))
+  (test-assert "daily 10-12"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+           dtstart: (datetime year: 2019 month: mars day: 2 hour: 10)
+           dtend: (datetime year: 2019 month: mars day: 2 hour: 12)
+           rrule: (recur-rule freq: 'WEEKLY))))
+  (test-assert "weekly 10-12"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+         dtstart: (with-parameters tzid: "Europe/Stockholm"
+                                   (datetime year: 2019 month: mars day: 2 hour: 10))
+         dtend:   (with-parameters tzid: "Europe/Stockholm"
+                                   (datetime year: 2019 month: mars day: 2 hour: 12))
+         rrule: (recur-rule freq: 'WEEKLY))))
+  (test-assert "weekly TZ 10-12"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+           dtstart: (with-parameters tzid: "Europe/Stockholm"
+                                     (datetime year: 2019 month: mars day: 2 hour: 10))
+           dtend:   (with-parameters tzid: "Europe/Stockholm"
+                                     (datetime year: 2019 month: mars day: 2 hour: 12))
+           rrule: (recur-rule freq: 'WEEKLY)
+           sequence: 1)))
+  (test-assert "weekly TZ SEQUENCE 10-12"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+           dtstart: (with-parameters tzid: "Europe/Stockholm"
+                                     (datetime year: 2019 month: mars day: 2 hour: 10))
+           dtend:   (with-parameters tzid: "Europe/Stockholm"
+                                     (datetime year: 2019 month: mars day: 2 hour: 12))
+           rrule: (recur-rule freq: 'WEEKLY)
+           location: "Here"
+           sequence: 1)))
+  (test-assert "weekly TZ SEQUENCE LOCATION 10-12"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+           dtstart: (datetime year: 2018 month: jan day: 17 hour: 17)
+           rrule: (recur-rule freq: 'WEEKLY)
+           location: "~")))
+  (test-assert "Just location"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+           dtstart: (datetime year: 2018 month: jan day: 17 hour: 17)
+           dtend: (datetime year: 2018 month: jan day: 17 hour: 20)
+           rrule: (recur-rule freq: 'WEEKLY))))
+  (test-assert "Same times"
+    (stream-car (generate-recurrence-set ev))))
+
+(let ((ev (vevent
+           dtstart: (with-parameters tzid: "Europe/Stockholm"
+                                     (datetime year: 2018 month: jan day: 17 hour: 17))
+           dtend:   (with-parameters tzid: "Europe/Stockholm"
+                                     (datetime year: 2018 month: jan day: 17 hour: 20))
+           rrule: (recur-rule freq: 'WEEKLY))))
+
+  ;; errer in dtend ?
+  (test-assert "Full test"
+    (stream-car (generate-recurrence-set ev))))
 
 ;;; Tests that exceptions (in the recurrence-id meaning)
 ;;; in recurrence sets are handled correctly.
 ;;; TODO Is however far from done.
 
-(define uid (symbol->string (gensym "areallyuniqueid")))
-
-;; TODO standardize vcomponents for tests as xcal, for example:
-`(vcalendar
-   (children
-     (vevent
-       (properties
-         (summary
-           (text "Changing type on Recurrence-id."))
-         (uid (text ,uid))
-         (dtstart (date "20090127"))))
-     (vevent
-       (properties
-         (summary
-           (text "Changing type on Recurrence-id."))
-         (uid (text ,uid))
-         (dtstart
-           (params (TZID "Europe/Stockholm"))
-           (date-time "20100127T120000"))
-         (recurrence-id (date "20100127"))
-         (summary
-           "This instance only has a time component")))))
-
-(define ev
-  (vcalendar
-   (list
-    (vevent
-     summary: "Changing type on Recurrence-id."
-     uid: uid
-     dtstart: (date year: 2009 month: jan day: 27))
-    (vevent
-     uid: uid
-     summary: "Changing type on Recurrence-id."
-     dtstart: (with-parameters tzid: "Europe/Stockholm"
-                               (datetime year: 2010 month: jan day: 12 hour: 12))
-     summary: "This instance only has a time component)"))))
-
-(test-assert "Changing type on Recurrence id."
-  (stream->list 10 (generate-recurrence-set ev)))
+(let* ((uid (symbol->string (gensym "areallyuniqueid")))
+       (ev
+        (vcalendar
+         (list
+          (vevent
+           summary: "Changing type on Recurrence-id."
+           uid: uid
+           dtstart: (date year: 2009 month: jan day: 27))
+          (vevent
+           uid: uid
+           summary: "Changing type on Recurrence-id."
+           dtstart: (with-parameters tzid: "Europe/Stockholm"
+                                     (datetime year: 2010 month: jan day: 12 hour: 12))
+           summary: "This instance only has a time component)")))))
+  (test-assert "Changing type on Recurrence id."
+    (stream->list 10 (generate-recurrence-set ev))))
 
 ;;; Earlier I failed to actually parse the recurrence parts, in short, 1 ≠ "1".
 
@@ -233,23 +190,22 @@
 ;;    'props-are-unused-for-recur
 ;;    '((freq "WEEKLY") (interval "1") (wkst "MO"))))
 
-(define ev
-  (vevent
-   summary: "reptest"
-   dtstart: (datetime year: 2021 month: jan day: 13 hour: 1)
-   dtend: (datetime year: 2021 month: jan day: 13 hour: 2)
-   uid: "RNW198S6QANQPV1C4FDNFH6ER1VZX6KXEYNB"
-   rrule: (recur-rule freq: 'WEEKLY
-                      interval: 1
-                      wkst: monday)
-   dtstamp: (datetime year: 2021 month: jan day: 13
-                      hour: 1 minute: 42 second: 20
-                      tz: "UTC")
-   sequence: 0))
-
-(test-assert
-  "Check that recurrence rule commint from xcal also works"
-  (generate-recurrence-set ev))
+(let ((ev (vevent
+           summary: "reptest"
+           dtstart: (datetime year: 2021 month: jan day: 13 hour: 1)
+           dtend: (datetime year: 2021 month: jan day: 13 hour: 2)
+           uid: "RNW198S6QANQPV1C4FDNFH6ER1VZX6KXEYNB"
+           rrule: (recur-rule freq: 'WEEKLY
+                              interval: 1
+                              wkst: monday)
+           dtstamp: (datetime year: 2021 month: jan day: 13
+                              hour: 1 minute: 42 second: 20
+                              tz: "UTC")
+           sequence: 0)))
+
+  (test-assert
+      "Check that recurrence rule commint from xcal also works"
+    (generate-recurrence-set ev)))
 
 
 ;;; TODO test here, for byday parsing, and multiple byday instances in one recur element