79d2cb392d
* `startOfDay(TimeInfo): TimeInfo` returns a new `TimeInfo` representing midnight at the beginning of the given day. * `startOfWeek(TimeInfo, WeekDay): TimeInfo` returns a new `TimeInfo` representing midnight at the beginning of the first day of the week. By default Monday is used as the start of the week (to be consistent with `times` view of the day order), but the user can pass in any other day to "start" the week. Because this find the start of the *current* week, the returned `TimeInfo` will always be a date in the past or present, never a date in the future.
127 lines
4.1 KiB
Nim
127 lines
4.1 KiB
Nim
import times, timeutils, unittest
|
|
|
|
let dtFormat = "yyyy-MM-dd HH:mm:ss"
|
|
|
|
suite "timeutils":
|
|
test "format TimeInterval":
|
|
let interval = seconds(70)
|
|
check:
|
|
interval.format("ss's'") == "10s"
|
|
interval.format("mm'm' ss's'") == "01m 10s"
|
|
interval.format("mm:ss") == "01:10"
|
|
|
|
test "TimeInfo difference":
|
|
var t1 = getLocalTime(getTime())
|
|
var t2 = t1 + 30.seconds
|
|
check t2 - t1 == 30.seconds
|
|
|
|
t1 = parse("2016-10-10 09:45:00", "yyyy-MM-dd HH:mm:ss")
|
|
t2 = parse("2016-10-11 09:45:00", "yyyy-MM-dd HH:mm:ss")
|
|
check t2 - t1 == 1.days
|
|
|
|
t2 = parse("2016-10-11 10:00:00", "yyyy-MM-dd HH:mm:ss")
|
|
check t2 - t1 == (1.days + 15.minutes)
|
|
|
|
test "TimeInfo comparisons":
|
|
let t1 = getLocalTime(getTime())
|
|
|
|
check:
|
|
t1 < t1 + 10.seconds
|
|
not (t1 + 10.seconds < t1)
|
|
not (t1 > t1)
|
|
|
|
t1 + 10.seconds > t1
|
|
not (t1 > t1 + 10.seconds)
|
|
not (t1 < t1)
|
|
|
|
t1 + 10.seconds >= t1
|
|
t1 >= t1
|
|
not (t1 >= t1 + 10.seconds)
|
|
|
|
t1 <= t1 + 10.seconds
|
|
t1 <= t1
|
|
not (t1 + 10.seconds <= t1)
|
|
|
|
test "TimeInterval comparisons":
|
|
check:
|
|
30.seconds > 10.seconds
|
|
not (10.seconds > 30.seconds)
|
|
not (10.seconds > 10.seconds)
|
|
|
|
10.minutes < 1.hours
|
|
not (1.hours < 10.minutes)
|
|
not (1.hours < 1.hours)
|
|
|
|
60.seconds >= 1.minutes
|
|
60.seconds >= 1.minutes
|
|
not (60.seconds >= 2.minutes)
|
|
|
|
60.seconds <= 1.minutes
|
|
60.seconds <= 2.minutes
|
|
not (2.minutes <= 60.seconds)
|
|
|
|
test "TimeInfo cmp":
|
|
let t1 = getLocalTime(getTime())
|
|
|
|
check cmp(t1, t1) == 0
|
|
check cmp(t1, t1 + 10.seconds) == -1
|
|
check cmp(t1 + 10.seconds, t1) == 1
|
|
|
|
test "startOfDay":
|
|
let t1 = fixedParse("13:42:19", "HH:mm:ss")
|
|
let t2 = fixedParse("2015-12-31 23:59:59", dtFormat)
|
|
|
|
check:
|
|
fixedParse("00:00:00", "HH:mm:ss") == startOfDay(t1)
|
|
|
|
#check fixedParse("2015-12-31 00:00:00", dtFormat) == startOfDay(t2)
|
|
|
|
startOfDay(startOfDay(t1)) == startOfDay(t1)
|
|
|
|
test "startOfWeek":
|
|
let t1 = fixedParse("2015-12-31 23:59:59", dtFormat)
|
|
let t2 = fixedParse("2015-12-26 23:59:59", dtFormat)
|
|
let t3 = fixedParse("2016-01-01 23:59:59", dtFormat)
|
|
|
|
# Not parsing the start of the day in order to work around the bug
|
|
# mentioned above.
|
|
check:
|
|
# Start of week = Monday
|
|
startOfWeek(t1) == startOfDay(getLocalTime(toTime(fixedParse("2015-12-28 12:01:00", dtFormat))))
|
|
startOfWeek(t1).weekday == dMon
|
|
startOfWeek(startOfWeek(t1)) == startOfWeek(t1)
|
|
|
|
startOfWeek(t2) == startOfDay(fixedParse("2015-12-21 01:00:00", dtFormat))
|
|
startOfWeek(t3) == startOfDay(fixedParse("2015-12-28 01:00:00", dtFormat))
|
|
|
|
# Start of week = Sunday
|
|
startOfWeek(t1, dSun) == startOfDay(fixedParse("2015-12-27 01:00:00", dtFormat))
|
|
startOfWeek(t1, dSun).weekday == dSun
|
|
startOfWeek(startOfWeek(t1, dSun), dSun) == startOfWeek(t1, dSun)
|
|
|
|
startOfWeek(t2, dSun) == startOfDay(fixedParse("2015-12-20 01:00:00", dtFormat))
|
|
startOfWeek(t3, dSun) == startOfDay(fixedParse("2015-12-27 01:00:00", dtFormat))
|
|
|
|
test "times.parse is still broken":
|
|
let t1 = parse("2015-12-01 12:00:00", dtFormat)
|
|
let t2 = parse("2015-06-01 12:00:00", dtFormat)
|
|
|
|
# parse is broken in that is uses the DST setting of the current time when
|
|
# parsing dates when it should figure out the DST time for that date. So
|
|
# depending on if you are currently in DST or not, one of the above dates
|
|
# will not parse correctly. We want to check that one of those fails to
|
|
# parse correctly. When they both parse correctly, the times.parse bug has
|
|
# been fixed and fixedParse is no longer necessary.
|
|
|
|
# This test works because passing the time through getLocalTime(toTime())
|
|
# correctly the DST setting for the time.
|
|
check t1 != getLocalTime(toTime(t1)) or t2 != getLocalTime(toTime(t2))
|
|
|
|
test "fixedParse":
|
|
let t1 = fixedParse("2015-12-01 12:00:00", dtFormat)
|
|
let t2 = fixedParse("2015-06-01 12:00:00", dtFormat)
|
|
|
|
check: # test both in DST and out of DST
|
|
t1 == getLocalTime(toTime(t1))
|
|
t2 == getLocalTime(toTime(t2))
|