convert old fail* assertions to assert*

1 files changed, 169 insertions, 169 deletions

diff --git a/Lib/test/test_datetime.py b/Lib/test/test_datetime.py
index b9d5959..8bf8420 100644
--- a/Lib/test/test_datetime.py
+++ b/Lib/test/test_datetime.py
@@ -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)