tests/test-time.lisp

   1 ;;; -*- Mode: Lisp -*-
   2 ;;; $Id$
   3 ;;;
   4 ;;; Copyright (c) 2000, 2001 onShore Development, Inc.
   5 ;;;
   6 ;;; Test time functions (time.lisp)
   7
   8 (in-package #:clsql-tests)
   9 #.(clsql-sys:locally-enable-sql-reader-syntax)
  10
  11 (def-view-class datetest ()
  12   ((testtimetz :COLUMN "testtimetz" :TYPE
  13                clsql-sys:wall-time :DB-KIND :BASE
  14                :DB-CONSTRAINTS COMMON-LISP:NIL
  15                :ACCESSOR testtimetz :INITARG
  16                :testtimetz :INITFORM COMMON-LISP:NIL
  17                :DB-TYPE "timestamp with time zone")
  18    (testtime :COLUMN "testtime" :TYPE
  19              clsql-sys:wall-time :DB-KIND :BASE
  20              :DB-CONSTRAINTS COMMON-LISP:NIL
  21              :ACCESSOR testtime :INITARG
  22              :testtime :INITFORM COMMON-LISP:NIL
  23              :DB-TYPE "timestamp without time zone")))
  24
  25 (def-dataset *ds-datetest*
  26   (:setup (lambda () (clsql-sys:create-view-from-class 'datetest)))
  27   (:cleanup "DROP TABLE datetest"))
  28
  29
  30 (def-dataset *cross-platform-datetest*
  31   (:setup (lambda () (create-table [datetest]
  32                                    '(([testtime] wall-time)))))
  33   (:cleanup (lambda ()
  34               (drop-table [datetest]))))
  35
  36
  37 (setq *rt-time*
  38       '(
  39
  40 ;; we use parse timestring a lot through here verifying other things
  41 ;; start off just checking that.
  42 (deftest :time/iso-parse/0
  43     (let* ((time1 (parse-timestring "2010-01-23")))
  44       (decode-time time1))
  45   0 0 0 0 23 1 2010 6)
  46
  47 (deftest :time/iso-parse/1
  48     (let* ((time1 (parse-timestring "2010-01-23T14:56:32Z")))
  49       (decode-time time1))
  50   0 32 56 14 23 1 2010 6)
  51
  52 (deftest :time/iso-parse/2
  53     (let* ((time1 (parse-timestring "2008-02-29 12:46:32")))
  54       (decode-time time1))
  55   0 32 46 12 29 2 2008 5)
  56
  57 (deftest :time/iso-parse/3
  58     (let* ((time1 (parse-timestring "2010-01-23 14:56:32.44")))
  59       (decode-time time1))
  60   440000 32 56 14 23 1 2010 6)
  61
  62 (deftest :time/iso-parse/4
  63     (let* ((time1 (parse-timestring "2010-01-23 14:56:32.0044")))
  64       (decode-time time1))
  65   4400 32 56 14 23 1 2010 6)
  66
  67 (deftest :time/iso-parse/5
  68     (let* ((time1 (parse-timestring "2010-01-23 14:56:32.000003")))
  69       (decode-time time1))
  70   3 32 56 14 23 1 2010 6)
  71
  72 (deftest :time/print-parse/1
  73     ;;make sure when we print and parse we get the same time.
  74     (let* ((time (clsql-sys:make-time :year 2010 :month 1 :day 4
  75                                       :hour 14 :minute 15 :second 44))
  76            (string-time (iso-timestring time))
  77            (time2 (parse-timestring string-time)))
  78       (decode-time time2))
  79   0 44 15 14 4 1 2010 1)
  80
  81 (deftest :time/print-parse/2
  82     ;;make sure when we print and parse we get the same time.
  83     (let* ((time (clsql-sys:make-time :year 2010 :month 1 :day 4
  84                                       :hour 14 :minute 15 :second 44 :usec 3))
  85            (string-time (iso-timestring time))
  86            (time2 (parse-timestring string-time)))
  87       (decode-time time2))
  88   3 44 15 14 4 1 2010 1)
  89
  90
  91 ;; relations of intervals
  92 (deftest :time/1
  93     (let* ((time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
  94            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
  95            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
  96            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00"))
  97            (interval-1 (clsql:make-interval :start time-1 :end time-2))
  98            (interval-2 (clsql:make-interval :start time-2 :end time-3))
  99            (interval-3 (clsql:make-interval :start time-3 :end time-4))
 100            (interval-4 (clsql:make-interval :start time-1 :end time-3))
 101            (interval-5 (clsql:make-interval :start time-2 :end time-4))
 102            (interval-6 (clsql:make-interval :start time-1 :end time-4)))
 103       (flet ((my-assert (number relation i1 i2)
 104                (declare (ignore number))
 105                (let ((found-relation (clsql:interval-relation i1 i2)))
 106                  (equal relation found-relation))))
 107         (and
 108          (my-assert 1 :contains interval-1 interval-1)
 109          (my-assert 2 :precedes interval-1 interval-2)
 110          (my-assert 3 :precedes interval-1 interval-3)
 111          (my-assert 4 :contained interval-1 interval-4)
 112          (my-assert 5 :precedes interval-1 interval-5)
 113          (my-assert 6 :contained interval-1 interval-6)
 114          (my-assert 7 :follows interval-2 interval-1)
 115          (my-assert 8 :contains interval-2 interval-2)
 116          (my-assert 9 :precedes interval-2 interval-3)
 117          (my-assert 10 :contained interval-2 interval-4)
 118          (my-assert 11 :contained interval-2 interval-5)
 119          (my-assert 12 :contained interval-2 interval-6)
 120          (my-assert 13 :follows interval-3 interval-1)
 121          (my-assert 14 :follows interval-3 interval-2)
 122          (my-assert 15 :contains interval-3 interval-3)
 123          (my-assert 16 :follows interval-3 interval-4)
 124          (my-assert 17 :contained interval-3 interval-5)
 125          (my-assert 18 :contained interval-3 interval-6)
 126          (my-assert 19 :contains interval-4 interval-1)
 127          (my-assert 20 :contains interval-4 interval-2)
 128          (my-assert 21 :precedes interval-4 interval-3)
 129          (my-assert 22 :contains interval-4 interval-4)
 130          (my-assert 23 :overlaps interval-4 interval-5)
 131          (my-assert 24 :contained interval-4 interval-6)
 132          (my-assert 25 :follows interval-5 interval-1)
 133          (my-assert 26 :contains interval-5 interval-2)
 134          (my-assert 27 :contains interval-5 interval-3)
 135          (my-assert 28 :overlaps interval-5 interval-4)
 136          (my-assert 29 :contains interval-5 interval-5)
 137          (my-assert 30 :contained interval-5 interval-6)
 138          (my-assert 31 :contains interval-6 interval-1)
 139          (my-assert 32 :contains interval-6 interval-2)
 140          (my-assert 33 :contains interval-6 interval-3)
 141          (my-assert 34 :contains interval-6 interval-4)
 142          (my-assert 35 :contains interval-6 interval-5)
 143          (my-assert 36 :contains interval-6 interval-6))))
 144   t)
 145
 146 ;; adjacent intervals in list
 147 (deftest :time/2
 148   (let* ((interval-list nil)
 149          (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 150          (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 151          (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 152     (setf interval-list
 153           (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-3
 154                                                       :type :open)))
 155     (setf interval-list
 156           (clsql:interval-push interval-list (clsql:make-interval :start time-3 :end time-4
 157                                                       :type :open)))
 158     (clsql:interval-relation (car interval-list) (cadr interval-list)))
 159   :precedes)
 160
 161 ;; nested intervals in list
 162 (deftest :time/3
 163     (let* ((interval-list nil)
 164            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 165            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 166            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 167            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 168       (setf interval-list
 169             (clsql:interval-push interval-list (clsql:make-interval :start time-1
 170                                                         :end time-4
 171                                                         :type :open)))
 172       (setf interval-list
 173             (clsql:interval-push interval-list (clsql:make-interval :start time-2
 174                                                         :end time-3
 175                                                         :type :closed)))
 176       (let* ((interval (car interval-list))
 177              (interval-contained
 178               (when interval (car (clsql:interval-contained interval)))))
 179         (when (and interval interval-contained)
 180           (and (clsql:time= (clsql:interval-start interval) time-1)
 181                (clsql:time= (clsql:interval-end interval) time-4)
 182                (eq (clsql:interval-type interval) :open)
 183                (clsql:time= (clsql:interval-start interval-contained) time-2)
 184                (clsql:time= (clsql:interval-end interval-contained) time-3)
 185                (eq (clsql:interval-type interval-contained) :closed)))))
 186   t)
 187
 188 ;; interval-edit - nonoverlapping
 189 (deftest :time/4
 190     (let* ((interval-list nil)
 191            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 192            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 193            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 194            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 195       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-2 :type :open)))
 196       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-3 :end time-4 :type :closed)))
 197       (setf interval-list (clsql:interval-edit interval-list time-1 time-1 time-3))
 198       ;; should be time-3 not time-2
 199       (clsql:time= (clsql:interval-end (car interval-list)) time-3))
 200   t)
 201
 202 ;; interval-edit - overlapping
 203 (deftest :time/5
 204     (let* ((interval-list nil)
 205            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 206            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 207            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 208            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 209       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-2 :type :open)))
 210       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-2 :end time-4 :type :closed)))
 211       (let ((pass t))
 212         (handler-case
 213             (progn
 214               (setf interval-list
 215                     (clsql:interval-edit interval-list time-1 time-1 time-3))
 216               (setf pass nil))
 217           (error nil))
 218         pass))
 219   t)
 220
 221 ;; interval-edit - nested intervals in list
 222 (deftest :time/6
 223     (let* ((interval-list nil)
 224            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 225            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 226            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 227            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00"))
 228            (time-5 (clsql:parse-timestring "2002-01-01 14:00:00"))
 229            (time-6 (clsql:parse-timestring "2002-01-01 15:00:00")))
 230       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-6 :type :open)))
 231       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-2 :end time-3 :type :closed)))
 232       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-4 :end time-5 :type :closed)))
 233       (setf interval-list (clsql:interval-edit interval-list time-1 time-1 time-4))
 234       ;; should be time-4 not time-6
 235       (clsql:time= (clsql:interval-end (car interval-list)) time-4))
 236   t)
 237
 238 ;; Test the boundaries of Local Time with granularity of 1 year
 239 (deftest :time/7
 240     (let ((sec-in-year (* 60 60 24 365))
 241           (year (clsql:time-element (clsql:make-time) :year)))
 242       (dotimes (n 50 n)
 243         (let ((date (clsql:make-time :second (* n sec-in-year))))
 244           (unless (= (+ year n)
 245                      (clsql:time-element date :year))
 246             (return n)))))
 247   50)
 248
 249 ;; Test db-timestring
 250 (deftest :time/9
 251     (flet ((grab-year (dbstring)
 252              (parse-integer (subseq dbstring 1 5))))
 253       (let ((second-in-year (* 60 60 24 365)))
 254         (dotimes (n 2000 n)
 255           (let* ((second (* -1 n second-in-year))
 256                  (date (clsql:make-time :year 2525 :second second)))
 257             (unless
 258                 (= (grab-year (clsql:db-timestring date))
 259                    (clsql:time-element date :year))
 260               (return n))))))
 261   2000)
 262
 263 ;; Conversion between MJD and Gregorian
 264 (deftest :time/10
 265     (dotimes (base 10000 base)
 266       (unless (= (apply #'clsql:gregorian-to-mjd (clsql:mjd-to-gregorian base))
 267                  base)
 268         (return base)))
 269   10000)
 270
 271 ;; Clsql:Roll by minutes: +90
 272 (deftest :time/11
 273     (let ((now (clsql:get-time)))
 274       (clsql:time= (clsql:time+ now (clsql:make-duration :minute 90))
 275              (clsql:roll now :minute 90)))
 276   t)
 277
 278 ;;Clsql:Roll by minutes: +900
 279 (deftest :time/12
 280     (let ((now (clsql:get-time)))
 281       (clsql:time= (clsql:time+ now (clsql:make-duration :minute 900))
 282              (clsql:roll now :minute 900)))
 283   t)
 284
 285
 286 ;; Clsql:Roll by minutes: +900
 287 (deftest :time/13
 288     (let* ((now (clsql:get-time))
 289            (add-time (clsql:time+ now (clsql:make-duration :minute 9000)))
 290            (roll-time (clsql:roll now :minute 9000)))
 291       (clsql:time= add-time roll-time))
 292   t)
 293
 294
 295
 296 ;;; The cross platform dataset uses the 'timestamp' column type which is
 297 ;;; in sql-92, for all that means.
 298
 299 (deftest :time/cross-platform/no-usec/no-tz
 300     (with-dataset *cross-platform-datetest*
 301       (let ((time (parse-timestring "2008-09-09T14:37:29")))
 302         (clsql-sys:insert-records :into [datetest]
 303                                   :attributes '([testtime])
 304                                   :values (list time))
 305         (let ((testtime
 306                (first (clsql:select [testtime]
 307                                     :from [datetest] :flatp T
 308                                     :where [= [testtime] time] ))))
 309           (format-time nil (parse-timestring testtime) :format :iso)
 310           )))
 311   #.(format-time nil (parse-timestring "2008-09-09T14:37:29") :format :iso))
 312
 313 (deftest :time/cross-platform/no-usec/tz
 314     (with-dataset *cross-platform-datetest*
 315       (let ((time (parse-timestring "2008-09-09T14:37:29-04:00")))
 316         (clsql-sys:insert-records :into [datetest]
 317                                   :attributes '([testtime])
 318                                   :values (list time))
 319         (let ((testtime
 320                (first (clsql:select [testtime]
 321                                     :from [datetest] :flatp T
 322                                     :where [= [testtime] time] ))))
 323           (format-time nil (parse-timestring testtime) :format :iso)
 324           )))
 325   #.(format-time nil (parse-timestring "2008-09-09T14:37:29-04:00") :format :iso))
 326
 327 (deftest :time/cross-platform/usec/no-tz
 328     (with-dataset *cross-platform-datetest*
 329       (let ((time (parse-timestring "2008-09-09T14:37:29.000213")))
 330         (clsql-sys:insert-records :into [datetest]
 331                                   :attributes '([testtime])
 332                                   :values (list time))
 333         (let ((testtime
 334                (first (clsql:select [testtime]
 335                                     :from [datetest] :flatp T
 336                                     :where [= [testtime] time] ))))
 337           (format-time nil (parse-timestring testtime) :format :iso)
 338           )))
 339   #.(format-time nil (parse-timestring "2008-09-09T14:37:29.000213") :format :iso))
 340
 341 (deftest :time/cross-platform/usec/tz
 342     (with-dataset *cross-platform-datetest*
 343       (let ((time (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
 344         (clsql-sys:insert-records :into [datetest]
 345                                   :attributes '([testtime])
 346                                   :values (list time))
 347         (let ((testtime
 348                (first (clsql:select [testtime]
 349                                     :from [datetest]
 350                                     :limit 1 :flatp T
 351                                     :where [= [testtime] time] ))))
 352           (format-time nil (parse-timestring testtime) :format :iso)
 353           )))
 354   #.(format-time nil (parse-timestring "2008-09-09T14:37:29.000213-04:00") :format :iso))
 355
 356
 357
 358
 359 ;;; All odbc databases use local times exclusively (they do not send timezone info)
 360 ;;; Postgresql can use timezones, except when being used over odbc.  This test when
 361 ;;; run through both postgres socket and postgres odbc should test a fairly
 362 ;;; broad swath of available problem space
 363 ;;;
 364 ;;; Things the following tests try to prove correct
 365 ;;;  * Reading and writing usec and usec-less times
 366 ;;;  * reading and writing timezones (Z=utc) when appropriate (eg: postgresql-socket)
 367 ;;;  * reading and writing localtimes when appropriate (eg: ODBC)
 368 ;;;  * reading and writing through both the oodml and fdml layers
 369
 370
 371
 372 (deftest :time/pg/fdml/usec
 373   (with-dataset *ds-datetest*
 374     (let ((time (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
 375       (clsql-sys:insert-records :into [datetest]
 376                                 :attributes '([testtimetz] [testtime])
 377                                 :values (list time time))
 378       (destructuring-bind (testtimetz testtime)
 379           (first (clsql:select [testtimetz] [testtime]
 380                                :from [datetest]
 381                                :limit 1 :flatp T
 382                                :where [= [testtime] time] ))
 383         (values (iso-timestring (parse-timestring testtime))
 384                 (iso-timestring (parse-timestring testtimetz))))))
 385   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000213-04:00"))
 386   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
 387
 388 (deftest :time/pg/oodml/no-usec
 389   (with-dataset *ds-datetest*
 390     (let ((time (parse-timestring "2008-09-09T14:37:29-04:00")))
 391       (clsql-sys:update-records-from-instance
 392        (make-instance 'datetest :testtimetz time :testtime time))
 393       (let ((o (first (clsql:select
 394                           'datetest
 395                         :limit 1 :flatp T
 396                         :where [= [testtime] time] ))))
 397         (assert o (o) "o shouldnt be null here (we should have just inserted)")
 398         (update-records-from-instance o)
 399         (update-instance-from-records o)
 400         (values (iso-timestring (testtime o))
 401                 (iso-timestring (testtimetz o))))))
 402   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29-04:00"))
 403   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29-04:00")))
 404
 405 (deftest :time/pg/oodml/usec
 406     (with-dataset *ds-datetest*
 407       (let ((time (parse-timestring "2008-09-09T14:37:29.000278-04:00")))
 408         (clsql-sys:update-records-from-instance
 409          (make-instance 'datetest :testtimetz time :testtime time))
 410         (let ((o (first (clsql:select
 411                          'datetest
 412                          :limit 1 :flatp T
 413                          :where [= [testtime] time] ))))
 414           (assert o (o) "o shouldnt be null here (we should have just inserted)")
 415           (update-records-from-instance o)
 416           (update-instance-from-records o)
 417           (values (iso-timestring (testtime o))
 418                   (iso-timestring (testtimetz o)))
 419           )))
 420     #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000278-04:00"))
 421     #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000278-04:00")))
 422
 423 ))
 424
 425
 426 #.(clsql-sys:locally-disable-sql-reader-syntax)