date-tests.rkt

#lang rosette

(require "dates.rkt")

(define (test-leap)
  (let ((d (new-date)))
    (set-field d "years" 2000)
    (assert (is-leap d)))
  (let ((d (new-date)))
    (set-field d "years" 2010)
    (assert (not (is-leap d))))
  (let ((d (new-date)))
    (set-field d "years" 1900)
    (assert (not (is-leap d))))
  (let ((d (new-date)))
    (set-field d "years" 2003)
    (assert (not (is-leap d))))
  (let ((d (new-date)))
    (set-field d "years" 2016)
    (assert (is-leap d))))
  
(define (test-add-seconds)
  ; test roll over to new day, leap year
  (let ((d (create-date 59 59 23 28 2 2000)))
    (add-seconds d 10)
    (println d)
    (assert (= 9 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 0 (get-field d "hours")))
    (assert (= 29 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 2000 (get-field d "years"))))

  (let ((d (create-date 59 59 23 28 2 2001)))
    ; test roll over to new day, non-leap year
    (add-seconds d 10)
    (println d)
    (assert (= 9 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 0 (get-field d "hours")))
    (assert (= 1 (get-field d "days")))
    (assert (= 3 (get-field d "months")))
    (assert (= 2001 (get-field d "years"))))

  (let ((d (create-date 59 59 23 31 1 2001)))
    ; test roll over to new day of a new month
    (add-seconds d 10)
    (println d)
    (assert (= 9 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 0 (get-field d "hours")))
    (assert (= 1 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 2001 (get-field d "years")))
  )

  (let ((d (create-date 59 59 23 31 12 2001)))
    ; test roll over to a new year
    (add-seconds d 10)
    (println d)
    (assert (= 9 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 0 (get-field d "hours")))
    (assert (= 1 (get-field d "days")))
    (assert (= 1 (get-field d "months")))
    (assert (= 2002 (get-field d "years")))))

(define (test-subtract-seconds)
  ; test roll back to a difft day, difft year
  (let ((d (create-date 0 0 0 1 1 2000)))
    (subtract-seconds d 10)
    (println d)
    (assert (= 50 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 12 (get-field d "months")))
    (assert (= 1999 (get-field d "years"))))

  (let ((d (create-date 10 0 0 1 3 2000)))
    ; test roll back a day, leap year
    (subtract-seconds d 20)
    (println d)
    (assert (= 50 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 29 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 2000 (get-field d "years"))))

  (let ((d (create-date 10 0 0 1 3 1900)))
  ; test roll back a day, non-leap year
    (subtract-seconds d 20)
    (println d)
    (assert (= 50 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 28 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 1900 (get-field d "years"))))

  (let ((d (create-date 50 0 0 1 3 2017)))
    ; test no carry over at all
    (subtract-seconds d 20)
    (println d)
    (assert (= 30 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 0 (get-field d "hours")))
    (assert (= 1 (get-field d "days")))
    (assert (= 3 (get-field d "months")))
    (assert (= 2017 (get-field d "years"))))
  
  (let ((d (create-date 40 0 0 1 3 2001)))
    ; test roll back a day, non-leap year
    (subtract-seconds d 50)
    (println d)
    (assert (= 50 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 28 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 2001 (get-field d "years")))))

(define (test-add-minutes)
  (let ((d (create-date 59 59 23 28 2 2000)))
   ; test roll over to new day, leap year
  (add-minutes d 20)
  (println d)
  (assert (= 59 (get-field d "seconds")))
  (assert (= 19 (get-field d "minutes")))
  (assert (= 0 (get-field d "hours")))
  (assert (= 29 (get-field d "days")))
  (assert (= 2 (get-field d "months")))
  (assert (= 2000 (get-field d "years"))))

  (let ((d (create-date 59 59 23 28 2 2001)))
  ; test roll over to new month, non-leap year
  (add-minutes d 20)
  (println d)
  (assert (= 59 (get-field d "seconds")))
  (assert (= 19 (get-field d "minutes")))
  (assert (= 0 (get-field d "hours")))
  (assert (= 1 (get-field d "days")))
  (assert (= 3 (get-field d "months")))
  (assert (= 2001 (get-field d "years")))
  )

  (let ((d (create-date 59 59 23 31 12 2001)))
  ; test roll over to new year
  (add-minutes d 20)
  (println d)
  (assert (= 59 (get-field d "seconds")))
  (assert (= 19 (get-field d "minutes")))
  (assert (= 0 (get-field d "hours")))
  (assert (= 1 (get-field d "days")))
  (assert (= 1 (get-field d "months")))
  (assert (= 2002 (get-field d "years")))
  )
)

(define (test-subtract-minutes)
  (let ((d (create-date 59 0 0 1 1 2000)))
    ; roll back a day
    (subtract-minutes d 20)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 40 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 12 (get-field d "months")))
    (assert (= 1999 (get-field d "years")))
    )

  (let ((d (create-date 59 10 0 1 1 2000)))
    ; roll back a day, but subtract some subset
    (subtract-minutes d 20)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 50 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 12 (get-field d "months")))
    (assert (= 1999 (get-field d "years")))
    )

    (let ((d (create-date 59 0 0 1 1 2000)))
      ; roll back a day, but subtract some subset
      (subtract-minutes d 59)
      (println d)
      (assert (= 59 (get-field d "seconds")))
      (assert (= 1 (get-field d "minutes")))
      (assert (= 23 (get-field d "hours")))
      (assert (= 31 (get-field d "days")))
      (assert (= 12 (get-field d "months")))
      (assert (= 1999 (get-field d "years")))
      )
  )

(define (test-add-hours)
  (let ((d (create-date 59 59 23 28 2 2000)))
   ; test roll over to new day, leap year
  (add-hours d 23)
  (println d)
  (assert (= 59 (get-field d "seconds")))
  (assert (= 59 (get-field d "minutes")))
  (assert (= 22 (get-field d "hours")))
  (assert (= 29 (get-field d "days")))
  (assert (= 2 (get-field d "months")))
  (assert (= 2000 (get-field d "years")))
  )

  ; test roll over to new day, non leap year
  (let ((d (create-date 59 59 23 28 2 2001)))
  (add-hours d 23)
  (println d)
  (assert (= 59 (get-field d "seconds")))
  (assert (= 59 (get-field d "minutes")))
  (assert (= 22 (get-field d "hours")))
  (assert (= 1 (get-field d "days")))
  (assert (= 3 (get-field d "months")))
  (assert (= 2001 (get-field d "years")))
  )

  (let ((d (create-date 59 59 23 31 12 2001)))
  ; test roll over to new year
  (add-hours d 23)
  (println d)
  (assert (= 59 (get-field d "seconds")))
  (assert (= 59 (get-field d "minutes")))
  (assert (= 22 (get-field d "hours")))
  (assert (= 1 (get-field d "days")))
  (assert (= 1 (get-field d "months")))
  (assert (= 2002 (get-field d "years")))
  )
)

(define (test-subtract-hours)
  (let ((d (create-date 59 0 15 1 1 2000)))
    ; roll back a day
    (subtract-hours d 23)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 16 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 12 (get-field d "months")))
    (assert (= 1999 (get-field d "years")))
    )
  )

(define (test-add-days)
  (let ((d (create-date 59 59 23 31 1 2001)))
     ; test roll over to new month, non leap year
    (add-days d 28)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 28 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 2001 (get-field d "years")))
    )

   (let ((d (create-date 59 59 23 15 2 2001)))
     ; test roll over to new month, non leap year
    (add-days d 20)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 7 (get-field d "days")))
    (assert (= 3 (get-field d "months")))
    (assert (= 2001 (get-field d "years")))
    )

     (let ((d (create-date 59 59 23 15 2 2000)))
     ; test roll over to new month, leap year
    (add-days d 20)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 6 (get-field d "days")))
    (assert (= 3 (get-field d "months")))
    (assert (= 2000 (get-field d "years")))
    )

    (let ((d (create-date 59 59 23 15 12 2000)))
     ; test roll over to year
    (add-days d 20)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 4 (get-field d "days")))
    (assert (= 1 (get-field d "months")))
    (assert (= 2001 (get-field d "years")))
    )
)

(define (test-subtract-days)
  (let ((d (create-date 59 0 15 1 1 2000)))
    ; roll back 28 days
    (subtract-days d 28)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 15 (get-field d "hours")))
    (assert (= 04 (get-field d "days")))
    (assert (= 12 (get-field d "months")))
    (assert (= 1999 (get-field d "years")))
    )

  (let ((d (create-date 59 0 15 3 3 2000)))
    ; roll back 28 days, leap year
    (subtract-days d 28)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 15 (get-field d "hours")))
    (assert (= 04 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 2000 (get-field d "years"))))
  
  (let ((d (create-date 59 0 15 3 3 1900)))
    ; roll back 28 days, non-leap year
    (subtract-days d 28)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 0 (get-field d "minutes")))
    (assert (= 15 (get-field d "hours")))
    (assert (= 03 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 1900 (get-field d "years")))))

(define (test-add-months)
    (let ((d (create-date 59 59 23 31 1 2001)))
     ; test roll add 1 month to invalid days
    (add-months d 1)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 28 (get-field d "days")))
    (assert (= 2 (get-field d "months")))
    (assert (= 2001 (get-field d "years"))))

    (let ((d (create-date 59 59 23 31 1 1964)))
      ; test roll add 1 month to invalid days
      (add-months d 1)
      (println d)
      (assert (= 59 (get-field d "seconds")))
      (assert (= 59 (get-field d "minutes")))
      (assert (= 23 (get-field d "hours")))
      (assert (= 29 (get-field d "days")))
      (assert (= 2 (get-field d "months")))
      (assert (= 1964 (get-field d "years"))))

  (let ((d (create-date 59 59 23 31 3 2001)))
    ; test roll add 1 month to invalid days
    (add-months d 1)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 30 (get-field d "days")))
    (assert (= 4 (get-field d "months")))
    (assert (= 2001 (get-field d "years"))))

  (let ((d (create-date 59 59 23 31 7 2001)))
    ; test roll add 1 month to valid days
    (add-months d 1)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 8 (get-field d "months")))
    (assert (= 2001 (get-field d "years"))))

  (let ((d (create-date 59 59 23 31 12 2001)))
    ; test roll add 1 month to change year
    (add-months d 1)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 1 (get-field d "months")))
    (assert (= 2002 (get-field d "years")))))


(define (test-subtract-months)
    (let ((d (create-date 59 59 23 31 3 2001)))
      ; test roll back 1 month to invalid days
      (subtract-months d 1)
      (println d)
      (assert (= 59 (get-field d "seconds")))
      (assert (= 59 (get-field d "minutes")))
      (assert (= 23 (get-field d "hours")))
      (assert (= 28 (get-field d "days")))
      (assert (= 2 (get-field d "months")))
      (assert (= 2001 (get-field d "years")))
      )
  
  (let ((d (create-date 59 59 23 31 3 2001)))
      ; test roll back 11 month to invalid day
      (subtract-months d 11)
      (println d)
      (assert (= 59 (get-field d "seconds")))
      (assert (= 59 (get-field d "minutes")))
      (assert (= 23 (get-field d "hours")))
      (assert (= 30 (get-field d "days")))
      (assert (= 4 (get-field d "months")))
      (assert (= 2000 (get-field d "years")))
      )
  
   (let ((d (create-date 59 59 23 31 3 2000)))
      ; test roll back 1 month to invalid day, leap year
      (subtract-months d 1)
      (println d)
      (assert (= 59 (get-field d "seconds")))
      (assert (= 59 (get-field d "minutes")))
      (assert (= 23 (get-field d "hours")))
      (assert (= 29 (get-field d "days")))
      (assert (= 2 (get-field d "months")))
      (assert (= 2000 (get-field d "years")))
      )
)

(define (test-add-years)
    (let ((d (create-date 59 59 23 31 1 2001)))
    (add-years d 99)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 1 (get-field d "months")))
    (assert (= 2100 (get-field d "years")))
    )
)

(define (test-subtract-years)
    (let ((d (create-date 59 59 23 31 1 2001)))
    (subtract-years d 99)
    (println d)
    (assert (= 59 (get-field d "seconds")))
    (assert (= 59 (get-field d "minutes")))
    (assert (= 23 (get-field d "hours")))
    (assert (= 31 (get-field d "days")))
    (assert (= 1 (get-field d "months")))
    (assert (= 1902 (get-field d "years")))
    )
)

(define (test-doy)
    (let ((d (create-date 59 59 23 3 4 2017)))
      (assert (= 93 (extract-day-of-year d))))
   (let ((d (create-date 59 59 23 3 1 2017)))
      (assert (= 3 (extract-day-of-year d))))
    (let ((d (create-date 59 59 23 15 5 1964)))
      (assert (= 136 (extract-day-of-year d))))
    (let ((d (create-date 59 59 23 15 5 1998)))
      (assert (= 135 (extract-day-of-year d))))
    (let ((d (create-date 59 59 23 30 8 1998)))
      (assert (= 242 (extract-day-of-year d))))
    (let ((d (create-date 59 59 23 31 8 1998)))
      (assert (= 243 (extract-day-of-year d))))
    (let ((d (create-date 59 59 23 1 9 1998)))
      (assert (= 244 (extract-day-of-year d))))
    (let ((d (create-date 59 59 23 30 9 1998)))
      (assert (= 273 (extract-day-of-year d))))
    (let ((d (create-date 59 59 23 30 9 2000)))
      (assert (= 274 (extract-day-of-year d))))
     (let ((d (create-date 59 59 23 31 12 2000)))
      (assert (= 366 (extract-day-of-year d))))
     (let ((d (create-date 59 59 23 31 12 2001)))
      (assert (= 365 (extract-day-of-year d))))
)

(define (test-epoch)
    (let ((d (create-date 28 26 18 4 10 2017)))
      (assert (= 1507141588 (extract-epoch d))))
    (let ((d (create-date 0 0 0 1 1 1970)))
      (assert (= 0 (extract-epoch d))))
    (let ((d (create-date 0 0 0 1 1 1969)))
      (assert (= -31536000 (extract-epoch d))))
    (let ((d (create-date 0 0 0 1 1 1968)))
      (assert (= -63158400 (extract-epoch d))))
    (let ((d (create-date 0 0 0 1 1 1964)))
      (assert (= -189388800 (extract-epoch d))))
    (let ((d (create-date 0 0 0 1 1 1912)))
      (assert (= -1830384000 (extract-epoch d))))
)

(define (test-date-creation)
  (let ((d (extract-date-from-epoch 1491492440)))
      (assert (= 20 (get-field d "seconds")))
      (assert (= 27 (get-field d "minutes")))
      (assert (= 15 (get-field d "hours")))
      (assert (= 6 (get-field d "days")))
      (assert (= 4 (get-field d "months")))
      (assert (= 2017 (get-field d "years")))
    )
    (let ((d (extract-date-from-epoch 912467738)))
      (assert (= 38 (get-field d "seconds")))
      (assert (= 15 (get-field d "minutes")))
      (assert (= 23 (get-field d "hours")))
      (assert (= 30 (get-field d "days")))
      (assert (= 11 (get-field d "months")))
      (assert (= 1998 (get-field d "years")))
    )
     (let ((d (extract-date-from-epoch -29029718)))
      (assert (= 22 (get-field d "seconds")))
      (assert (= 11 (get-field d "minutes")))
      (assert (= 0 (get-field d "hours")))
      (assert (= 30 (get-field d "days")))
      (assert (= 1 (get-field d "months")))
      (assert (= 1969 (get-field d "years")))
    )
    (let ((d (extract-date-from-epoch -1821303575)))
      (assert (= 25 (get-field d "seconds")))
      (assert (= 20 (get-field d "minutes")))
      (assert (= 2 (get-field d "hours")))
      (assert (= 15 (get-field d "days")))
      (assert (= 4 (get-field d "months")))
      (assert (= 1912(get-field d "years")))
    )
)


(define (test-dow)
    (let ((d (create-date 59 59 23 3 4 2017)))
      (assert (= 1 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 1 4 2017)))
     (assert (= 6 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 2 4 2017)))
     (assert (= 0 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 15 5 1964)))
      (assert (= 5 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 15 5 1998)))
      (assert (= 5 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 30 8 1998)))
      (assert (= 0 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 31 8 1998)))
      (assert (= 1 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 1 9 1998)))
      (assert (= 2 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 30 9 1998)))
      (assert (= 3 (extract-day-of-week d))))
    (let ((d (create-date 59 59 23 30 9 2000)))
      (assert (= 6 (extract-day-of-week d))))
     (let ((d (create-date 59 59 23 31 12 2000)))
      (assert (= 0 (extract-day-of-week d))))
     (let ((d (create-date 59 59 23 31 12 2001)))
      (assert (= 1 (extract-day-of-week d))))
  )

(define (test-date-subtract)
  (let ((d1 (create-date 59 59 23 3 4 2017))
        (d2 (create-date 59 59 23 2 4 2017)))
    (assert (= 1 (date-subtract d1 d2))))
  (let ((d1 (create-date 59 59 23 1 3 2017))
        (d2 (create-date 59 59 23 28 2 2017)))
    (assert (= 1 (date-subtract d1 d2)))))

(define (test-date-compare)
  (let ((d1 (create-date 59 59 23 3 4 2017))
        (d2 (create-date 59 59 23 2 4 2017)))
    (assert (equal? #t (date-gt d1 d2))))
  (let ((d1 (create-date 59 59 23 1 3 2017))
        (d2 (create-date 59 59 23 28 2 2017)))
    (assert (equal? #f (date-lt d1 d2)))))
  
  
(define (test-all-date-ops)
  (test-leap)
  (test-add-seconds)
  (test-subtract-seconds)
  (test-add-minutes)
  (test-subtract-minutes)
  (test-add-hours)
  (test-subtract-hours)
  (test-add-days)
  (test-subtract-days)
  (test-add-months)
  (test-subtract-months)
  (test-add-years)
  (test-subtract-years)
  (test-doy)
  (test-dow)
  (test-epoch)
  (test-date-creation)
  (test-date-subtract)
  (test-date-compare)
  )

(define-symbolic i1 integer?)
(define-symbolic i2 integer?)

(define (test-symbolic-subtract-seconds)
  (let ((d (create-date 59 59 23 28 2 2000)))
    (subtract-seconds d i1)
    (let ((m1 (solve (assert (= 20 (extract-seconds d))))))
      (println (evaluate i1 m1))
      (assert (= 39 (evaluate i1 m1))))))

(define (test-symbolic-subtract-minutes)
  (let ((d (create-date 59 59 23 28 2 2000)))
    (subtract-minutes d i1)
    (let ((m1 (solve (assert (= 20 (extract-minutes d))))))
      (println (evaluate i1 m1))
      (assert (= 39 (evaluate i1 m1))))))

(define (test-symbolic-subtract-hours)
  (let ((d (create-date 59 59 23 28 2 2000)))
    (subtract-hours d i1)
    (let ((m1 (solve (assert (= 20 (extract-hours d))))))
      (println (evaluate i1 m1))
      (assert (= 3 (evaluate i1 m1))))))

(define (test-symbolic-subtract-days)
  (let ((d (create-date 59 59 23 28 2 2000)))
    (subtract-days d i1)
    (let ((m1 (solve (assert (= 20 (extract-days d))))))
      (println (evaluate i1 m1))
      (assert (= 8 (evaluate i1 m1))))))

(define (test-symbolic-subtract-months)
  (let ((d (create-date 59 59 23 28 11 2000)))
    (subtract-months d i1)
    (let ((m1 (solve (assert (= 9 (extract-months d))))))
      (println (evaluate i1 m1))
      (assert (= 2 (evaluate i1 m1))))))

(define (test-symbolic-subtract-years)
  (let ((d (create-date 59 59 23 28 2 2000)))
    (subtract-years d i1)
    (let ((m1 (solve (assert (= 1998 (extract-years d))))))
      (println (evaluate i1 m1))
      (assert (= 2 (evaluate i1 m1))))))

(define (test-symbolic-add-seconds)
  (let ((d (create-date 10 59 23 28 2 2000)))
    (add-seconds d i1)
    (let ((m1 (solve (assert (= 20 (extract-seconds d))))))
         (println (evaluate i1 m1))
         (assert (= 10 (evaluate i1 m1))))))

(define (test-symbolic-add-minutes)
  (let ((d (create-date 10 20 23 28 2 2000)))
    (add-minutes d i1)
    (let ((m1 (solve (assert (= 40 (extract-minutes d))))))
         (println (evaluate i1 m1))
         (assert (= 20 (evaluate i1 m1))))))

(define (test-symbolic-add-hours)
  (let ((d (create-date 10 20 10 28 2 2000)))
    (add-hours d i1)
    (let ((m1 (solve (assert (= 23 (extract-hours d))))))
         (println (evaluate i1 m1))
         (assert (= 13 (evaluate i1 m1))))))

(define (test-symbolic-add-days)
  (let ((d (create-date 10 59 23 22 2 2000)))
    (add-days d i1)
    (let ((m1 (solve (assert (= 24 (extract-days d))))))
         (println (evaluate i1 m1))
         (assert (= 2 (evaluate i1 m1))))))

(define (test-symbolic-add-months)
  (let ((d (create-date 10 59 23 22 2 2000)))
    (add-months d i1)
    (let ((m1 (solve (assert (= 11 (extract-months d))))))
         (println (evaluate i1 m1))
         (assert (= 9 (evaluate i1 m1))))))

(define (test-symbolic-add-years)
  (let ((d (create-date 10 59 23 22 2 2000)))
    (add-years d i1)
    (let ((m1 (solve (assert (= 2017 (extract-years d))))))
         (println (evaluate i1 m1))
         (assert (= 17 (evaluate i1 m1))))))

(define (test-symbolic-date-diff)
  (let ((d1 (create-date 10 59 23 1 3 2000))
        (d2 (create-date 10 59 23 i1 3 2000)))
    (let ((m1 (solve (assert (= 4 (date-subtract d2 d1))))))
      (assert (= 5 (evaluate i1 m1))))))

(define (test-symbolic-date-gt)
  (let ((d1 (create-date 10 59 23 1 3 2000))
        (d2 (create-date 10 59 23 i1 3 2000)))
        (solve (assert (date-gt d2 d1)))))

(define (test-symbolic-date-lt)
  (let ((d1 (create-date 10 59 23 11 3 2000))
        (d2 (create-date 10 59 23 i1 3 2000)))
        (solve (assert (date-lt d2 d1)))))

(define (test-symbolic-date-ge)
  (let ((d1 (create-date 10 59 23 11 3 2000))
        (d2 (create-date 10 59 23 i1 3 2000)))
        (solve (assert (date-ge d2 d1)))))

(define (test-symbolic-date-le)
  (let ((d1 (create-date 10 59 23 11 3 2000))
        (d2 (create-date 10 59 23 i1 3 2000)))
        (solve (assert (date-le d2 d1)))))

(define (test-symbolic-date-eq)
  (let ((d1 (create-date 10 59 23 11 3 2000))
        (d2 (create-date 10 59 23 i1 3 2000)))
        (solve (assert (date-equal d2 d1)))))

(define (test-symbolic-extract-epoch)
  (let* ((d (create-date 10 59 23 i1 3 2000))
        (m1 (solve (assert (= 952732800 (extract-epoch d))))))
    (assert (= 11 (evaluate i1 m1)))))

(define (test-symbolic-extract-date)
   (let ((d (extract-date-from-epoch i1)))
    (solve (assert (= 952732800 (extract-epoch d))))
     (println d)))

(define (test-symbolic-doy)
  (let* ((d (create-date 59 59 i1 3 4 2017))
        (m1 (solve (assert (= 93 (extract-day-of-year d))))))
  (assert (= 23 (evaluate i1 m1)))))

(define (test-symbolic-dow)
  (let* ((d (create-date 59 59 23 i1 4 2017))
         (m1 (solve (assert (= 1 (extract-day-of-week d))))))
  (assert (= 3 (evaluate i1 m1)))))
    
(define (test-all-symbolic-ops)
  (test-symbolic-subtract-seconds)
  (test-symbolic-subtract-minutes)
  (test-symbolic-subtract-hours)
  (test-symbolic-subtract-days)
  (test-symbolic-subtract-months)
  (test-symbolic-subtract-years)
  (test-symbolic-add-seconds)
  (test-symbolic-add-minutes)
  (test-symbolic-add-hours)
  (test-symbolic-add-days)
  (test-symbolic-add-months)
  (test-symbolic-add-years)
  (test-symbolic-date-diff)
  (test-symbolic-date-gt)
  (test-symbolic-date-lt)
  (test-symbolic-date-le)
  (test-symbolic-date-ge)
  (test-symbolic-date-eq)
  (test-symbolic-extract-epoch)
  (test-symbolic-extract-date))