def setUp(self):
self.date1_365_day = DatetimeNoLeap(-5000, 1, 2, 12)
self.date2_365_day = DatetimeNoLeap(-5000, 1, 3, 12)
self.date3_gregorian = DatetimeGregorian(1969, 7, 20, 12)
# last day of the Julian calendar in the mixed Julian/Gregorian calendar
self.date4_gregorian = DatetimeGregorian(1582, 10, 4)
# first day of the Gregorian calendar in the mixed Julian/Gregorian calendar
self.date5_gregorian = DatetimeGregorian(1582, 10, 15)
self.date6_proleptic_gregorian = DatetimeProlepticGregorian(
1582, 10, 15)
self.date7_360_day = Datetime360Day(2000, 1, 1)
self.date8_julian = DatetimeJulian(1582, 10, 4)
# a datetime.datetime instance (proleptic Gregorian calendar)
self.datetime_date1 = datetime(1969, 7, 21, 12)
self.delta = timedelta(hours=25)
def test_add(self):
dt = self.date1_365_day
# datetime + timedelta
self.assertEqual(
dt + self.delta, # add 25 hours
dt.replace(day=dt.day + 1, hour=dt.hour + 1))
# timedelta + datetime
self.assertEqual(
self.delta + dt, # add 25 hours
dt.replace(day=dt.day + 1, hour=dt.hour + 1))
# test the Julian/Gregorian transition
self.assertEqual(self.date4_gregorian + self.delta,
DatetimeGregorian(1582, 10, 15, 1))
# The Julian calendar has no invalid dates
self.assertEqual(self.date8_julian + self.delta,
DatetimeJulian(1582, 10, 5, 1))
# Test going over the year boundary.
self.assertEqual(
DatetimeGregorian(2000, 11, 1) + timedelta(days=30 + 31),
DatetimeGregorian(2001, 1, 1))
# Year 2000 is a leap year.
self.assertEqual(
DatetimeGregorian(2000, 1, 1) + timedelta(days=31 + 29),
DatetimeGregorian(2000, 3, 1))
# Test the 366_day calendar.
self.assertEqual(
DatetimeAllLeap(1, 1, 1) + timedelta(days=366 * 10 + 31),
DatetimeAllLeap(11, 2, 1))
# The Gregorian calendar has no year zero.
self.assertEqual(
DatetimeGregorian(-1, 12, 31) + self.delta,
DatetimeGregorian(1, 1, 1, 1))
def invalid_add_1():
self.date1_365_day + 1
def invalid_add_2():
1 + self.date1_365_day
for func in [invalid_add_1, invalid_add_2]:
self.assertRaises(TypeError, func)
def setUp(self):
self.date1_365_day = DatetimeNoLeap(-5000, 1, 2, 12)
self.date2_365_day = DatetimeNoLeap(-5000, 1, 3, 12)
self.date3_gregorian = DatetimeGregorian(1969, 7, 20, 12)
# last day of the Julian calendar in the mixed Julian/Gregorian calendar
self.date4_gregorian = DatetimeGregorian(1582, 10, 4)
# first day of the Gregorian calendar in the mixed Julian/Gregorian calendar
self.date5_gregorian = DatetimeGregorian(1582, 10, 15)
self.date6_proleptic_gregorian = DatetimeProlepticGregorian(1582, 10, 15)
self.date7_360_day = Datetime360Day(2000, 1, 1)
self.date8_julian = DatetimeJulian(1582, 10, 4)
# a datetime.datetime instance (proleptic Gregorian calendar)
self.datetime_date1 = datetime(1969, 7, 21, 12)
self.delta = timedelta(hours=25)
def invalid_gregorian_date():
DatetimeGregorian(1582, 10, 5) + self.delta
def invalid_day():
DatetimeGregorian(1, 1, 32) + self.delta
def invalid_month():
DatetimeGregorian(1, 13, 1) + self.delta
def invalid_year():
DatetimeGregorian(0, 1, 1) + self.delta
def test_sub(self):
# subtracting a timedelta
previous_day = self.date1_365_day - self.delta
self.assertEqual(previous_day.day, self.date1_365_day.day - 1)
def total_seconds(td):
"""Equivalent to td.total_seconds() on Python >= 2.7. See
https://docs.python.org/2/library/datetime.html#datetime.timedelta.total_seconds
"""
return (td.microseconds +
(td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
# sutracting two netcdftime.datetime instances
delta = self.date2_365_day - self.date1_365_day
# date1 and date2 are exactly one day apart
self.assertEqual(total_seconds(delta), 86400)
# subtracting netcdftime.datetime from datetime.datetime
delta = self.datetime_date1 - self.date3_gregorian
# real_date2 and real_date1 are exactly one day apart
self.assertEqual(total_seconds(delta), 86400)
# subtracting datetime.datetime from netcdftime.datetime
delta = self.date3_gregorian - self.datetime_date1
# real_date2 and real_date1 are exactly one day apart
self.assertEqual(total_seconds(delta), -86400)
# Test the Julian/Gregorian transition.
self.assertEqual(self.date5_gregorian - self.delta,
DatetimeGregorian(1582, 10, 3, 23))
# The proleptic Gregorian calendar does not have invalid dates.
self.assertEqual(self.date6_proleptic_gregorian - self.delta,
DatetimeProlepticGregorian(1582, 10, 13, 23))
# The Gregorian calendar has no year zero.
self.assertEqual(
DatetimeGregorian(1, 1, 1) - self.delta,
DatetimeGregorian(-1, 12, 30, 23))
# The 360_day calendar has year zero.
self.assertEqual(self.date7_360_day - timedelta(days=2000 * 360),
Datetime360Day(0, 1, 1))
# Test going over the year boundary.
self.assertEqual(
DatetimeGregorian(2000, 3, 1) - timedelta(days=29 + 31 + 31),
DatetimeGregorian(1999, 12, 1))
# Year 2000 is a leap year.
self.assertEqual(
DatetimeGregorian(2000, 3, 1) - self.delta,
DatetimeGregorian(2000, 2, 28, 23))
def invalid_sub_1():
self.date1_365_day - 1
def invalid_sub_2():
1 - self.date1_365_day
def invalid_sub_3():
self.date1_365_day - self.datetime_date1
def invalid_sub_4():
self.datetime_date1 - self.date1_365_day
def invalid_sub_5():
self.date3_gregorian - self.date1_365_day
for func in [invalid_sub_1, invalid_sub_2]:
self.assertRaises(TypeError, func)
for func in [invalid_sub_3, invalid_sub_4, invalid_sub_5]:
self.assertRaises(ValueError, func)
class DateTime(unittest.TestCase):
def setUp(self):
self.date1_365_day = DatetimeNoLeap(-5000, 1, 2, 12)
self.date2_365_day = DatetimeNoLeap(-5000, 1, 3, 12)
self.date3_gregorian = DatetimeGregorian(1969, 7, 20, 12)
# last day of the Julian calendar in the mixed Julian/Gregorian calendar
self.date4_gregorian = DatetimeGregorian(1582, 10, 4)
# first day of the Gregorian calendar in the mixed Julian/Gregorian calendar
self.date5_gregorian = DatetimeGregorian(1582, 10, 15)
self.date6_proleptic_gregorian = DatetimeProlepticGregorian(
1582, 10, 15)
self.date7_360_day = Datetime360Day(2000, 1, 1)
self.date8_julian = DatetimeJulian(1582, 10, 4)
# a datetime.datetime instance (proleptic Gregorian calendar)
self.datetime_date1 = datetime(1969, 7, 21, 12)
self.delta = timedelta(hours=25)
def test_add(self):
dt = self.date1_365_day
# datetime + timedelta
self.assertEqual(
dt + self.delta, # add 25 hours
dt.replace(day=dt.day + 1, hour=dt.hour + 1))
# timedelta + datetime
self.assertEqual(
self.delta + dt, # add 25 hours
dt.replace(day=dt.day + 1, hour=dt.hour + 1))
# test the Julian/Gregorian transition
self.assertEqual(self.date4_gregorian + self.delta,
DatetimeGregorian(1582, 10, 15, 1))
# The Julian calendar has no invalid dates
self.assertEqual(self.date8_julian + self.delta,
DatetimeJulian(1582, 10, 5, 1))
# Test going over the year boundary.
self.assertEqual(
DatetimeGregorian(2000, 11, 1) + timedelta(days=30 + 31),
DatetimeGregorian(2001, 1, 1))
# Year 2000 is a leap year.
self.assertEqual(
DatetimeGregorian(2000, 1, 1) + timedelta(days=31 + 29),
DatetimeGregorian(2000, 3, 1))
# Test the 366_day calendar.
self.assertEqual(
DatetimeAllLeap(1, 1, 1) + timedelta(days=366 * 10 + 31),
DatetimeAllLeap(11, 2, 1))
# The Gregorian calendar has no year zero.
self.assertEqual(
DatetimeGregorian(-1, 12, 31) + self.delta,
DatetimeGregorian(1, 1, 1, 1))
def invalid_add_1():
self.date1_365_day + 1
def invalid_add_2():
1 + self.date1_365_day
for func in [invalid_add_1, invalid_add_2]:
self.assertRaises(TypeError, func)
def test_sub(self):
# subtracting a timedelta
previous_day = self.date1_365_day - self.delta
self.assertEqual(previous_day.day, self.date1_365_day.day - 1)
def total_seconds(td):
"""Equivalent to td.total_seconds() on Python >= 2.7. See
https://docs.python.org/2/library/datetime.html#datetime.timedelta.total_seconds
"""
return (td.microseconds +
(td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
# sutracting two netcdftime.datetime instances
delta = self.date2_365_day - self.date1_365_day
# date1 and date2 are exactly one day apart
self.assertEqual(total_seconds(delta), 86400)
# subtracting netcdftime.datetime from datetime.datetime
delta = self.datetime_date1 - self.date3_gregorian
# real_date2 and real_date1 are exactly one day apart
self.assertEqual(total_seconds(delta), 86400)
# subtracting datetime.datetime from netcdftime.datetime
delta = self.date3_gregorian - self.datetime_date1
# real_date2 and real_date1 are exactly one day apart
self.assertEqual(total_seconds(delta), -86400)
# Test the Julian/Gregorian transition.
self.assertEqual(self.date5_gregorian - self.delta,
DatetimeGregorian(1582, 10, 3, 23))
# The proleptic Gregorian calendar does not have invalid dates.
self.assertEqual(self.date6_proleptic_gregorian - self.delta,
DatetimeProlepticGregorian(1582, 10, 13, 23))
# The Gregorian calendar has no year zero.
self.assertEqual(
DatetimeGregorian(1, 1, 1) - self.delta,
DatetimeGregorian(-1, 12, 30, 23))
# The 360_day calendar has year zero.
self.assertEqual(self.date7_360_day - timedelta(days=2000 * 360),
Datetime360Day(0, 1, 1))
# Test going over the year boundary.
self.assertEqual(
DatetimeGregorian(2000, 3, 1) - timedelta(days=29 + 31 + 31),
DatetimeGregorian(1999, 12, 1))
# Year 2000 is a leap year.
self.assertEqual(
DatetimeGregorian(2000, 3, 1) - self.delta,
DatetimeGregorian(2000, 2, 28, 23))
def invalid_sub_1():
self.date1_365_day - 1
def invalid_sub_2():
1 - self.date1_365_day
def invalid_sub_3():
self.date1_365_day - self.datetime_date1
def invalid_sub_4():
self.datetime_date1 - self.date1_365_day
def invalid_sub_5():
self.date3_gregorian - self.date1_365_day
for func in [invalid_sub_1, invalid_sub_2]:
self.assertRaises(TypeError, func)
for func in [invalid_sub_3, invalid_sub_4, invalid_sub_5]:
self.assertRaises(ValueError, func)
def test_replace(self):
self.assertEqual(self.date1_365_day.replace(year=4000).year, 4000)
self.assertEqual(self.date1_365_day.replace(month=3).month, 3)
self.assertEqual(self.date1_365_day.replace(day=3).day, 3)
self.assertEqual(self.date1_365_day.replace(hour=3).hour, 3)
self.assertEqual(self.date1_365_day.replace(minute=3).minute, 3)
self.assertEqual(self.date1_365_day.replace(second=3).second, 3)
self.assertEqual(
self.date1_365_day.replace(microsecond=3).microsecond, 3)
self.assertEqual(self.date1_365_day.replace(dayofwk=3).dayofwk, 3)
self.assertEqual(self.date1_365_day.replace(dayofyr=3).dayofyr, 3)
def test_pickling(self):
"Test reversibility of pickling."
import pickle
date = Datetime360Day(year=1,
month=2,
day=3,
hour=4,
minute=5,
second=6,
microsecond=7)
self.assertEqual(date, pickle.loads(pickle.dumps(date)))
def test_misc(self):
"Miscellaneous tests."
# make sure repr succeeds
repr(self.date1_365_day)
# make sure strftime without a format string works
self.assertEqual(self.date3_gregorian.strftime(None),
"1969-07-20 12:00:00")
def invalid_year():
DatetimeGregorian(0, 1, 1) + self.delta
def invalid_month():
DatetimeGregorian(1, 13, 1) + self.delta
def invalid_day():
DatetimeGregorian(1, 1, 32) + self.delta
def invalid_gregorian_date():
DatetimeGregorian(1582, 10, 5) + self.delta
for func in [
invalid_year, invalid_month, invalid_day,
invalid_gregorian_date
]:
self.assertRaises(ValueError, func)
def test_richcmp(self):
# compare datetime and datetime
self.assertTrue(self.date1_365_day == self.date1_365_day)
self.assertFalse(self.date1_365_day == self.date2_365_day)
self.assertTrue(self.date1_365_day < self.date2_365_day)
self.assertFalse(self.date1_365_day < self.date1_365_day)
self.assertTrue(self.date2_365_day > self.date1_365_day)
self.assertFalse(self.date1_365_day > self.date2_365_day)
# compare real_datetime and datetime
self.assertTrue(self.datetime_date1 > self.date3_gregorian)
# compare datetime and real_datetime
self.assertFalse(self.date3_gregorian > self.datetime_date1)
def not_comparable_1():
"compare two datetime instances with different calendars"
self.date1_365_day > self.date3_gregorian
def not_comparable_2():
"compare a datetime instance with a non-standard calendar to real_datetime"
self.date2_365_day > self.datetime_date1
def not_comparable_3():
"compare datetime.datetime to netcdftime.datetime with a non-gregorian calendar"
self.datetime_date1 > self.date2_365_day
def not_comparable_4():
"compare a datetime instance to something other than a datetime"
self.date1_365_day > 0
for func in [
not_comparable_1, not_comparable_2, not_comparable_3,
not_comparable_4
]:
self.assertRaises(TypeError, func)
class DateTime(unittest.TestCase):
def setUp(self):
self.date1_365_day = DatetimeNoLeap(-5000, 1, 2, 12)
self.date2_365_day = DatetimeNoLeap(-5000, 1, 3, 12)
self.date3_gregorian = DatetimeGregorian(1969, 7, 20, 12)
# last day of the Julian calendar in the mixed Julian/Gregorian calendar
self.date4_gregorian = DatetimeGregorian(1582, 10, 4)
# first day of the Gregorian calendar in the mixed Julian/Gregorian calendar
self.date5_gregorian = DatetimeGregorian(1582, 10, 15)
self.date6_proleptic_gregorian = DatetimeProlepticGregorian(1582, 10, 15)
self.date7_360_day = Datetime360Day(2000, 1, 1)
self.date8_julian = DatetimeJulian(1582, 10, 4)
# a datetime.datetime instance (proleptic Gregorian calendar)
self.datetime_date1 = datetime(1969, 7, 21, 12)
self.delta = timedelta(hours=25)
def test_add(self):
dt = self.date1_365_day
# datetime + timedelta
self.assertEqual(dt + self.delta, # add 25 hours
dt.replace(day=dt.day + 1, hour=dt.hour + 1))
# timedelta + datetime
self.assertEqual(self.delta + dt, # add 25 hours
dt.replace(day=dt.day + 1, hour=dt.hour + 1))
# test the Julian/Gregorian transition
self.assertEqual(self.date4_gregorian + self.delta,
DatetimeGregorian(1582, 10, 15, 1))
# The Julian calendar has no invalid dates
self.assertEqual(self.date8_julian + self.delta,
DatetimeJulian(1582, 10, 5, 1))
# Test going over the year boundary.
self.assertEqual(DatetimeGregorian(2000, 11, 1) + timedelta(days=30 + 31),
DatetimeGregorian(2001, 1, 1))
# Year 2000 is a leap year.
self.assertEqual(DatetimeGregorian(2000, 1, 1) + timedelta(days=31 + 29),
DatetimeGregorian(2000, 3, 1))
# Test the 366_day calendar.
self.assertEqual(DatetimeAllLeap(1, 1, 1) + timedelta(days=366 * 10 + 31),
DatetimeAllLeap(11, 2, 1))
# The Gregorian calendar has no year zero.
self.assertEqual(DatetimeGregorian(-1, 12, 31) + self.delta,
DatetimeGregorian(1, 1, 1, 1))
def invalid_add_1():
self.date1_365_day + 1
def invalid_add_2():
1 + self.date1_365_day
for func in [invalid_add_1, invalid_add_2]:
self.assertRaises(TypeError, func)
def test_sub(self):
# subtracting a timedelta
previous_day = self.date1_365_day - self.delta
self.assertEqual(previous_day.day, self.date1_365_day.day - 1)
def total_seconds(td):
"""Equivalent to td.total_seconds() on Python >= 2.7. See
https://docs.python.org/2/library/datetime.html#datetime.timedelta.total_seconds
"""
return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
# sutracting two netcdftime.datetime instances
delta = self.date2_365_day - self.date1_365_day
# date1 and date2 are exactly one day apart
self.assertEqual(total_seconds(delta), 86400)
# subtracting netcdftime.datetime from datetime.datetime
delta = self.datetime_date1 - self.date3_gregorian
# real_date2 and real_date1 are exactly one day apart
self.assertEqual(total_seconds(delta), 86400)
# subtracting datetime.datetime from netcdftime.datetime
delta = self.date3_gregorian - self.datetime_date1
# real_date2 and real_date1 are exactly one day apart
self.assertEqual(total_seconds(delta), -86400)
# Test the Julian/Gregorian transition.
self.assertEqual(self.date5_gregorian - self.delta,
DatetimeGregorian(1582, 10, 3, 23))
# The proleptic Gregorian calendar does not have invalid dates.
self.assertEqual(self.date6_proleptic_gregorian - self.delta,
DatetimeProlepticGregorian(1582, 10, 13, 23))
# The Gregorian calendar has no year zero.
self.assertEqual(DatetimeGregorian(1, 1, 1) - self.delta,
DatetimeGregorian(-1, 12, 30, 23))
# The 360_day calendar has year zero.
self.assertEqual(self.date7_360_day - timedelta(days=2000 * 360),
Datetime360Day(0, 1, 1))
# Test going over the year boundary.
self.assertEqual(DatetimeGregorian(2000, 3, 1) - timedelta(days=29 + 31 + 31),
DatetimeGregorian(1999, 12, 1))
# Year 2000 is a leap year.
self.assertEqual(DatetimeGregorian(2000, 3, 1) - self.delta,
DatetimeGregorian(2000, 2, 28, 23))
def invalid_sub_1():
self.date1_365_day - 1
def invalid_sub_2():
1 - self.date1_365_day
def invalid_sub_3():
self.date1_365_day - self.datetime_date1
def invalid_sub_4():
self.datetime_date1 - self.date1_365_day
def invalid_sub_5():
self.date3_gregorian - self.date1_365_day
for func in [invalid_sub_1, invalid_sub_2]:
self.assertRaises(TypeError, func)
for func in [invalid_sub_3, invalid_sub_4, invalid_sub_5]:
self.assertRaises(ValueError, func)
def test_replace(self):
self.assertEqual(self.date1_365_day.replace(year=4000).year, 4000)
self.assertEqual(self.date1_365_day.replace(month=3).month, 3)
self.assertEqual(self.date1_365_day.replace(day=3).day, 3)
self.assertEqual(self.date1_365_day.replace(hour=3).hour, 3)
self.assertEqual(self.date1_365_day.replace(minute=3).minute, 3)
self.assertEqual(self.date1_365_day.replace(second=3).second, 3)
self.assertEqual(self.date1_365_day.replace(microsecond=3).microsecond, 3)
self.assertEqual(self.date1_365_day.replace(dayofwk=3).dayofwk, 3)
self.assertEqual(self.date1_365_day.replace(dayofyr=3).dayofyr, 3)
def test_pickling(self):
"Test reversibility of pickling."
import pickle
date = Datetime360Day(year=1, month=2, day=3, hour=4, minute=5, second=6, microsecond=7)
self.assertEqual(date, pickle.loads(pickle.dumps(date)))
def test_misc(self):
"Miscellaneous tests."
# make sure repr succeeds
repr(self.date1_365_day)
# make sure strftime without a format string works
self.assertEqual(self.date3_gregorian.strftime(None),
"1969-07-20 12:00:00")
def invalid_year():
DatetimeGregorian(0, 1, 1) + self.delta
def invalid_month():
DatetimeGregorian(1, 13, 1) + self.delta
def invalid_day():
DatetimeGregorian(1, 1, 32) + self.delta
def invalid_gregorian_date():
DatetimeGregorian(1582, 10, 5) + self.delta
for func in [invalid_year, invalid_month, invalid_day, invalid_gregorian_date]:
self.assertRaises(ValueError, func)
def test_richcmp(self):
# compare datetime and datetime
self.assertTrue(self.date1_365_day == self.date1_365_day)
self.assertFalse(self.date1_365_day == self.date2_365_day)
self.assertTrue(self.date1_365_day < self.date2_365_day)
self.assertFalse(self.date1_365_day < self.date1_365_day)
self.assertTrue(self.date2_365_day > self.date1_365_day)
self.assertFalse(self.date1_365_day > self.date2_365_day)
# compare real_datetime and datetime
self.assertTrue(self.datetime_date1 > self.date3_gregorian)
# compare datetime and real_datetime
self.assertFalse(self.date3_gregorian > self.datetime_date1)
def not_comparable_1():
"compare two datetime instances with different calendars"
self.date1_365_day > self.date3_gregorian
def not_comparable_2():
"compare a datetime instance with a non-standard calendar to real_datetime"
self.date2_365_day > self.datetime_date1
def not_comparable_3():
"compare datetime.datetime to netcdftime.datetime with a non-gregorian calendar"
self.datetime_date1 > self.date2_365_day
def not_comparable_4():
"compare a datetime instance to something other than a datetime"
self.date1_365_day > 0
for func in [not_comparable_1, not_comparable_2, not_comparable_3, not_comparable_4]:
self.assertRaises(TypeError, func)