Update number of tests.

6 files changed, 114 insertions, 163 deletions

diff --git a/tests/unit/util/object.scm b/tests/unit/util/object.scm
index 6db9890c..55b1313c 100644
--- a/tests/unit/util/object.scm
+++ b/tests/unit/util/object.scm
@@ -84,7 +84,7 @@
         (o2 (f3 f3-x: 10 f3-y: "string")))
     (test-eq "An object is itself" o1 o1)
     (test-assert "Two identical objects are different objects"
-      (not (eq?? o1 o2)))
+      (not (eq? o1 o2)))
     (test-equal "Two identical objects are equal" o1 o2)))
 
 '((hnh util object))
diff --git a/tests/unit/vcomponent/param.scm b/tests/unit/vcomponent/param.scm
index 9611fd8a..68feb1ac 100644
--- a/tests/unit/vcomponent/param.scm
+++ b/tests/unit/vcomponent/param.scm
@@ -9,26 +9,16 @@
   :use-module (srfi srfi-88)
   :use-module ((vcomponent base)
                :select (param prop* parameters prop vline?))
-  :use-module ((vcomponent formats ical parse)
-               :select (parse-calendar))
   :use-module ((vcomponent) :select (vcomponent properties set-properties))
+  :use-module ((vcomponent create) :select (vcomponent with-parameters))
   :use-module ((hnh util) :select (sort* set!))
   :use-module ((ice-9 ports) :select (call-with-input-string))
-  :use-module ((vcomponent formats xcal output)
-               :select (vcomponent->sxcal))
   )
 
-;; TODO clean up this whole test
-
-;; TODO possibly change parsing
-
 (define v
-  (car
-   (call-with-input-string
-       "BEGIN:DUMMY
-X-KEY;A=1;B=2:Some text
-END:DUMMY"
-     parse-calendar)))
+  (vcomponent 'DUMMY
+              x-key: (with-parameters a: "1" b: "2"
+                                      "Some text")))
 
 (test-equal '("1") (param (prop* v 'X-KEY) 'A))
 
@@ -45,25 +35,4 @@ END:DUMMY"
    (test-assert (vline? (cadar p)))))
 
 
-
-;; TODO possibly move this.
-;; Checks that a warning is properly raised for
-;; unkonwn keys (without an X-prefix)
-(test-error "Ensure parse-calendar warns on unknown keys"
-  'warning
-  (call-with-input-string
-    "BEGIN:DUMMY
-KEY:Some Text
-END:DUMMY"
-    parse-calendar))
-
-;; Similar thing happens for sxcal, but during serialization instead
-(let ((component (set-properties (vcomponent type: 'DUMMY)
-                                 (cons 'KEY "Anything"))))
-
-  (test-error
-    'warning
-    (vcomponent->sxcal component)))
-
-'((vcomponent base)
-  (vcomponent formats xcal output))
+'((vcomponent base))
diff --git a/tests/unit/vcomponent/recurrence-simple.scm b/tests/unit/vcomponent/recurrence-simple.scm
index 31a74989..dff57346 100644
--- a/tests/unit/vcomponent/recurrence-simple.scm
+++ b/tests/unit/vcomponent/recurrence-simple.scm
@@ -15,18 +15,16 @@
   :use-module ((sxml namespaced) :select (sxml->namespaced-sxml))
   :use-module ((calp namespaces) :select (xcal))
   :use-module ((hnh util) :select (->))
+  :use-module (datetime)
+  :use-module ((vcomponent create) :select (vcalendar vevent with-parameters))
   :use-module ((hnh util exceptions)
                :select (warnings-are-errors warning-handler))
-  :use-module ((vcomponent formats ical parse)
-               :select (parse-calendar))
-  :use-module ((vcomponent formats xcal parse)
-               :select (sxcal->vcomponent))
   :use-module ((vcomponent recurrence)
                :select (parse-recurrence-rule
                         make-recur-rule
                         generate-recurrence-set)))
 
-;; TODO evaluate format for direct events
+(define recur-rule make-recur-rule)
 
 ;;; Test that basic parsing or recurrence rules work.
 
@@ -54,13 +52,9 @@
 ;;; also see the neighbour test file recurrence.scm for more tests.
 
 (define ev
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART;VALUE=DATE:20190302
-RRULE:FREQ=DAILY
-END:VEVENT"
-     parse-calendar)))
+  (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)))
@@ -93,13 +87,9 @@ END:VEVENT"
 (test-assert "Test 1" #t)
 
 (define ev
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART:20190302T100000
-RRULE:FREQ=DAILY
-END:VEVENT"
-     parse-calendar)))
+  (vevent
+   dtstart: (datetime year: 2019 month: mars day: 2 hour: 10)
+   rrule: (recur-rule freq: 'DAILY)))
 
 (test-assert "Test 2" #t)
 
@@ -107,110 +97,85 @@ END:VEVENT"
   (stream-car (generate-recurrence-set ev)))
 
 (define ev
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART:20190302T100000
-DTEND:20190302T120000
-RRULE:FREQ=DAILY
-END:VEVENT"
-     parse-calendar)))
+  (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
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART:20190302T100000
-DTEND:20190302T120000
-RRULE:FREQ=WEEKLY
-END:VEVENT"
-     parse-calendar)))
+  (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
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART;TZID=Europe/Stockholm:20190302T100000
-DTEND;TZID=Europe/Stockholm:20190302T120000
-RRULE:FREQ=WEEKLY
-END:VEVENT"
-     parse-calendar)))
+  (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
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART;TZID=Europe/Stockholm:20190302T100000
-DTEND;TZID=Europe/Stockholm:20190302T120000
-RRULE:FREQ=WEEKLY
-SEQUENCE:1
-END:VEVENT"
-     parse-calendar)))
+  (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
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART;TZID=Europe/Stockholm:20190302T100000
-RRULE:FREQ=WEEKLY
-DTEND;TZID=Europe/Stockholm:20190302T120000
-SEQUENCE:1
-LOCATION:Here
-END:VEVENT"
-     parse-calendar)))
+  (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
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART:20180117T170000
-RRULE:FREQ=WEEKLY
-LOCATION:~
-END:VEVENT"
-     parse-calendar)))
+  (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
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART;TZID=Europe/Stockholm:20180117T170000
-DTEND;TZID=Europe/Stockholm:20180117T200000
-RRULE:FREQ=WEEKLY
-END:VEVENT"
-     parse-calendar)))
+  (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
-  (car
-   (call-with-input-string
-       "BEGIN:VEVENT
-DTSTART;TZID=Europe/Stockholm:20180117T170000
-RRULE:FREQ=WEEKLY
-DTEND;TZID=Europe/Stockholm:20180117T200000
-SEQUENCE:1
-LOCATION:~
-END:VEVENT"
-     parse-calendar)))
+  (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 ?
 
@@ -245,26 +210,18 @@ END:VEVENT"
            "This instance only has a time component")))))
 
 (define ev
-  (call-with-input-string
-    (format
-      #f
-      "BEGIN:VCALENDAR
-BEGIN:VEVENT
-SUMMARY:Changing type on Recurrence-id.
-UID:~a
-DTSTART;VALUE=DATE:20090127
-END:VEVENT
-BEGIN:VEVENT
-UID:~a
-SUMMARY:Changing type on Recurrence-id.
-DTSTART;TZID=Europe/Stockholm:20100127T120000
-RECURRENCE-ID;VALUE=DATE:20100127
-SUMMARY:This instance only has a time component
-END:VEVENT
-END:VCALENDAR"
-      uid
-      uid)
-    parse-calendar))
+  (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)))
@@ -278,20 +235,18 @@ END:VCALENDAR"
    '((freq "WEEKLY") (interval "1") (wkst "MO"))))
 
 (define ev
-  (-> '(vevent
-        (properties
-         (summary (text "reptest"))
-         (dtend (date-time "2021-01-13T02:00:00"))
-         (dtstart (date-time "2021-01-13T01:00:00"))
-         (uid (text "RNW198S6QANQPV1C4FDNFH6ER1VZX6KXEYNB"))
-         (rrule (recur (freq "WEEKLY")
-                       (interval "1")
-                       (wkst "MO")))
-         (dtstamp (date-time "2021-01-13T01:42:20Z"))
-         (sequence (integer "0")))
-        (components))
-      (sxml->namespaced-sxml `((#f . ,xcal)))
-      sxcal->vcomponent))
+  (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"
diff --git a/tests/unit/vcomponent/vcomponent-control.scm b/tests/unit/vcomponent/vcomponent-control.scm
index 7ebafa3d..fbf40408 100644
--- a/tests/unit/vcomponent/vcomponent-control.scm
+++ b/tests/unit/vcomponent/vcomponent-control.scm
@@ -8,8 +8,6 @@
   :use-module (vcomponent create)
   :use-module ((vcomponent util control)
                :select (with-replaced-properties))
-  :use-module ((vcomponent formats ical parse)
-               :select (parse-calendar))
   :use-module ((vcomponent base) :select (prop)))
 
 (define ev (vcomponent 'DUMMY x-key: "value"))
diff --git a/tests/unit/vcomponent/vcomponent-formats-common-types.scm b/tests/unit/vcomponent/vcomponent-formats-common-types.scm
index 1d7c77cf..72273999 100644
--- a/tests/unit/vcomponent/vcomponent-formats-common-types.scm
+++ b/tests/unit/vcomponent/vcomponent-formats-common-types.scm
@@ -2,6 +2,7 @@
   :use-module (srfi srfi-64)
   :use-module (srfi srfi-64 test-error)
   :use-module (srfi srfi-88)
+  :use-module (hnh util table)
   :use-module ((vcomponent formats common types)
                :select (get-parser))
   :use-module ((datetime) :select (date time datetime)))
@@ -42,7 +43,7 @@
 (test-equal
     (datetime year: 2021 month: 12 day: 02 hour: 10 minute: 20 second: 30)
   (parse-datetime
-    (make-hash-table)
+    (table)
     "20211202T102030"))
 
 ;; TODO tests with timezones here
diff --git a/tests/unit/vcomponent/vcomponent.scm b/tests/unit/vcomponent/vcomponent.scm
index ebd0b1ff..523cce54 100644
--- a/tests/unit/vcomponent/vcomponent.scm
+++ b/tests/unit/vcomponent/vcomponent.scm
@@ -8,7 +8,8 @@
   :use-module (srfi srfi-88)
   :use-module (hnh util table)
   :use-module (datetime)
-  :use-module (vcomponent base))
+  :use-module (vcomponent base)
+  :use-module ((vcomponent create) :select (vevent vcalendar with-parameters)))
 
 
 
@@ -87,6 +88,33 @@
            `((K1 . "V1")
              (K2 . "V2"))))))
 
+(test-equal "VLine string representation"
+  "#<<vline> key: KEY value: \"Value\" parameters: #f>"
+ (with-output-to-string
+   (lambda ()
+     (write (vline key: 'KEY vline-value: "Value") ))))
+
+;; (test-equal "VLine with parameters representation"
+;;   "#<<vline> key: KEY value: \"Value\" parameters: #f>"
+;;  (with-output-to-string
+;;    (lambda ()
+;;      (write (vline key: 'KEY vline-value: "Value") ))))
+
+(test-equal "VComponent string representation"
+  "(vcomponent (quote VCALENDAR) (list (vcomponent (quote VEVENT) #:dtstart #<<vline> key: DTSTART value: #2023-03-01T10:00:00 parameters: #f> #:uid #<<vline> key: UID value: \"049d9004-cb1e-4c8d-bb54-042689d9808b\" parameters: #f>)))"
+
+  (with-output-to-string
+    (lambda ()
+      (write (vcalendar
+              ;; name: "Hello"
+              (list (vevent
+                     uid: "049d9004-cb1e-4c8d-bb54-042689d9808b"
+                     dtstart:
+                     (with-parameters
+                      tzid: "Europe/Stockholm"
+                      (datetime year: 2023 month: mars day: 1
+                                hour: 10)))))))))
+
 ;; remove-property
 
 ;; extract extract*