specify posix.time: - before: tm = require "posix.time" now = tm.time () - describe clock_getres: - before: clock_getres = tm.clock_getres - context with bad arguments: if clock_getres then badargs.diagnose (clock_getres, "(int)") end - it returns a PosixTimespec: if clock_getres then expect (prototype (clock_getres (tm.CLOCK_REALTIME))). to_be "PosixTimespec" end - describe clock_gettime: - before: clock_gettime = tm.clock_gettime - context with bad arguments: if clock_gettime then badargs.diagnose (clock_gettime, "(int)") end - it returns a PosixTimespec: if clock_getres then expect (prototype (clock_gettime (tm.CLOCK_REALTIME))). to_be "PosixTimespec" end - describe gmtime: - before: gmtime = tm.gmtime - context with bad arguments: badargs.diagnose (gmtime, "(int)") - it returns a PosixTm: expect (prototype (gmtime (now))).to_be "PosixTm" - it fetches broken-down time values: t = gmtime (now) fields = {"tm_sec", "tm_min", "tm_hour", "tm_mday", "tm_mon", "tm_year", "tm_wday", "tm_yday", "tm_isdst"} expect (t).to_contain.a_permutation_of (fields) for _, field in pairs (fields) do expect (type (t[field])).to_be "number" expect (t[field] >= 0).to_be (true) end - it returns a month in the range 0-11: # A recent December afternoon in epoch seconds... expect (gmtime (1418734089).tm_mon).to_be (11) t = gmtime (now) expect (t.tm_mon >= 0 and t.tm_mon < 12).to_be (true) - it returns years since 1900: expect (gmtime (now).tm_year < 1900).to_be (true) - describe localtime: - before: localtime = tm.localtime - context with bad arguments: badargs.diagnose (localtime, "(int)") - it returns a PosixTm: expect (prototype (localtime (now))).to_be "PosixTm" - it fetches broken-down time values: t = localtime (now) fields = {"tm_sec", "tm_min", "tm_hour", "tm_mday", "tm_mon", "tm_year", "tm_wday", "tm_yday", "tm_isdst"} expect (t).to_contain.a_permutation_of (fields) for _, field in pairs (fields) do expect (type (t[field])).to_be "number" expect (t[field] >= 0).to_be (true) end - it returns a month in the range 0-11: # A recent December afternoon in epoch seconds... expect (localtime (1418734089).tm_mon).to_be (11) t = localtime (now) expect (t.tm_mon >= 0 and t.tm_mon < 12).to_be (true) - it returns years since 1900: expect (localtime (now).tm_year < 1900).to_be (true) - describe mktime: - before: localtime, mktime, time = tm.localtime, tm.mktime, tm.time epoch = time () t = localtime (epoch) - context with bad arguments: badargs.diagnose (mktime, "(table)") - it returns an epoch time: expect (prototype (mktime (t))).to_be "number" - it is the inverse of localtime: expect (mktime (t)).to_be (epoch) - describe nanosleep: - before: nanosleep, typeerrors = init (tm, "nanosleep") - context with bad arguments: | badargs.diagnose (nanosleep, "(table)") examples { ["context diagnosing timespec table fields"] = { { ["it diagnoses argument #1 tv_sec field type not int"] = function () expect (nanosleep {tv_sec = false}). to_raise.any_of (typeerrors (1, "int", "tv_sec", "boolean")) end }, { ["it diagnoses argument #1 tv_nsec field type not int"] = function () expect (nanosleep {tv_sec = -1, tv_nsec = false}). to_raise.any_of (typeerrors (1, "int", "tv_nsec", "boolean")) end }, { ["it diagnoses argument #1 spurious fields"] = function () expect (nanosleep {tv_sec = -1, tv_nsec = -1, bogus = false}). to_raise.any_of (typeerrors (1, nil, "bogus")) end }, } } - it returns an integer: expect (nanosleep {tv_sec = 0, tv_nsec = 10}).to_be (0) - describe strftime: - before: strftime = tm.strftime t = { tm_wday = 0, tm_isdst = 1, tm_sec = 2, tm_min = 3, tm_hour = 4, tm_mday = 5, tm_mon = 6, tm_year = 7, tm_yday = 8 } - context with bad arguments: badargs.diagnose (strftime, "(string, table)") - context with place-holders: - it plugs tm_wday: expect (strftime ("%w", t)).to_be "0" - it plugs tm_sec: expect (strftime ("%S", t)).to_be "02" - it plugs tm_min: expect (strftime ("%M", t)).to_be "03" - it plugs tm_hour: expect (strftime ("%H", t)).to_be "04" - it plugs tm_mday: expect (strftime ("%d", t)).to_be "05" - it plugs tm_mon: expect (strftime ("%m", t)).to_be "07" - it plugs tm_year: expect (strftime ("%y", t)).to_be "07" - it plugs tm_yday: expect (strftime ("%j", t)).to_be "009" - describe strptime: - before: strptime = tm.strptime - context with bad arguments: badargs.diagnose (strptime, "(string, string)") - context with place-holders: - before: t, i = strptime ("Mon Jun 4 03:02:01 BST 1906 garbage", "%a %b %d %H:%M:%S BST %Y") - it returns the first unconsumed character: expect (i).to_be (29) # tm_yday and tm_isdst are not set by strptime - it scans into tm_wday: expect (t.tm_wday).to_be (1) - it scans into tm_sec: expect (t.tm_sec).to_be (1) - it scans into tm_min: expect (t.tm_min).to_be (2) - it scans into tm_hour: expect (t.tm_hour).to_be (3) - it scans into tm_mday: expect (t.tm_mday).to_be (4) - it scans into tm_mon: expect (t.tm_mon).to_be (5) - it scans into tm_year: expect (t.tm_year).to_be (6) - describe time: - before: time = tm.time - context with bad arguments: badargs.diagnose (time, "()") - it returns epoch seconds: expect (type (time ())).to_be "number" expect (time () > 0).to_be (true)