| 1 |
;;; |
| 2 |
;;; testing SRFI-19 |
| 3 |
;;; |
| 4 |
|
| 5 |
(use gauche.test) |
| 6 |
(test-start "SRFI-19") |
| 7 |
(test-section "SRFI-19") |
| 8 |
|
| 9 |
(define-module srfi-19-tests |
| 10 |
(use gauche.test) |
| 11 |
(use srfi.19) |
| 12 |
(test-module 'srfi.19) |
| 13 |
|
| 14 |
(test* "make-time" '(#t time-utc 100 5555) |
| 15 |
(let1 t (make-time time-utc 5555 100) |
| 16 |
(list (time? t) (time-type t) (time-second t) |
| 17 |
(time-nanosecond t)))) |
| 18 |
(test* "copy-time" '(#t time-utc 100 5555) |
| 19 |
(let1 t (copy-time (make-time time-utc 5555 100)) |
| 20 |
(list (time? t) (time-type t) (time-second t) |
| 21 |
(time-nanosecond t)))) |
| 22 |
(test* "current-time" '(time-utc time-tai time-monotonic) |
| 23 |
(map time-type (list (current-time) |
| 24 |
(current-time time-tai) |
| 25 |
(current-time time-monotonic)))) |
| 26 |
(test* "time comparison" |
| 27 |
'(#t #f #f |
| 28 |
#t #f #t #f #f |
| 29 |
#t #f #t #f #t |
| 30 |
#f #t #f #t #f |
| 31 |
#f #t #f #t #t) |
| 32 |
(let ([t0 (make-time time-tai 345676543 23456)] |
| 33 |
[t1 (make-time time-tai 293892851 93853)] |
| 34 |
[t2 (make-time time-tai 893892851 93853)]) |
| 35 |
(list (time=? t0 t0) |
| 36 |
(time=? t0 t1) |
| 37 |
(time=? t1 t2) |
| 38 |
(time<? t0 t1) |
| 39 |
(time<? t1 t0) |
| 40 |
(time<? t1 t2) |
| 41 |
(time<? t2 t1) |
| 42 |
(time<? t1 t1) |
| 43 |
(time<=? t0 t1) |
| 44 |
(time<=? t1 t0) |
| 45 |
(time<=? t1 t2) |
| 46 |
(time<=? t2 t1) |
| 47 |
(time<=? t0 t0) |
| 48 |
(time>? t0 t1) |
| 49 |
(time>? t1 t0) |
| 50 |
(time>? t1 t2) |
| 51 |
(time>? t2 t1) |
| 52 |
(time>? t0 t0) |
| 53 |
(time>=? t0 t1) |
| 54 |
(time>=? t1 t0) |
| 55 |
(time>=? t1 t2) |
| 56 |
(time>=? t2 t1) |
| 57 |
(time>=? t0 t0)))) |
| 58 |
(test* "time difference" '(#t #t #t #t #t #t) |
| 59 |
(let* ([t0 (current-time)] |
| 60 |
[t1 (make-time time-utc 333333333 1000000000)] |
| 61 |
[dt (time-difference t1 t0)] |
| 62 |
[r0 (eq? (time-type dt) time-duration)] |
| 63 |
[t2 (add-duration t0 dt)] |
| 64 |
[r1 (eq? (time-type t2) (time-type t0))] |
| 65 |
[r2 (time=? t1 t2)] |
| 66 |
[r3 (begin (subtract-duration! t2 dt) |
| 67 |
(time=? t2 t0))] |
| 68 |
[r4 (begin (add-duration! t0 dt) |
| 69 |
(time=? t1 t0))] |
| 70 |
[r5 (begin (time-difference! t0 t2) |
| 71 |
(time=? t0 dt))]) |
| 72 |
(list r0 r1 r2 r3 r4 r5))) |
| 73 |
(test* "time conversion" '(#t #t) |
| 74 |
(let* ([t0 (current-time)] |
| 75 |
[ta (time-utc->time-tai t0)] |
| 76 |
[tb (time-tai->time-utc ta)] |
| 77 |
[r0 (time=? t0 tb)] |
| 78 |
[r1 (time=? ta (begin (time-utc->time-tai! t0) t0))]) |
| 79 |
(list r0 r1))) |
| 80 |
(test* "time conversion" '(#t #t) |
| 81 |
(let* ([t0 (current-time)] |
| 82 |
[ta (time-utc->time-monotonic t0)] |
| 83 |
[tb (time-monotonic->time-utc ta)] |
| 84 |
[r0 (time=? t0 tb)] |
| 85 |
[r1 (time=? ta (begin (time-utc->time-monotonic! t0) t0))]) |
| 86 |
(list r0 r1))) |
| 87 |
(let ([now (current-time)]) |
| 88 |
(test* "make-date" |
| 89 |
(let1 d1 (sys-localtime (time-second now)) |
| 90 |
(list (+ (slot-ref d1 'year) 1900) |
| 91 |
(+ (slot-ref d1 'mon) 1) |
| 92 |
(slot-ref d1 'mday) |
| 93 |
(slot-ref d1 'hour) |
| 94 |
(slot-ref d1 'min) |
| 95 |
(slot-ref d1 'sec) |
| 96 |
(time-nanosecond now) |
| 97 |
(+ (slot-ref d1 'yday) 1) |
| 98 |
(slot-ref d1 'wday))) |
| 99 |
(let1 d0 (time-utc->date now) |
| 100 |
(list (date-year d0) |
| 101 |
(date-month d0) |
| 102 |
(date-day d0) |
| 103 |
(date-hour d0) |
| 104 |
(date-minute d0) |
| 105 |
(date-second d0) |
| 106 |
(date-nanosecond d0) |
| 107 |
(date-year-day d0) |
| 108 |
(date-week-day d0))) |
| 109 |
)) |
| 110 |
(test* "date conversion" |
| 111 |
'(#t #t #t #t) |
| 112 |
(let* ([t0 (make-time 'time-utc 0 0)] |
| 113 |
[t1 (make-time 'time-utc 48375295 1022191954)] |
| 114 |
[t2 (make-time 'time-tai 0 0)] |
| 115 |
[t3 (make-time 'time-tai 48375295 1022191954)]) |
| 116 |
(list (time=? t0 (date->time-utc (time-utc->date t0))) |
| 117 |
(time=? t1 (date->time-utc (time-utc->date t1))) |
| 118 |
(time=? t2 (date->time-tai (time-tai->date t2))) |
| 119 |
(time=? t3 (date->time-tai (time-tai->date t3))) |
| 120 |
))) |
| 121 |
|
| 122 |
(test* "date past 2038/1/19" (date->time-utc (make-date 0 0 0 0 1 1 3000 0)) |
| 123 |
(julian-day->time-utc |
| 124 |
(+ (date->julian-day (make-date 0 0 0 0 1 1 2000 0)) |
| 125 |
(+ (* 365 1000) 243)))) |
| 126 |
|
| 127 |
;; NB: in Gauche, the round-trip conversion from time -> julian-day -> time |
| 128 |
;; can't be guaranteed because of the limited precision of julian-day |
| 129 |
;; calculation. We round the nanosecond range. |
| 130 |
(define (round-to-seconds time) |
| 131 |
(let1 n (time-nanosecond time) |
| 132 |
(set! (ref time 'nanosecond) 0) |
| 133 |
(when (> n 500000000) |
| 134 |
(add-duration! time (make-time 'time-duration 0 1))) |
| 135 |
time)) |
| 136 |
|
| 137 |
(let1 t0 (make-time time-utc 0 1022191954) |
| 138 |
(test "julian day number, via time-utc" |
| 139 |
t0 |
| 140 |
(^[] ($ round-to-seconds |
| 141 |
$ julian-day->time-utc $ time-utc->julian-day t0)) |
| 142 |
time=?)) |
| 143 |
(let1 jd 2453311 |
| 144 |
(test "julian day number, via date" |
| 145 |
jd |
| 146 |
(^[] (date->julian-day (julian-day->date jd))) |
| 147 |
=)) |
| 148 |
(let1 t0 (make-time time-utc 0 1022191954) |
| 149 |
(test "modified julian day number" |
| 150 |
t0 |
| 151 |
(^[] ($ round-to-seconds $ modified-julian-day->time-utc |
| 152 |
$ time-utc->modified-julian-day t0)) |
| 153 |
time=?)) |
| 154 |
|
| 155 |
|
| 156 |
(test* "date->string" |
| 157 |
"2002/05/15 01:23:34.001234567 -1000 3" |
| 158 |
(date->string (make-date 1234567 34 23 1 15 5 2002 -36000) |
| 159 |
"~Y/~m/~d ~H:~M:~S.~N ~z ~w")) |
| 160 |
(test* "date->string (past 2038)" |
| 161 |
"2100/05/15 01:23:34.001234567 -1000 6" |
| 162 |
(date->string |
| 163 |
(time-utc->date |
| 164 |
(date->time-utc |
| 165 |
(make-date 1234567 34 23 1 15 5 2100 -36000)) -36000) |
| 166 |
"~Y/~m/~d ~H:~M:~S.~N ~z ~w")) |
| 167 |
|
| 168 |
(test* "date->string" |
| 169 |
"02/05/ 1| 2|14" |
| 170 |
(date->string (make-date 1234567 4 3 14 1 5 2002 -36000) |
| 171 |
"~y/~m/~e|~l|~k")) |
| 172 |
|
| 173 |
(test* "string->date" |
| 174 |
'(2002 5 15 12 34 56 -36000) |
| 175 |
(let1 d (string->date "2002/5/15 12:34:56 (-1000)" |
| 176 |
"~Y/~m/~d ~H:~M:~S (~z)") |
| 177 |
(map (cut slot-ref d <>) |
| 178 |
'(year month day hour minute second zone-offset)))) |
| 179 |
|
| 180 |
;; NB: this test will fail when locale-dependent date name is supported. |
| 181 |
(test* "string->date" |
| 182 |
'(2002 11 2 7 14 11 32400) |
| 183 |
(let1 d (string->date "02/Nov/2002:07:14:11 +0900" |
| 184 |
"~d~b~Y~H~M~S~z") |
| 185 |
(map (cut slot-ref d <>) |
| 186 |
'(year month day hour minute second zone-offset)))) |
| 187 |
|
| 188 |
;; ISO week number ~V should be the same as strftime %V |
| 189 |
;; NB: MinGW's strftime doesn't support %V yet. Since the Scheme code is |
| 190 |
;; portable, we just skip the tests for now. |
| 191 |
;; Cf. https://sourceforge.net/p/mingw-w64/bugs/793/ |
| 192 |
(cond-expand |
| 193 |
[gauche.os.windows] |
| 194 |
[else |
| 195 |
(let ((dates '((2021 1 1) ; Friday, week 53 |
| 196 |
(2021 1 3) ; Sunday, week 53 |
| 197 |
(2021 1 4) ; Monday, week 1 |
| 198 |
(2020 12 31) ; Thursday, week 53 |
| 199 |
|
| 200 |
(2020 1 1) ; Wednesday, week 1 |
| 201 |
(2019 12 31) ; Tuesday, week 1 |
| 202 |
(2019 12 30) ; Monday, week 1 |
| 203 |
(2019 12 29) ; Sunday, week 52 |
| 204 |
|
| 205 |
(2017 1 1) ; Sunday, week 52 |
| 206 |
(2017 1 2) ; Monday, week 1 |
| 207 |
(2017 1 8) ; Sunday, week 1 |
| 208 |
(2017 1 9) ; Monday, week 2 |
| 209 |
(2016 12 31) ; Saturday, week 52 |
| 210 |
|
| 211 |
(2015 1 1) ; Thursday, week 1 |
| 212 |
(2015 1 2) ; Friday, week 1 |
| 213 |
(2015 1 3) ; Saturday, week 1 |
| 214 |
(2015 1 4) ; Sunday, week 1 |
| 215 |
(2015 1 5) ; Monday, week 2 |
| 216 |
(2014 12 31) ; Wednesday, week 1 |
| 217 |
(2014 12 30) ; Tuesday, week 1 |
| 218 |
(2014 12 29) ; Monday, week 1 |
| 219 |
(2014 12 28) ; Sunday, week 52 |
| 220 |
))) |
| 221 |
(dolist [date dates] |
| 222 |
(let1 d (make-date 0 0 0 0 (caddr date) (cadr date) (car date) 0) |
| 223 |
(test* (apply format "~d/~2,'0d/~2,'0d" date) |
| 224 |
(sys-strftime "%V" (sys-gmtime (date->time-utc d))) |
| 225 |
(date->string d "~V"))))) |
| 226 |
]) ; cond-expand |
| 227 |
|
| 228 |
;; object-compare for dates. |
| 229 |
(let ((d1 (make-date 0 0 0 0 1 1 2022 0)) |
| 230 |
(d2 (make-date 0 0 0 0 2 1 2022 0)) |
| 231 |
(d3 (make-date 0 0 0 0 2 1 2022 -36000))) |
| 232 |
(define data |
| 233 |
`([,d1 ,d2 -1] |
| 234 |
[,d2 ,d2 0] |
| 235 |
[,d2 ,d1 1] |
| 236 |
[,d1 ,d3 -1] |
| 237 |
[,d2 ,d3 -1])) |
| 238 |
(dolist [dd data] |
| 239 |
(test* #"comparing dates ~(car dd) ~(cadr dd)" (caddr dd) |
| 240 |
(compare (car dd) (cadr dd)))) |
| 241 |
) |
| 242 |
) |
| 243 |
|
| 244 |
(test-end) |