mirror of
https://github.com/python/cpython.git
synced 2025-07-08 03:45:36 +00:00
convert old fail* assertions to assert*
This commit is contained in:
Benjamin Peterson
parent
98d23f2e06
commit
c9c0f201fe
275 changed files with 4540 additions and 4540 deletions
|
|
@ -77,9 +77,9 @@ class TestTZInfo(unittest.TestCase):
|
|||
def __init__(self, offset, name):
|
||||
self.__offset = offset
|
||||
self.__name = name
|
||||
self.failUnless(issubclass(NotEnough, tzinfo))
|
||||
self.assertTrue(issubclass(NotEnough, tzinfo))
|
||||
ne = NotEnough(3, "NotByALongShot")
|
||||
self.failUnless(isinstance(ne, tzinfo))
|
||||
self.assertTrue(isinstance(ne, tzinfo))
|
||||
|
||||
dt = datetime.now()
|
||||
self.assertRaises(NotImplementedError, ne.tzname, dt)
|
||||
|
|
@ -88,7 +88,7 @@ class TestTZInfo(unittest.TestCase):
|
|||
|
||||
def test_normal(self):
|
||||
fo = FixedOffset(3, "Three")
|
||||
self.failUnless(isinstance(fo, tzinfo))
|
||||
self.assertTrue(isinstance(fo, tzinfo))
|
||||
for dt in datetime.now(), None:
|
||||
self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3))
|
||||
self.assertEqual(fo.tzname(dt), "Three")
|
||||
|
|
@ -99,25 +99,25 @@ class TestTZInfo(unittest.TestCase):
|
|||
# carry no data), but they need to be picklable anyway else
|
||||
# concrete subclasses can't be pickled.
|
||||
orig = tzinfo.__new__(tzinfo)
|
||||
self.failUnless(type(orig) is tzinfo)
|
||||
self.assertTrue(type(orig) is tzinfo)
|
||||
for pickler, unpickler, proto in pickle_choices:
|
||||
green = pickler.dumps(orig, proto)
|
||||
derived = unpickler.loads(green)
|
||||
self.failUnless(type(derived) is tzinfo)
|
||||
self.assertTrue(type(derived) is tzinfo)
|
||||
|
||||
def test_pickling_subclass(self):
|
||||
# Make sure we can pickle/unpickle an instance of a subclass.
|
||||
offset = timedelta(minutes=-300)
|
||||
orig = PicklableFixedOffset(offset, 'cookie')
|
||||
self.failUnless(isinstance(orig, tzinfo))
|
||||
self.failUnless(type(orig) is PicklableFixedOffset)
|
||||
self.assertTrue(isinstance(orig, tzinfo))
|
||||
self.assertTrue(type(orig) is PicklableFixedOffset)
|
||||
self.assertEqual(orig.utcoffset(None), offset)
|
||||
self.assertEqual(orig.tzname(None), 'cookie')
|
||||
for pickler, unpickler, proto in pickle_choices:
|
||||
green = pickler.dumps(orig, proto)
|
||||
derived = unpickler.loads(green)
|
||||
self.failUnless(isinstance(derived, tzinfo))
|
||||
self.failUnless(type(derived) is PicklableFixedOffset)
|
||||
self.assertTrue(isinstance(derived, tzinfo))
|
||||
self.assertTrue(type(derived) is PicklableFixedOffset)
|
||||
self.assertEqual(derived.utcoffset(None), offset)
|
||||
self.assertEqual(derived.tzname(None), 'cookie')
|
||||
|
||||
|
|
@ -134,16 +134,16 @@ class HarmlessMixedComparison:
|
|||
def test_harmless_mixed_comparison(self):
|
||||
me = self.theclass(1, 1, 1)
|
||||
|
||||
self.failIf(me == ())
|
||||
self.failUnless(me != ())
|
||||
self.failIf(() == me)
|
||||
self.failUnless(() != me)
|
||||
self.assertFalse(me == ())
|
||||
self.assertTrue(me != ())
|
||||
self.assertFalse(() == me)
|
||||
self.assertTrue(() != me)
|
||||
|
||||
self.failUnless(me in [1, 20, [], me])
|
||||
self.failIf(me not in [1, 20, [], me])
|
||||
self.assertTrue(me in [1, 20, [], me])
|
||||
self.assertFalse(me not in [1, 20, [], me])
|
||||
|
||||
self.failUnless([] in [me, 1, 20, []])
|
||||
self.failIf([] not in [me, 1, 20, []])
|
||||
self.assertTrue([] in [me, 1, 20, []])
|
||||
self.assertFalse([] not in [me, 1, 20, []])
|
||||
|
||||
def test_harmful_mixed_comparison(self):
|
||||
me = self.theclass(1, 1, 1)
|
||||
|
|
@ -303,26 +303,26 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
|
|||
t1 = timedelta(2, 3, 4)
|
||||
t2 = timedelta(2, 3, 4)
|
||||
self.assertEqual(t1, t2)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t1 >= t2)
|
||||
self.failUnless(not t1 != t2)
|
||||
self.failUnless(not t1 < t2)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t1 >= t2)
|
||||
self.assertTrue(not t1 != t2)
|
||||
self.assertTrue(not t1 < t2)
|
||||
self.assertTrue(not t1 > t2)
|
||||
|
||||
for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
|
||||
t2 = timedelta(*args) # this is larger than t1
|
||||
self.failUnless(t1 < t2)
|
||||
self.failUnless(t2 > t1)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t2 >= t1)
|
||||
self.failUnless(t1 != t2)
|
||||
self.failUnless(t2 != t1)
|
||||
self.failUnless(not t1 == t2)
|
||||
self.failUnless(not t2 == t1)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.failUnless(not t2 < t1)
|
||||
self.failUnless(not t1 >= t2)
|
||||
self.failUnless(not t2 <= t1)
|
||||
self.assertTrue(t1 < t2)
|
||||
self.assertTrue(t2 > t1)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t2 >= t1)
|
||||
self.assertTrue(t1 != t2)
|
||||
self.assertTrue(t2 != t1)
|
||||
self.assertTrue(not t1 == t2)
|
||||
self.assertTrue(not t2 == t1)
|
||||
self.assertTrue(not t1 > t2)
|
||||
self.assertTrue(not t2 < t1)
|
||||
self.assertTrue(not t1 >= t2)
|
||||
self.assertTrue(not t2 <= t1)
|
||||
|
||||
for badarg in OTHERSTUFF:
|
||||
self.assertEqual(t1 == badarg, False)
|
||||
|
|
@ -368,7 +368,7 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
|
|||
|
||||
# Verify td -> string -> td identity.
|
||||
s = repr(td)
|
||||
self.failUnless(s.startswith('datetime.'))
|
||||
self.assertTrue(s.startswith('datetime.'))
|
||||
s = s[9:]
|
||||
td2 = eval(s)
|
||||
self.assertEqual(td, td2)
|
||||
|
|
@ -378,10 +378,10 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
|
|||
self.assertEqual(td, td2)
|
||||
|
||||
def test_resolution_info(self):
|
||||
self.assert_(isinstance(timedelta.min, timedelta))
|
||||
self.assert_(isinstance(timedelta.max, timedelta))
|
||||
self.assert_(isinstance(timedelta.resolution, timedelta))
|
||||
self.assert_(timedelta.max > timedelta.min)
|
||||
self.assertTrue(isinstance(timedelta.min, timedelta))
|
||||
self.assertTrue(isinstance(timedelta.max, timedelta))
|
||||
self.assertTrue(isinstance(timedelta.resolution, timedelta))
|
||||
self.assertTrue(timedelta.max > timedelta.min)
|
||||
self.assertEqual(timedelta.min, timedelta(-999999999))
|
||||
self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1))
|
||||
self.assertEqual(timedelta.resolution, timedelta(0, 0, 1))
|
||||
|
|
@ -428,11 +428,11 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
|
|||
(-1, 24*3600-1, 999999))
|
||||
|
||||
def test_bool(self):
|
||||
self.failUnless(timedelta(1))
|
||||
self.failUnless(timedelta(0, 1))
|
||||
self.failUnless(timedelta(0, 0, 1))
|
||||
self.failUnless(timedelta(microseconds=1))
|
||||
self.failUnless(not timedelta(0))
|
||||
self.assertTrue(timedelta(1))
|
||||
self.assertTrue(timedelta(0, 1))
|
||||
self.assertTrue(timedelta(0, 0, 1))
|
||||
self.assertTrue(timedelta(microseconds=1))
|
||||
self.assertTrue(not timedelta(0))
|
||||
|
||||
def test_subclass_timedelta(self):
|
||||
|
||||
|
|
@ -448,17 +448,17 @@ class TestTimeDelta(HarmlessMixedComparison, unittest.TestCase):
|
|||
return round(sum)
|
||||
|
||||
t1 = T(days=1)
|
||||
self.assert_(type(t1) is T)
|
||||
self.assertTrue(type(t1) is T)
|
||||
self.assertEqual(t1.as_hours(), 24)
|
||||
|
||||
t2 = T(days=-1, seconds=-3600)
|
||||
self.assert_(type(t2) is T)
|
||||
self.assertTrue(type(t2) is T)
|
||||
self.assertEqual(t2.as_hours(), -25)
|
||||
|
||||
t3 = t1 + t2
|
||||
self.assert_(type(t3) is timedelta)
|
||||
self.assertTrue(type(t3) is timedelta)
|
||||
t4 = T.from_td(t3)
|
||||
self.assert_(type(t4) is T)
|
||||
self.assertTrue(type(t4) is T)
|
||||
self.assertEqual(t3.days, t4.days)
|
||||
self.assertEqual(t3.seconds, t4.seconds)
|
||||
self.assertEqual(t3.microseconds, t4.microseconds)
|
||||
|
|
@ -521,7 +521,7 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase):
|
|||
self.theclass.today()):
|
||||
# Verify dt -> string -> date identity.
|
||||
s = repr(dt)
|
||||
self.failUnless(s.startswith('datetime.'))
|
||||
self.assertTrue(s.startswith('datetime.'))
|
||||
s = s[9:]
|
||||
dt2 = eval(s)
|
||||
self.assertEqual(dt, dt2)
|
||||
|
|
@ -755,7 +755,7 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase):
|
|||
|
||||
# It worked or it didn't. If it didn't, assume it's reason #2, and
|
||||
# let the test pass if they're within half a second of each other.
|
||||
self.failUnless(today == todayagain or
|
||||
self.assertTrue(today == todayagain or
|
||||
abs(todayagain - today) < timedelta(seconds=0.5))
|
||||
|
||||
def test_weekday(self):
|
||||
|
|
@ -891,10 +891,10 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase):
|
|||
self.assertEqual(b.__format__(fmt), 'B')
|
||||
|
||||
def test_resolution_info(self):
|
||||
self.assert_(isinstance(self.theclass.min, self.theclass))
|
||||
self.assert_(isinstance(self.theclass.max, self.theclass))
|
||||
self.assert_(isinstance(self.theclass.resolution, timedelta))
|
||||
self.assert_(self.theclass.max > self.theclass.min)
|
||||
self.assertTrue(isinstance(self.theclass.min, self.theclass))
|
||||
self.assertTrue(isinstance(self.theclass.max, self.theclass))
|
||||
self.assertTrue(isinstance(self.theclass.resolution, timedelta))
|
||||
self.assertTrue(self.theclass.max > self.theclass.min)
|
||||
|
||||
def test_extreme_timedelta(self):
|
||||
big = self.theclass.max - self.theclass.min
|
||||
|
|
@ -943,26 +943,26 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase):
|
|||
t1 = self.theclass(2, 3, 4)
|
||||
t2 = self.theclass(2, 3, 4)
|
||||
self.assertEqual(t1, t2)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t1 >= t2)
|
||||
self.failUnless(not t1 != t2)
|
||||
self.failUnless(not t1 < t2)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t1 >= t2)
|
||||
self.assertTrue(not t1 != t2)
|
||||
self.assertTrue(not t1 < t2)
|
||||
self.assertTrue(not t1 > t2)
|
||||
|
||||
for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
|
||||
t2 = self.theclass(*args) # this is larger than t1
|
||||
self.failUnless(t1 < t2)
|
||||
self.failUnless(t2 > t1)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t2 >= t1)
|
||||
self.failUnless(t1 != t2)
|
||||
self.failUnless(t2 != t1)
|
||||
self.failUnless(not t1 == t2)
|
||||
self.failUnless(not t2 == t1)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.failUnless(not t2 < t1)
|
||||
self.failUnless(not t1 >= t2)
|
||||
self.failUnless(not t2 <= t1)
|
||||
self.assertTrue(t1 < t2)
|
||||
self.assertTrue(t2 > t1)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t2 >= t1)
|
||||
self.assertTrue(t1 != t2)
|
||||
self.assertTrue(t2 != t1)
|
||||
self.assertTrue(not t1 == t2)
|
||||
self.assertTrue(not t2 == t1)
|
||||
self.assertTrue(not t1 > t2)
|
||||
self.assertTrue(not t2 < t1)
|
||||
self.assertTrue(not t1 >= t2)
|
||||
self.assertTrue(not t2 <= t1)
|
||||
|
||||
for badarg in OTHERSTUFF:
|
||||
self.assertEqual(t1 == badarg, False)
|
||||
|
|
@ -1031,8 +1031,8 @@ class TestDate(HarmlessMixedComparison, unittest.TestCase):
|
|||
|
||||
def test_bool(self):
|
||||
# All dates are considered true.
|
||||
self.failUnless(self.theclass.min)
|
||||
self.failUnless(self.theclass.max)
|
||||
self.assertTrue(self.theclass.min)
|
||||
self.assertTrue(self.theclass.max)
|
||||
|
||||
def test_strftime_out_of_range(self):
|
||||
# For nasty technical reasons, we can't handle years before 1900.
|
||||
|
|
@ -1155,7 +1155,7 @@ class TestDateTime(TestDate):
|
|||
self.theclass.now()):
|
||||
# Verify dt -> string -> datetime identity.
|
||||
s = repr(dt)
|
||||
self.failUnless(s.startswith('datetime.'))
|
||||
self.assertTrue(s.startswith('datetime.'))
|
||||
s = s[9:]
|
||||
dt2 = eval(s)
|
||||
self.assertEqual(dt, dt2)
|
||||
|
|
@ -1228,7 +1228,7 @@ class TestDateTime(TestDate):
|
|||
dt2 = self.theclass(2002, 3, 1, 10, 0, 0)
|
||||
dt3 = self.theclass(2002, 3, 1, 9, 0, 0)
|
||||
self.assertEqual(dt1, dt3)
|
||||
self.assert_(dt2 > dt3)
|
||||
self.assertTrue(dt2 > dt3)
|
||||
|
||||
# Make sure comparison doesn't forget microseconds, and isn't done
|
||||
# via comparing a float timestamp (an IEEE double doesn't have enough
|
||||
|
|
@ -1239,7 +1239,7 @@ class TestDateTime(TestDate):
|
|||
us = timedelta(microseconds=1)
|
||||
dt2 = dt1 + us
|
||||
self.assertEqual(dt2 - dt1, us)
|
||||
self.assert_(dt1 < dt2)
|
||||
self.assertTrue(dt1 < dt2)
|
||||
|
||||
def test_strftime_with_bad_tzname_replace(self):
|
||||
# verify ok if tzinfo.tzname().replace() returns a non-string
|
||||
|
|
@ -1420,28 +1420,28 @@ class TestDateTime(TestDate):
|
|||
t1 = self.theclass(*args)
|
||||
t2 = self.theclass(*args)
|
||||
self.assertEqual(t1, t2)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t1 >= t2)
|
||||
self.failUnless(not t1 != t2)
|
||||
self.failUnless(not t1 < t2)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t1 >= t2)
|
||||
self.assertTrue(not t1 != t2)
|
||||
self.assertTrue(not t1 < t2)
|
||||
self.assertTrue(not t1 > t2)
|
||||
|
||||
for i in range(len(args)):
|
||||
newargs = args[:]
|
||||
newargs[i] = args[i] + 1
|
||||
t2 = self.theclass(*newargs) # this is larger than t1
|
||||
self.failUnless(t1 < t2)
|
||||
self.failUnless(t2 > t1)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t2 >= t1)
|
||||
self.failUnless(t1 != t2)
|
||||
self.failUnless(t2 != t1)
|
||||
self.failUnless(not t1 == t2)
|
||||
self.failUnless(not t2 == t1)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.failUnless(not t2 < t1)
|
||||
self.failUnless(not t1 >= t2)
|
||||
self.failUnless(not t2 <= t1)
|
||||
self.assertTrue(t1 < t2)
|
||||
self.assertTrue(t2 > t1)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t2 >= t1)
|
||||
self.assertTrue(t1 != t2)
|
||||
self.assertTrue(t2 != t1)
|
||||
self.assertTrue(not t1 == t2)
|
||||
self.assertTrue(not t2 == t1)
|
||||
self.assertTrue(not t1 > t2)
|
||||
self.assertTrue(not t2 < t1)
|
||||
self.assertTrue(not t1 >= t2)
|
||||
self.assertTrue(not t2 <= t1)
|
||||
|
||||
|
||||
# A helper for timestamp constructor tests.
|
||||
|
|
@ -1520,7 +1520,7 @@ class TestDateTime(TestDate):
|
|||
if abs(from_timestamp - from_now) <= tolerance:
|
||||
break
|
||||
# Else try again a few times.
|
||||
self.failUnless(abs(from_timestamp - from_now) <= tolerance)
|
||||
self.assertTrue(abs(from_timestamp - from_now) <= tolerance)
|
||||
|
||||
def test_strptime(self):
|
||||
import _strptime
|
||||
|
|
@ -1689,7 +1689,7 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase):
|
|||
|
||||
# Verify t -> string -> time identity.
|
||||
s = repr(t)
|
||||
self.failUnless(s.startswith('datetime.'))
|
||||
self.assertTrue(s.startswith('datetime.'))
|
||||
s = s[9:]
|
||||
t2 = eval(s)
|
||||
self.assertEqual(t, t2)
|
||||
|
|
@ -1704,28 +1704,28 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase):
|
|||
t1 = self.theclass(*args)
|
||||
t2 = self.theclass(*args)
|
||||
self.assertEqual(t1, t2)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t1 >= t2)
|
||||
self.failUnless(not t1 != t2)
|
||||
self.failUnless(not t1 < t2)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t1 >= t2)
|
||||
self.assertTrue(not t1 != t2)
|
||||
self.assertTrue(not t1 < t2)
|
||||
self.assertTrue(not t1 > t2)
|
||||
|
||||
for i in range(len(args)):
|
||||
newargs = args[:]
|
||||
newargs[i] = args[i] + 1
|
||||
t2 = self.theclass(*newargs) # this is larger than t1
|
||||
self.failUnless(t1 < t2)
|
||||
self.failUnless(t2 > t1)
|
||||
self.failUnless(t1 <= t2)
|
||||
self.failUnless(t2 >= t1)
|
||||
self.failUnless(t1 != t2)
|
||||
self.failUnless(t2 != t1)
|
||||
self.failUnless(not t1 == t2)
|
||||
self.failUnless(not t2 == t1)
|
||||
self.failUnless(not t1 > t2)
|
||||
self.failUnless(not t2 < t1)
|
||||
self.failUnless(not t1 >= t2)
|
||||
self.failUnless(not t2 <= t1)
|
||||
self.assertTrue(t1 < t2)
|
||||
self.assertTrue(t2 > t1)
|
||||
self.assertTrue(t1 <= t2)
|
||||
self.assertTrue(t2 >= t1)
|
||||
self.assertTrue(t1 != t2)
|
||||
self.assertTrue(t2 != t1)
|
||||
self.assertTrue(not t1 == t2)
|
||||
self.assertTrue(not t2 == t1)
|
||||
self.assertTrue(not t1 > t2)
|
||||
self.assertTrue(not t2 < t1)
|
||||
self.assertTrue(not t1 >= t2)
|
||||
self.assertTrue(not t2 <= t1)
|
||||
|
||||
for badarg in OTHERSTUFF:
|
||||
self.assertEqual(t1 == badarg, False)
|
||||
|
|
@ -1876,10 +1876,10 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase):
|
|||
"%s(23, 15)" % name)
|
||||
|
||||
def test_resolution_info(self):
|
||||
self.assert_(isinstance(self.theclass.min, self.theclass))
|
||||
self.assert_(isinstance(self.theclass.max, self.theclass))
|
||||
self.assert_(isinstance(self.theclass.resolution, timedelta))
|
||||
self.assert_(self.theclass.max > self.theclass.min)
|
||||
self.assertTrue(isinstance(self.theclass.min, self.theclass))
|
||||
self.assertTrue(isinstance(self.theclass.max, self.theclass))
|
||||
self.assertTrue(isinstance(self.theclass.resolution, timedelta))
|
||||
self.assertTrue(self.theclass.max > self.theclass.min)
|
||||
|
||||
def test_pickling(self):
|
||||
args = 20, 59, 16, 64**2
|
||||
|
|
@ -1899,12 +1899,12 @@ class TestTime(HarmlessMixedComparison, unittest.TestCase):
|
|||
|
||||
def test_bool(self):
|
||||
cls = self.theclass
|
||||
self.failUnless(cls(1))
|
||||
self.failUnless(cls(0, 1))
|
||||
self.failUnless(cls(0, 0, 1))
|
||||
self.failUnless(cls(0, 0, 0, 1))
|
||||
self.failUnless(not cls(0))
|
||||
self.failUnless(not cls())
|
||||
self.assertTrue(cls(1))
|
||||
self.assertTrue(cls(0, 1))
|
||||
self.assertTrue(cls(0, 0, 1))
|
||||
self.assertTrue(cls(0, 0, 0, 1))
|
||||
self.assertTrue(not cls(0))
|
||||
self.assertTrue(not cls())
|
||||
|
||||
def test_replace(self):
|
||||
cls = self.theclass
|
||||
|
|
@ -2001,7 +2001,7 @@ class TZInfoBase:
|
|||
def utcoffset(self, dt): pass
|
||||
b = BetterTry()
|
||||
t = cls(1, 1, 1, tzinfo=b)
|
||||
self.failUnless(t.tzinfo is b)
|
||||
self.assertTrue(t.tzinfo is b)
|
||||
|
||||
def test_utc_offset_out_of_bounds(self):
|
||||
class Edgy(tzinfo):
|
||||
|
|
@ -2040,9 +2040,9 @@ class TZInfoBase:
|
|||
for t in (cls(1, 1, 1),
|
||||
cls(1, 1, 1, tzinfo=None),
|
||||
cls(1, 1, 1, tzinfo=C1())):
|
||||
self.failUnless(t.utcoffset() is None)
|
||||
self.failUnless(t.dst() is None)
|
||||
self.failUnless(t.tzname() is None)
|
||||
self.assertTrue(t.utcoffset() is None)
|
||||
self.assertTrue(t.dst() is None)
|
||||
self.assertTrue(t.tzname() is None)
|
||||
|
||||
class C3(tzinfo):
|
||||
def utcoffset(self, dt): return timedelta(minutes=-1439)
|
||||
|
|
@ -2137,7 +2137,7 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):
|
|||
self.assertEqual(t.minute, 0)
|
||||
self.assertEqual(t.second, 0)
|
||||
self.assertEqual(t.microsecond, 0)
|
||||
self.failUnless(t.tzinfo is None)
|
||||
self.assertTrue(t.tzinfo is None)
|
||||
|
||||
def test_zones(self):
|
||||
est = FixedOffset(-300, "EST", 1)
|
||||
|
|
@ -2152,25 +2152,25 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):
|
|||
self.assertEqual(t1.tzinfo, est)
|
||||
self.assertEqual(t2.tzinfo, utc)
|
||||
self.assertEqual(t3.tzinfo, met)
|
||||
self.failUnless(t4.tzinfo is None)
|
||||
self.assertTrue(t4.tzinfo is None)
|
||||
self.assertEqual(t5.tzinfo, utc)
|
||||
|
||||
self.assertEqual(t1.utcoffset(), timedelta(minutes=-300))
|
||||
self.assertEqual(t2.utcoffset(), timedelta(minutes=0))
|
||||
self.assertEqual(t3.utcoffset(), timedelta(minutes=60))
|
||||
self.failUnless(t4.utcoffset() is None)
|
||||
self.assertTrue(t4.utcoffset() is None)
|
||||
self.assertRaises(TypeError, t1.utcoffset, "no args")
|
||||
|
||||
self.assertEqual(t1.tzname(), "EST")
|
||||
self.assertEqual(t2.tzname(), "UTC")
|
||||
self.assertEqual(t3.tzname(), "MET")
|
||||
self.failUnless(t4.tzname() is None)
|
||||
self.assertTrue(t4.tzname() is None)
|
||||
self.assertRaises(TypeError, t1.tzname, "no args")
|
||||
|
||||
self.assertEqual(t1.dst(), timedelta(minutes=1))
|
||||
self.assertEqual(t2.dst(), timedelta(minutes=-2))
|
||||
self.assertEqual(t3.dst(), timedelta(minutes=3))
|
||||
self.failUnless(t4.dst() is None)
|
||||
self.assertTrue(t4.dst() is None)
|
||||
self.assertRaises(TypeError, t1.dst, "no args")
|
||||
|
||||
self.assertEqual(hash(t1), hash(t2))
|
||||
|
|
@ -2246,7 +2246,7 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):
|
|||
green = pickler.dumps(orig, proto)
|
||||
derived = unpickler.loads(green)
|
||||
self.assertEqual(orig, derived)
|
||||
self.failUnless(isinstance(derived.tzinfo, PicklableFixedOffset))
|
||||
self.assertTrue(isinstance(derived.tzinfo, PicklableFixedOffset))
|
||||
self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
|
||||
self.assertEqual(derived.tzname(), 'cookie')
|
||||
|
||||
|
|
@ -2255,20 +2255,20 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):
|
|||
cls = self.theclass
|
||||
|
||||
t = cls(0, tzinfo=FixedOffset(-300, ""))
|
||||
self.failUnless(t)
|
||||
self.assertTrue(t)
|
||||
|
||||
t = cls(5, tzinfo=FixedOffset(-300, ""))
|
||||
self.failUnless(t)
|
||||
self.assertTrue(t)
|
||||
|
||||
t = cls(5, tzinfo=FixedOffset(300, ""))
|
||||
self.failUnless(not t)
|
||||
self.assertTrue(not t)
|
||||
|
||||
t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, ""))
|
||||
self.failUnless(not t)
|
||||
self.assertTrue(not t)
|
||||
|
||||
# Mostly ensuring this doesn't overflow internally.
|
||||
t = cls(0, tzinfo=FixedOffset(23*60 + 59, ""))
|
||||
self.failUnless(t)
|
||||
self.assertTrue(t)
|
||||
|
||||
# But this should yield a value error -- the utcoffset is bogus.
|
||||
t = cls(0, tzinfo=FixedOffset(24*60, ""))
|
||||
|
|
@ -2302,13 +2302,13 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):
|
|||
# Ensure we can get rid of a tzinfo.
|
||||
self.assertEqual(base.tzname(), "+100")
|
||||
base2 = base.replace(tzinfo=None)
|
||||
self.failUnless(base2.tzinfo is None)
|
||||
self.failUnless(base2.tzname() is None)
|
||||
self.assertTrue(base2.tzinfo is None)
|
||||
self.assertTrue(base2.tzname() is None)
|
||||
|
||||
# Ensure we can add one.
|
||||
base3 = base2.replace(tzinfo=z100)
|
||||
self.assertEqual(base, base3)
|
||||
self.failUnless(base.tzinfo is base3.tzinfo)
|
||||
self.assertTrue(base.tzinfo is base3.tzinfo)
|
||||
|
||||
# Out of bounds.
|
||||
base = cls(1)
|
||||
|
|
@ -2345,7 +2345,7 @@ class TestTimeTZ(TestTime, TZInfoBase, unittest.TestCase):
|
|||
|
||||
# But if they're not identical, it isn't ignored.
|
||||
t2 = t2.replace(tzinfo=Varies())
|
||||
self.failUnless(t1 < t2) # t1's offset counter still going up
|
||||
self.assertTrue(t1 < t2) # t1's offset counter still going up
|
||||
|
||||
def test_subclass_timetz(self):
|
||||
|
||||
|
|
@ -2401,9 +2401,9 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
tzinfo=FixedOffset(-1439, ""))
|
||||
|
||||
# Make sure those compare correctly, and w/o overflow.
|
||||
self.failUnless(t1 < t2)
|
||||
self.failUnless(t1 != t2)
|
||||
self.failUnless(t2 > t1)
|
||||
self.assertTrue(t1 < t2)
|
||||
self.assertTrue(t1 != t2)
|
||||
self.assertTrue(t2 > t1)
|
||||
|
||||
self.assertEqual(t1, t1)
|
||||
self.assertEqual(t2, t2)
|
||||
|
|
@ -2415,21 +2415,21 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
|
||||
# Change t1 not to subtract a minute, and t1 should be larger.
|
||||
t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(0, ""))
|
||||
self.failUnless(t1 > t2)
|
||||
self.assertTrue(t1 > t2)
|
||||
|
||||
# Change t1 to subtract 2 minutes, and t1 should be smaller.
|
||||
t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(2, ""))
|
||||
self.failUnless(t1 < t2)
|
||||
self.assertTrue(t1 < t2)
|
||||
|
||||
# Back to the original t1, but make seconds resolve it.
|
||||
t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
|
||||
second=1)
|
||||
self.failUnless(t1 > t2)
|
||||
self.assertTrue(t1 > t2)
|
||||
|
||||
# Likewise, but make microseconds resolve it.
|
||||
t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
|
||||
microsecond=1)
|
||||
self.failUnless(t1 > t2)
|
||||
self.assertTrue(t1 > t2)
|
||||
|
||||
# Make t2 naive and it should fail.
|
||||
t2 = self.theclass.min
|
||||
|
|
@ -2473,7 +2473,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
green = pickler.dumps(orig, proto)
|
||||
derived = unpickler.loads(green)
|
||||
self.assertEqual(orig, derived)
|
||||
self.failUnless(isinstance(derived.tzinfo,
|
||||
self.assertTrue(isinstance(derived.tzinfo,
|
||||
PicklableFixedOffset))
|
||||
self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
|
||||
self.assertEqual(derived.tzname(), 'cookie')
|
||||
|
|
@ -2544,7 +2544,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
tz55 = FixedOffset(-330, "west 5:30")
|
||||
timeaware = now.time().replace(tzinfo=tz55)
|
||||
nowaware = self.theclass.combine(now.date(), timeaware)
|
||||
self.failUnless(nowaware.tzinfo is tz55)
|
||||
self.assertTrue(nowaware.tzinfo is tz55)
|
||||
self.assertEqual(nowaware.timetz(), timeaware)
|
||||
|
||||
# Can't mix aware and non-aware.
|
||||
|
|
@ -2563,15 +2563,15 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
# Adding a delta should preserve tzinfo.
|
||||
delta = timedelta(weeks=1, minutes=12, microseconds=5678)
|
||||
nowawareplus = nowaware + delta
|
||||
self.failUnless(nowaware.tzinfo is tz55)
|
||||
self.assertTrue(nowaware.tzinfo is tz55)
|
||||
nowawareplus2 = delta + nowaware
|
||||
self.failUnless(nowawareplus2.tzinfo is tz55)
|
||||
self.assertTrue(nowawareplus2.tzinfo is tz55)
|
||||
self.assertEqual(nowawareplus, nowawareplus2)
|
||||
|
||||
# that - delta should be what we started with, and that - what we
|
||||
# started with should be delta.
|
||||
diff = nowawareplus - delta
|
||||
self.failUnless(diff.tzinfo is tz55)
|
||||
self.assertTrue(diff.tzinfo is tz55)
|
||||
self.assertEqual(nowaware, diff)
|
||||
self.assertRaises(TypeError, lambda: delta - nowawareplus)
|
||||
self.assertEqual(nowawareplus - nowaware, delta)
|
||||
|
|
@ -2580,7 +2580,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
tzr = FixedOffset(random.randrange(-1439, 1440), "randomtimezone")
|
||||
# Attach it to nowawareplus.
|
||||
nowawareplus = nowawareplus.replace(tzinfo=tzr)
|
||||
self.failUnless(nowawareplus.tzinfo is tzr)
|
||||
self.assertTrue(nowawareplus.tzinfo is tzr)
|
||||
# Make sure the difference takes the timezone adjustments into account.
|
||||
got = nowaware - nowawareplus
|
||||
# Expected: (nowaware base - nowaware offset) -
|
||||
|
|
@ -2607,7 +2607,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
off42 = FixedOffset(42, "42")
|
||||
another = meth(off42)
|
||||
again = meth(tz=off42)
|
||||
self.failUnless(another.tzinfo is again.tzinfo)
|
||||
self.assertTrue(another.tzinfo is again.tzinfo)
|
||||
self.assertEqual(another.utcoffset(), timedelta(minutes=42))
|
||||
# Bad argument with and w/o naming the keyword.
|
||||
self.assertRaises(TypeError, meth, 16)
|
||||
|
|
@ -2624,7 +2624,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
utc = FixedOffset(0, "utc", 0)
|
||||
for dummy in range(3):
|
||||
now = datetime.now(weirdtz)
|
||||
self.failUnless(now.tzinfo is weirdtz)
|
||||
self.assertTrue(now.tzinfo is weirdtz)
|
||||
utcnow = datetime.utcnow().replace(tzinfo=utc)
|
||||
now2 = utcnow.astimezone(weirdtz)
|
||||
if abs(now - now2) < timedelta(seconds=30):
|
||||
|
|
@ -2645,7 +2645,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
off42 = FixedOffset(42, "42")
|
||||
another = meth(ts, off42)
|
||||
again = meth(ts, tz=off42)
|
||||
self.failUnless(another.tzinfo is again.tzinfo)
|
||||
self.assertTrue(another.tzinfo is again.tzinfo)
|
||||
self.assertEqual(another.utcoffset(), timedelta(minutes=42))
|
||||
# Bad argument with and w/o naming the keyword.
|
||||
self.assertRaises(TypeError, meth, ts, 16)
|
||||
|
|
@ -2840,13 +2840,13 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
# Ensure we can get rid of a tzinfo.
|
||||
self.assertEqual(base.tzname(), "+100")
|
||||
base2 = base.replace(tzinfo=None)
|
||||
self.failUnless(base2.tzinfo is None)
|
||||
self.failUnless(base2.tzname() is None)
|
||||
self.assertTrue(base2.tzinfo is None)
|
||||
self.assertTrue(base2.tzname() is None)
|
||||
|
||||
# Ensure we can add one.
|
||||
base3 = base2.replace(tzinfo=z100)
|
||||
self.assertEqual(base, base3)
|
||||
self.failUnless(base.tzinfo is base3.tzinfo)
|
||||
self.assertTrue(base.tzinfo is base3.tzinfo)
|
||||
|
||||
# Out of bounds.
|
||||
base = cls(2000, 2, 29)
|
||||
|
|
@ -2859,20 +2859,20 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
fm5h = FixedOffset(-timedelta(hours=5), "m300")
|
||||
|
||||
dt = self.theclass.now(tz=f44m)
|
||||
self.failUnless(dt.tzinfo is f44m)
|
||||
self.assertTrue(dt.tzinfo is f44m)
|
||||
# Replacing with degenerate tzinfo raises an exception.
|
||||
self.assertRaises(ValueError, dt.astimezone, fnone)
|
||||
# Ditto with None tz.
|
||||
self.assertRaises(TypeError, dt.astimezone, None)
|
||||
# Replacing with same tzinfo makes no change.
|
||||
x = dt.astimezone(dt.tzinfo)
|
||||
self.failUnless(x.tzinfo is f44m)
|
||||
self.assertTrue(x.tzinfo is f44m)
|
||||
self.assertEqual(x.date(), dt.date())
|
||||
self.assertEqual(x.time(), dt.time())
|
||||
|
||||
# Replacing with different tzinfo does adjust.
|
||||
got = dt.astimezone(fm5h)
|
||||
self.failUnless(got.tzinfo is fm5h)
|
||||
self.assertTrue(got.tzinfo is fm5h)
|
||||
self.assertEqual(got.utcoffset(), timedelta(hours=-5))
|
||||
expected = dt - dt.utcoffset() # in effect, convert to UTC
|
||||
expected += fm5h.utcoffset(dt) # and from there to local time
|
||||
|
|
@ -2880,7 +2880,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
self.assertEqual(got.date(), expected.date())
|
||||
self.assertEqual(got.time(), expected.time())
|
||||
self.assertEqual(got.timetz(), expected.timetz())
|
||||
self.failUnless(got.tzinfo is expected.tzinfo)
|
||||
self.assertTrue(got.tzinfo is expected.tzinfo)
|
||||
self.assertEqual(got, expected)
|
||||
|
||||
def test_aware_subtract(self):
|
||||
|
|
@ -2955,7 +2955,7 @@ class TestDateTimeTZ(TestDateTime, TZInfoBase, unittest.TestCase):
|
|||
|
||||
# But if they're not identical, it isn't ignored.
|
||||
t2 = t2.replace(tzinfo=Varies())
|
||||
self.failUnless(t1 < t2) # t1's offset counter still going up
|
||||
self.assertTrue(t1 < t2) # t1's offset counter still going up
|
||||
|
||||
def test_subclass_datetimetz(self):
|
||||
|
||||
|
|
@ -3306,10 +3306,10 @@ class Oddballs(unittest.TestCase):
|
|||
# type comparison, despite that datetime is a subclass of date.
|
||||
as_date = date.today()
|
||||
as_datetime = datetime.combine(as_date, time())
|
||||
self.assert_(as_date != as_datetime)
|
||||
self.assert_(as_datetime != as_date)
|
||||
self.assert_(not as_date == as_datetime)
|
||||
self.assert_(not as_datetime == as_date)
|
||||
self.assertTrue(as_date != as_datetime)
|
||||
self.assertTrue(as_datetime != as_date)
|
||||
self.assertTrue(not as_date == as_datetime)
|
||||
self.assertTrue(not as_datetime == as_date)
|
||||
self.assertRaises(TypeError, lambda: as_date < as_datetime)
|
||||
self.assertRaises(TypeError, lambda: as_datetime < as_date)
|
||||
self.assertRaises(TypeError, lambda: as_date <= as_datetime)
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue