Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_datetime.py

    r2 r391  
    33See http://www.zope.org/Members/fdrake/DateTimeWiki/TestCases
    44"""
    5 
    6 import os
     5from __future__ import division
     6import sys
    77import pickle
    88import cPickle
    … …  
    8080                self.__offset = offset
    8181                self.__name = name
    82         self.failUnless(issubclass(NotEnough, tzinfo))
     82        self.assertTrue(issubclass(NotEnough, tzinfo))
    8383        ne = NotEnough(3, "NotByALongShot")
    84         self.failUnless(isinstance(ne, tzinfo))
     84        self.assertIsInstance(ne, tzinfo)
    8585
    8686        dt = datetime.now()
    … …  
    9191    def test_normal(self):
    9292        fo = FixedOffset(3, "Three")
    93         self.failUnless(isinstance(fo, tzinfo))
     93        self.assertIsInstance(fo, tzinfo)
    9494        for dt in datetime.now(), None:
    9595            self.assertEqual(fo.utcoffset(dt), timedelta(minutes=3))
    … …  
    102102        # concrete subclasses can't be pickled.
    103103        orig = tzinfo.__new__(tzinfo)
    104         self.failUnless(type(orig) is tzinfo)
     104        self.assertTrue(type(orig) is tzinfo)
    105105        for pickler, unpickler, proto in pickle_choices:
    106106            green = pickler.dumps(orig, proto)
    107107            derived = unpickler.loads(green)
    108             self.failUnless(type(derived) is tzinfo)
     108            self.assertTrue(type(derived) is tzinfo)
    109109
    110110    def test_pickling_subclass(self):
    … …  
    112112        offset = timedelta(minutes=-300)
    113113        orig = PicklableFixedOffset(offset, 'cookie')
    114         self.failUnless(isinstance(orig, tzinfo))
    115         self.failUnless(type(orig) is PicklableFixedOffset)
     114        self.assertIsInstance(orig, tzinfo)
     115        self.assertTrue(type(orig) is PicklableFixedOffset)
    116116        self.assertEqual(orig.utcoffset(None), offset)
    117117        self.assertEqual(orig.tzname(None), 'cookie')
    … …  
    119119            green = pickler.dumps(orig, proto)
    120120            derived = unpickler.loads(green)
    121             self.failUnless(isinstance(derived, tzinfo))
    122             self.failUnless(type(derived) is PicklableFixedOffset)
     121            self.assertIsInstance(derived, tzinfo)
     122            self.assertTrue(type(derived) is PicklableFixedOffset)
    123123            self.assertEqual(derived.utcoffset(None), offset)
    124124            self.assertEqual(derived.tzname(None), 'cookie')
    125125
    126126#############################################################################
    127 # Base clase for testing a particular aspect of timedelta, time, date and
     127# Base class for testing a particular aspect of timedelta, time, date and
    128128# datetime comparisons.
    129129
    … …  
    137137        me = self.theclass(1, 1, 1)
    138138
    139         self.failIf(me == ())
    140         self.failUnless(me != ())
    141         self.failIf(() == me)
    142         self.failUnless(() != me)
    143 
    144         self.failUnless(me in [1, 20L, [], me])
    145         self.failIf(me not in [1, 20L, [], me])
    146 
    147         self.failUnless([] in [me, 1, 20L, []])
    148         self.failIf([] not in [me, 1, 20L, []])
     139        self.assertFalse(me == ())
     140        self.assertTrue(me != ())
     141        self.assertFalse(() == me)
     142        self.assertTrue(() != me)
     143
     144        self.assertIn(me, [1, 20L, [], me])
     145        self.assertIn([], [me, 1, 20L, []])
    149146
    150147    def test_harmful_mixed_comparison(self):
    … …  
    235232        eq(a//3600000, td(0, 0, 7*24*1000))
    236233
     234        # Issue #11576
     235        eq(td(999999999, 86399, 999999) - td(999999999, 86399, 999998),
     236           td(0, 0, 1))
     237        eq(td(999999999, 1, 1) - td(999999999, 1, 0),
     238           td(0, 0, 1))
     239
     240
    237241    def test_disallowed_computations(self):
    238242        a = timedelta(42)
    … …  
    266270        self.assertEqual(td.seconds, seconds)
    267271        self.assertEqual(td.microseconds, us)
     272
     273    def test_total_seconds(self):
     274        td = timedelta(days=365)
     275        self.assertEqual(td.total_seconds(), 31536000.0)
     276        for total_seconds in [123456.789012, -123456.789012, 0.123456, 0, 1e6]:
     277            td = timedelta(seconds=total_seconds)
     278            self.assertEqual(td.total_seconds(), total_seconds)
     279        # Issue8644: Test that td.total_seconds() has the same
     280        # accuracy as td / timedelta(seconds=1).
     281        for ms in [-1, -2, -123]:
     282            td = timedelta(microseconds=ms)
     283            self.assertEqual(td.total_seconds(),
     284                             ((24*3600*td.days + td.seconds)*10**6
     285                              + td.microseconds)/10**6)
    268286
    269287    def test_carries(self):
    … …  
    308326        t1 = timedelta(2, 3, 4)
    309327        t2 = timedelta(2, 3, 4)
    310         self.failUnless(t1 == t2)
    311         self.failUnless(t1 <= t2)
    312         self.failUnless(t1 >= t2)
    313         self.failUnless(not t1 != t2)
    314         self.failUnless(not t1 < t2)
    315         self.failUnless(not t1 > t2)
     328        self.assertTrue(t1 == t2)
     329        self.assertTrue(t1 <= t2)
     330        self.assertTrue(t1 >= t2)
     331        self.assertTrue(not t1 != t2)
     332        self.assertTrue(not t1 < t2)
     333        self.assertTrue(not t1 > t2)
    316334        self.assertEqual(cmp(t1, t2), 0)
    317335        self.assertEqual(cmp(t2, t1), 0)
    … …  
    319337        for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
    320338            t2 = timedelta(*args)   # this is larger than t1
    321             self.failUnless(t1 < t2)
    322             self.failUnless(t2 > t1)
    323             self.failUnless(t1 <= t2)
    324             self.failUnless(t2 >= t1)
    325             self.failUnless(t1 != t2)
    326             self.failUnless(t2 != t1)
    327             self.failUnless(not t1 == t2)
    328             self.failUnless(not t2 == t1)
    329             self.failUnless(not t1 > t2)
    330             self.failUnless(not t2 < t1)
    331             self.failUnless(not t1 >= t2)
    332             self.failUnless(not t2 <= t1)
     339            self.assertTrue(t1 < t2)
     340            self.assertTrue(t2 > t1)
     341            self.assertTrue(t1 <= t2)
     342            self.assertTrue(t2 >= t1)
     343            self.assertTrue(t1 != t2)
     344            self.assertTrue(t2 != t1)
     345            self.assertTrue(not t1 == t2)
     346            self.assertTrue(not t2 == t1)
     347            self.assertTrue(not t1 > t2)
     348            self.assertTrue(not t2 < t1)
     349            self.assertTrue(not t1 >= t2)
     350            self.assertTrue(not t2 <= t1)
    333351            self.assertEqual(cmp(t1, t2), -1)
    334352            self.assertEqual(cmp(t2, t1), 1)
    … …  
    378396            # Verify td -> string -> td identity.
    379397            s = repr(td)
    380             self.failUnless(s.startswith('datetime.'))
     398            self.assertTrue(s.startswith('datetime.'))
    381399            s = s[9:]
    382400            td2 = eval(s)
    … …  
    388406
    389407    def test_resolution_info(self):
    390         self.assert_(isinstance(timedelta.min, timedelta))
    391         self.assert_(isinstance(timedelta.max, timedelta))
    392         self.assert_(isinstance(timedelta.resolution, timedelta))
    393         self.assert_(timedelta.max > timedelta.min)
     408        self.assertIsInstance(timedelta.min, timedelta)
     409        self.assertIsInstance(timedelta.max, timedelta)
     410        self.assertIsInstance(timedelta.resolution, timedelta)
     411        self.assertTrue(timedelta.max > timedelta.min)
    394412        self.assertEqual(timedelta.min, timedelta(-999999999))
    395413        self.assertEqual(timedelta.max, timedelta(999999999, 24*3600-1, 1e6-1))
    … …  
    438456
    439457    def test_bool(self):
    440         self.failUnless(timedelta(1))
    441         self.failUnless(timedelta(0, 1))
    442         self.failUnless(timedelta(0, 0, 1))
    443         self.failUnless(timedelta(microseconds=1))
    444         self.failUnless(not timedelta(0))
     458        self.assertTrue(timedelta(1))
     459        self.assertTrue(timedelta(0, 1))
     460        self.assertTrue(timedelta(0, 0, 1))
     461        self.assertTrue(timedelta(microseconds=1))
     462        self.assertTrue(not timedelta(0))
    445463
    446464    def test_subclass_timedelta(self):
    … …  
    458476
    459477        t1 = T(days=1)
    460         self.assert_(type(t1) is T)
     478        self.assertTrue(type(t1) is T)
    461479        self.assertEqual(t1.as_hours(), 24)
    462480
    463481        t2 = T(days=-1, seconds=-3600)
    464         self.assert_(type(t2) is T)
     482        self.assertTrue(type(t2) is T)
    465483        self.assertEqual(t2.as_hours(), -25)
    466484
    467485        t3 = t1 + t2
    468         self.assert_(type(t3) is timedelta)
     486        self.assertTrue(type(t3) is timedelta)
    469487        t4 = T.from_td(t3)
    470         self.assert_(type(t4) is T)
     488        self.assertTrue(type(t4) is T)
    471489        self.assertEqual(t3.days, t4.days)
    472490        self.assertEqual(t3.seconds, t4.seconds)
    … …  
    531549            # Verify dt -> string -> date identity.
    532550            s = repr(dt)
    533             self.failUnless(s.startswith('datetime.'))
     551            self.assertTrue(s.startswith('datetime.'))
    534552            s = s[9:]
    535553            dt2 = eval(s)
    … …  
    710728        tiny = self.theclass.resolution
    711729
    712         dt = self.theclass.min + tiny
    713         dt -= tiny  # no problem
    714         self.assertRaises(OverflowError, dt.__sub__, tiny)
    715         self.assertRaises(OverflowError, dt.__add__, -tiny)
    716 
    717         dt = self.theclass.max - tiny
    718         dt += tiny  # no problem
    719         self.assertRaises(OverflowError, dt.__add__, tiny)
    720         self.assertRaises(OverflowError, dt.__sub__, -tiny)
     730        for delta in [tiny, timedelta(1), timedelta(2)]:
     731            dt = self.theclass.min + delta
     732            dt -= delta  # no problem
     733            self.assertRaises(OverflowError, dt.__sub__, delta)
     734            self.assertRaises(OverflowError, dt.__add__, -delta)
     735
     736            dt = self.theclass.max - delta
     737            dt += delta  # no problem
     738            self.assertRaises(OverflowError, dt.__add__, delta)
     739            self.assertRaises(OverflowError, dt.__sub__, -delta)
    721740
    722741    def test_fromtimestamp(self):
    … …  
    765784        # It worked or it didn't.  If it didn't, assume it's reason #2, and
    766785        # let the test pass if they're within half a second of each other.
    767         self.failUnless(today == todayagain or
     786        self.assertTrue(today == todayagain or
    768787                        abs(todayagain - today) < timedelta(seconds=0.5))
    769788
    … …  
    902921
    903922    def test_resolution_info(self):
    904         self.assert_(isinstance(self.theclass.min, self.theclass))
    905         self.assert_(isinstance(self.theclass.max, self.theclass))
    906         self.assert_(isinstance(self.theclass.resolution, timedelta))
    907         self.assert_(self.theclass.max > self.theclass.min)
     923        self.assertIsInstance(self.theclass.min, self.theclass)
     924        self.assertIsInstance(self.theclass.max, self.theclass)
     925        self.assertIsInstance(self.theclass.resolution, timedelta)
     926        self.assertTrue(self.theclass.max > self.theclass.min)
    908927
    909928    def test_extreme_timedelta(self):
    … …  
    953972        t1 = self.theclass(2, 3, 4)
    954973        t2 = self.theclass(2, 3, 4)
    955         self.failUnless(t1 == t2)
    956         self.failUnless(t1 <= t2)
    957         self.failUnless(t1 >= t2)
    958         self.failUnless(not t1 != t2)
    959         self.failUnless(not t1 < t2)
    960         self.failUnless(not t1 > t2)
     974        self.assertTrue(t1 == t2)
     975        self.assertTrue(t1 <= t2)
     976        self.assertTrue(t1 >= t2)
     977        self.assertTrue(not t1 != t2)
     978        self.assertTrue(not t1 < t2)
     979        self.assertTrue(not t1 > t2)
    961980        self.assertEqual(cmp(t1, t2), 0)
    962981        self.assertEqual(cmp(t2, t1), 0)
    … …  
    964983        for args in (3, 3, 3), (2, 4, 4), (2, 3, 5):
    965984            t2 = self.theclass(*args)   # this is larger than t1
    966             self.failUnless(t1 < t2)
    967             self.failUnless(t2 > t1)
    968             self.failUnless(t1 <= t2)
    969             self.failUnless(t2 >= t1)
    970             self.failUnless(t1 != t2)
    971             self.failUnless(t2 != t1)
    972             self.failUnless(not t1 == t2)
    973             self.failUnless(not t2 == t1)
    974             self.failUnless(not t1 > t2)
    975             self.failUnless(not t2 < t1)
    976             self.failUnless(not t1 >= t2)
    977             self.failUnless(not t2 <= t1)
     985            self.assertTrue(t1 < t2)
     986            self.assertTrue(t2 > t1)
     987            self.assertTrue(t1 <= t2)
     988            self.assertTrue(t2 >= t1)
     989            self.assertTrue(t1 != t2)
     990            self.assertTrue(t2 != t1)
     991            self.assertTrue(not t1 == t2)
     992            self.assertTrue(not t2 == t1)
     993            self.assertTrue(not t1 > t2)
     994            self.assertTrue(not t2 < t1)
     995            self.assertTrue(not t1 >= t2)
     996            self.assertTrue(not t2 <= t1)
    978997            self.assertEqual(cmp(t1, t2), -1)
    979998            self.assertEqual(cmp(t2, t1), 1)
    … …  
    10291048        self.assertEqual(cmp(our, their), 0)
    10301049        self.assertEqual(cmp(their, our), 0)
    1031         self.failUnless(our == their)
    1032         self.failUnless(their == our)
     1050        self.assertTrue(our == their)
     1051        self.assertTrue(their == our)
    10331052
    10341053    def test_bool(self):
    10351054        # All dates are considered true.
    1036         self.failUnless(self.theclass.min)
    1037         self.failUnless(self.theclass.max)
     1055        self.assertTrue(self.theclass.min)
     1056        self.assertTrue(self.theclass.max)
    10381057
    10391058    def test_strftime_out_of_range(self):
    … …  
    11581177            # Verify dt -> string -> datetime identity.
    11591178            s = repr(dt)
    1160             self.failUnless(s.startswith('datetime.'))
     1179            self.assertTrue(s.startswith('datetime.'))
    11611180            s = s[9:]
    11621181            dt2 = eval(s)
    … …  
    12321251        dt3 = self.theclass(2002, 3, 1, 9, 0, 0)
    12331252        self.assertEqual(dt1, dt3)
    1234         self.assert_(dt2 > dt3)
     1253        self.assertTrue(dt2 > dt3)
    12351254
    12361255        # Make sure comparison doesn't forget microseconds, and isn't done
    … …  
    12431262        dt2 = dt1 + us
    12441263        self.assertEqual(dt2 - dt1, us)
    1245         self.assert_(dt1 < dt2)
     1264        self.assertTrue(dt1 < dt2)
    12461265
    12471266    def test_strftime_with_bad_tzname_replace(self):
    … …  
    14231442        t1 = self.theclass(*args)
    14241443        t2 = self.theclass(*args)
    1425         self.failUnless(t1 == t2)
    1426         self.failUnless(t1 <= t2)
    1427         self.failUnless(t1 >= t2)
    1428         self.failUnless(not t1 != t2)
    1429         self.failUnless(not t1 < t2)
    1430         self.failUnless(not t1 > t2)
     1444        self.assertTrue(t1 == t2)
     1445        self.assertTrue(t1 <= t2)
     1446        self.assertTrue(t1 >= t2)
     1447        self.assertTrue(not t1 != t2)
     1448        self.assertTrue(not t1 < t2)
     1449        self.assertTrue(not t1 > t2)
    14311450        self.assertEqual(cmp(t1, t2), 0)
    14321451        self.assertEqual(cmp(t2, t1), 0)
    … …  
    14361455            newargs[i] = args[i] + 1
    14371456            t2 = self.theclass(*newargs)   # this is larger than t1
    1438             self.failUnless(t1 < t2)
    1439             self.failUnless(t2 > t1)
    1440             self.failUnless(t1 <= t2)
    1441             self.failUnless(t2 >= t1)
    1442             self.failUnless(t1 != t2)
    1443             self.failUnless(t2 != t1)
    1444             self.failUnless(not t1 == t2)
    1445             self.failUnless(not t2 == t1)
    1446             self.failUnless(not t1 > t2)
    1447             self.failUnless(not t2 < t1)
    1448             self.failUnless(not t1 >= t2)
    1449             self.failUnless(not t2 <= t1)
     1457            self.assertTrue(t1 < t2)
     1458            self.assertTrue(t2 > t1)
     1459            self.assertTrue(t1 <= t2)
     1460            self.assertTrue(t2 >= t1)
     1461            self.assertTrue(t1 != t2)
     1462            self.assertTrue(t2 != t1)
     1463            self.assertTrue(not t1 == t2)
     1464            self.assertTrue(not t2 == t1)
     1465            self.assertTrue(not t1 > t2)
     1466            self.assertTrue(not t2 < t1)
     1467            self.assertTrue(not t1 >= t2)
     1468            self.assertTrue(not t2 <= t1)
    14501469            self.assertEqual(cmp(t1, t2), -1)
    14511470            self.assertEqual(cmp(t2, t1), 1)
    … …  
    14801499        # Test whether fromtimestamp "rounds up" floats that are less
    14811500        # than one microsecond smaller than an integer.
    1482         self.assertEquals(self.theclass.fromtimestamp(0.9999999),
    1483                           self.theclass.fromtimestamp(1))
     1501        self.assertEqual(self.theclass.fromtimestamp(0.9999999),
     1502                         self.theclass.fromtimestamp(1))
    14841503
    14851504    def test_insane_fromtimestamp(self):
    … …  
    15001519            self.assertRaises(ValueError, self.theclass.utcfromtimestamp,
    15011520                              insane)
    1502 
     1521    @unittest.skipIf(sys.platform == "win32", "Windows doesn't accept negative timestamps")
    15031522    def test_negative_float_fromtimestamp(self):
    1504         # Windows doesn't accept negative timestamps
    1505         if os.name == "nt":
    1506             return
    15071523        # The result is tz-dependent; at least test that this doesn't
    15081524        # fail (like it did before bug 1646728 was fixed).
    15091525        self.theclass.fromtimestamp(-1.05)
    15101526
     1527    @unittest.skipIf(sys.platform == "win32", "Windows doesn't accept negative timestamps")
    15111528    def test_negative_float_utcfromtimestamp(self):
    1512         # Windows doesn't accept negative timestamps
    1513         if os.name == "nt":
    1514             return
    15151529        d = self.theclass.utcfromtimestamp(-1.05)
    1516         self.assertEquals(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))
     1530        self.assertEqual(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))
    15171531
    15181532    def test_utcnow(self):
    … …  
    15281542                break
    15291543            # Else try again a few times.
    1530         self.failUnless(abs(from_timestamp - from_now) <= tolerance)
     1544        self.assertTrue(abs(from_timestamp - from_now) <= tolerance)
    15311545
    15321546    def test_strptime(self):
    … …  
    16971711        # Verify t -> string -> time identity.
    16981712        s = repr(t)
    1699         self.failUnless(s.startswith('datetime.'))
     1713        self.assertTrue(s.startswith('datetime.'))
    17001714        s = s[9:]
    17011715        t2 = eval(s)
    … …  
    17111725        t1 = self.theclass(*args)
    17121726        t2 = self.theclass(*args)
    1713         self.failUnless(t1 == t2)
    1714         self.failUnless(t1 <= t2)
    1715         self.failUnless(t1 >= t2)
    1716         self.failUnless(not t1 != t2)
    1717         self.failUnless(not t1 < t2)
    1718         self.failUnless(not t1 > t2)
     1727        self.assertTrue(t1 == t2)
     1728        self.assertTrue(t1 <= t2)
     1729        self.assertTrue(t1 >= t2)
     1730        self.assertTrue(not t1 != t2)
     1731        self.assertTrue(not t1 < t2)
     1732        self.assertTrue(not t1 > t2)
    17191733        self.assertEqual(cmp(t1, t2), 0)
    17201734        self.assertEqual(cmp(t2, t1), 0)
    … …  
    17241738            newargs[i] = args[i] + 1
    17251739            t2 = self.theclass(*newargs)   # this is larger than t1
    1726             self.failUnless(t1 < t2)
    1727             self.failUnless(t2 > t1)
    1728             self.failUnless(t1 <= t2)
    1729             self.failUnless(t2 >= t1)
    1730             self.failUnless(t1 != t2)
    1731             self.failUnless(t2 != t1)
    1732             self.failUnless(not t1 == t2)
    1733             self.failUnless(not t2 == t1)
    1734             self.failUnless(not t1 > t2)
    1735             self.failUnless(not t2 < t1)
    1736             self.failUnless(not t1 >= t2)
    1737             self.failUnless(not t2 <= t1)
     1740            self.assertTrue(t1 < t2)
     1741            self.assertTrue(t2 > t1)
     1742            self.assertTrue(t1 <= t2)
     1743            self.assertTrue(t2 >= t1)
     1744            self.assertTrue(t1 != t2)
     1745            self.assertTrue(t2 != t1)
     1746            self.assertTrue(not t1 == t2)
     1747            self.assertTrue(not t2 == t1)
     1748            self.assertTrue(not t1 > t2)
     1749            self.assertTrue(not t2 < t1)
     1750            self.assertTrue(not t1 >= t2)
     1751            self.assertTrue(not t2 <= t1)
    17381752            self.assertEqual(cmp(t1, t2), -1)
    17391753            self.assertEqual(cmp(t2, t1), 1)
    … …  
    18881902
    18891903    def test_resolution_info(self):
    1890         self.assert_(isinstance(self.theclass.min, self.theclass))
    1891         self.assert_(isinstance(self.theclass.max, self.theclass))
    1892         self.assert_(isinstance(self.theclass.resolution, timedelta))
    1893         self.assert_(self.theclass.max > self.theclass.min)
     1904        self.assertIsInstance(self.theclass.min, self.theclass)
     1905        self.assertIsInstance(self.theclass.max, self.theclass)
     1906        self.assertIsInstance(self.theclass.resolution, timedelta)
     1907        self.assertTrue(self.theclass.max > self.theclass.min)
    18941908
    18951909    def test_pickling(self):
    … …  
    19111925    def test_bool(self):
    19121926        cls = self.theclass
    1913         self.failUnless(cls(1))
    1914         self.failUnless(cls(0, 1))
    1915         self.failUnless(cls(0, 0, 1))
    1916         self.failUnless(cls(0, 0, 0, 1))
    1917         self.failUnless(not cls(0))
    1918         self.failUnless(not cls())
     1927        self.assertTrue(cls(1))
     1928        self.assertTrue(cls(0, 1))
     1929        self.assertTrue(cls(0, 0, 1))
     1930        self.assertTrue(cls(0, 0, 0, 1))
     1931        self.assertTrue(not cls(0))
     1932        self.assertTrue(not cls())
    19191933
    19201934    def test_replace(self):
    … …  
    20132027        b = BetterTry()
    20142028        t = cls(1, 1, 1, tzinfo=b)
    2015         self.failUnless(t.tzinfo is b)
     2029        self.assertTrue(t.tzinfo is b)
    20162030
    20172031    def test_utc_offset_out_of_bounds(self):
    … …  
    20522066                  cls(1, 1, 1, tzinfo=None),
    20532067                  cls(1, 1, 1, tzinfo=C1())):
    2054             self.failUnless(t.utcoffset() is None)
    2055             self.failUnless(t.dst() is None)
    2056             self.failUnless(t.tzname() is None)
     2068            self.assertTrue(t.utcoffset() is None)
     2069            self.assertTrue(t.dst() is None)
     2070            self.assertTrue(t.tzname() is None)
    20572071
    20582072        class C3(tzinfo):
    … …  
    21482162        self.assertEqual(t.second, 0)
    21492163        self.assertEqual(t.microsecond, 0)
    2150         self.failUnless(t.tzinfo is None)
     2164        self.assertTrue(t.tzinfo is None)
    21512165
    21522166    def test_zones(self):
    … …  
    21632177        self.assertEqual(t2.tzinfo, utc)
    21642178        self.assertEqual(t3.tzinfo, met)
    2165         self.failUnless(t4.tzinfo is None)
     2179        self.assertTrue(t4.tzinfo is None)
    21662180        self.assertEqual(t5.tzinfo, utc)
    21672181
    … …  
    21692183        self.assertEqual(t2.utcoffset(), timedelta(minutes=0))
    21702184        self.assertEqual(t3.utcoffset(), timedelta(minutes=60))
    2171         self.failUnless(t4.utcoffset() is None)
     2185        self.assertTrue(t4.utcoffset() is None)
    21722186        self.assertRaises(TypeError, t1.utcoffset, "no args")
    21732187
    … …  
    21752189        self.assertEqual(t2.tzname(), "UTC")
    21762190        self.assertEqual(t3.tzname(), "MET")
    2177         self.failUnless(t4.tzname() is None)
     2191        self.assertTrue(t4.tzname() is None)
    21782192        self.assertRaises(TypeError, t1.tzname, "no args")
    21792193
    … …  
    21812195        self.assertEqual(t2.dst(), timedelta(minutes=-2))
    21822196        self.assertEqual(t3.dst(), timedelta(minutes=3))
    2183         self.failUnless(t4.dst() is None)
     2197        self.assertTrue(t4.dst() is None)
    21842198        self.assertRaises(TypeError, t1.dst, "no args")
    21852199
    … …  
    22572271            derived = unpickler.loads(green)
    22582272            self.assertEqual(orig, derived)
    2259             self.failUnless(isinstance(derived.tzinfo, PicklableFixedOffset))
     2273            self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
    22602274            self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
    22612275            self.assertEqual(derived.tzname(), 'cookie')
    … …  
    22662280
    22672281        t = cls(0, tzinfo=FixedOffset(-300, ""))
    2268         self.failUnless(t)
     2282        self.assertTrue(t)
    22692283
    22702284        t = cls(5, tzinfo=FixedOffset(-300, ""))
    2271         self.failUnless(t)
     2285        self.assertTrue(t)
    22722286
    22732287        t = cls(5, tzinfo=FixedOffset(300, ""))
    2274         self.failUnless(not t)
     2288        self.assertTrue(not t)
    22752289
    22762290        t = cls(23, 59, tzinfo=FixedOffset(23*60 + 59, ""))
    2277         self.failUnless(not t)
     2291        self.assertTrue(not t)
    22782292
    22792293        # Mostly ensuring this doesn't overflow internally.
    22802294        t = cls(0, tzinfo=FixedOffset(23*60 + 59, ""))
    2281         self.failUnless(t)
     2295        self.assertTrue(t)
    22822296
    22832297        # But this should yield a value error -- the utcoffset is bogus.
    … …  
    23132327        self.assertEqual(base.tzname(), "+100")
    23142328        base2 = base.replace(tzinfo=None)
    2315         self.failUnless(base2.tzinfo is None)
    2316         self.failUnless(base2.tzname() is None)
     2329        self.assertTrue(base2.tzinfo is None)
     2330        self.assertTrue(base2.tzname() is None)
    23172331
    23182332        # Ensure we can add one.
    23192333        base3 = base2.replace(tzinfo=z100)
    23202334        self.assertEqual(base, base3)
    2321         self.failUnless(base.tzinfo is base3.tzinfo)
     2335        self.assertTrue(base.tzinfo is base3.tzinfo)
    23222336
    23232337        # Out of bounds.
    … …  
    23562370        # But if they're not identical, it isn't ignored.
    23572371        t2 = t2.replace(tzinfo=Varies())
    2358         self.failUnless(t1 < t2)  # t1's offset counter still going up
     2372        self.assertTrue(t1 < t2)  # t1's offset counter still going up
    23592373
    23602374    def test_subclass_timetz(self):
    … …  
    24122426
    24132427        # Make sure those compare correctly, and w/o overflow.
    2414         self.failUnless(t1 < t2)
    2415         self.failUnless(t1 != t2)
    2416         self.failUnless(t2 > t1)
    2417 
    2418         self.failUnless(t1 == t1)
    2419         self.failUnless(t2 == t2)
     2428        self.assertTrue(t1 < t2)
     2429        self.assertTrue(t1 != t2)
     2430        self.assertTrue(t2 > t1)
     2431
     2432        self.assertTrue(t1 == t1)
     2433        self.assertTrue(t2 == t2)
    24202434
    24212435        # Equal afer adjustment.
    … …  
    24262440        # Change t1 not to subtract a minute, and t1 should be larger.
    24272441        t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(0, ""))
    2428         self.failUnless(t1 > t2)
     2442        self.assertTrue(t1 > t2)
    24292443
    24302444        # Change t1 to subtract 2 minutes, and t1 should be smaller.
    24312445        t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(2, ""))
    2432         self.failUnless(t1 < t2)
     2446        self.assertTrue(t1 < t2)
    24332447
    24342448        # Back to the original t1, but make seconds resolve it.
    24352449        t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
    24362450                           second=1)
    2437         self.failUnless(t1 > t2)
     2451        self.assertTrue(t1 > t2)
    24382452
    24392453        # Likewise, but make microseconds resolve it.
    24402454        t1 = self.theclass(1, 12, 31, 23, 59, tzinfo=FixedOffset(1, ""),
    24412455                           microsecond=1)
    2442         self.failUnless(t1 > t2)
     2456        self.assertTrue(t1 > t2)
    24432457
    24442458        # Make t2 naive and it should fail.
    … …  
    24842498            derived = unpickler.loads(green)
    24852499            self.assertEqual(orig, derived)
    2486             self.failUnless(isinstance(derived.tzinfo,
    2487                             PicklableFixedOffset))
     2500            self.assertIsInstance(derived.tzinfo, PicklableFixedOffset)
    24882501            self.assertEqual(derived.utcoffset(), timedelta(minutes=-300))
    24892502            self.assertEqual(derived.tzname(), 'cookie')
    … …  
    25552568        timeaware = now.time().replace(tzinfo=tz55)
    25562569        nowaware = self.theclass.combine(now.date(), timeaware)
    2557         self.failUnless(nowaware.tzinfo is tz55)
     2570        self.assertTrue(nowaware.tzinfo is tz55)
    25582571        self.assertEqual(nowaware.timetz(), timeaware)
    25592572
    … …  
    25742587        delta = timedelta(weeks=1, minutes=12, microseconds=5678)
    25752588        nowawareplus = nowaware + delta
    2576         self.failUnless(nowaware.tzinfo is tz55)
     2589        self.assertTrue(nowaware.tzinfo is tz55)
    25772590        nowawareplus2 = delta + nowaware
    2578         self.failUnless(nowawareplus2.tzinfo is tz55)
     2591        self.assertTrue(nowawareplus2.tzinfo is tz55)
    25792592        self.assertEqual(nowawareplus, nowawareplus2)
    25802593
    … …  
    25822595        # started with should be delta.
    25832596        diff = nowawareplus - delta
    2584         self.failUnless(diff.tzinfo is tz55)
     2597        self.assertTrue(diff.tzinfo is tz55)
    25852598        self.assertEqual(nowaware, diff)
    25862599        self.assertRaises(TypeError, lambda: delta - nowawareplus)
    … …  
    25912604        # Attach it to nowawareplus.
    25922605        nowawareplus = nowawareplus.replace(tzinfo=tzr)
    2593         self.failUnless(nowawareplus.tzinfo is tzr)
     2606        self.assertTrue(nowawareplus.tzinfo is tzr)
    25942607        # Make sure the difference takes the timezone adjustments into account.
    25952608        got = nowaware - nowawareplus
    … …  
    26182631        another = meth(off42)
    26192632        again = meth(tz=off42)
    2620         self.failUnless(another.tzinfo is again.tzinfo)
     2633        self.assertTrue(another.tzinfo is again.tzinfo)
    26212634        self.assertEqual(another.utcoffset(), timedelta(minutes=42))
    26222635        # Bad argument with and w/o naming the keyword.
    … …  
    26352648        for dummy in range(3):
    26362649            now = datetime.now(weirdtz)
    2637             self.failUnless(now.tzinfo is weirdtz)
     2650            self.assertTrue(now.tzinfo is weirdtz)
    26382651            utcnow = datetime.utcnow().replace(tzinfo=utc)
    26392652            now2 = utcnow.astimezone(weirdtz)
    … …  
    26562669        another = meth(ts, off42)
    26572670        again = meth(ts, tz=off42)
    2658         self.failUnless(another.tzinfo is again.tzinfo)
     2671        self.assertTrue(another.tzinfo is again.tzinfo)
    26592672        self.assertEqual(another.utcoffset(), timedelta(minutes=42))
    26602673        # Bad argument with and w/o naming the keyword.
    … …  
    28502863        self.assertEqual(base.tzname(), "+100")
    28512864        base2 = base.replace(tzinfo=None)
    2852         self.failUnless(base2.tzinfo is None)
    2853         self.failUnless(base2.tzname() is None)
     2865        self.assertTrue(base2.tzinfo is None)
     2866        self.assertTrue(base2.tzname() is None)
    28542867
    28552868        # Ensure we can add one.
    28562869        base3 = base2.replace(tzinfo=z100)
    28572870        self.assertEqual(base, base3)
    2858         self.failUnless(base.tzinfo is base3.tzinfo)
     2871        self.assertTrue(base.tzinfo is base3.tzinfo)
    28592872
    28602873        # Out of bounds.
    … …  
    28692882
    28702883        dt = self.theclass.now(tz=f44m)
    2871         self.failUnless(dt.tzinfo is f44m)
     2884        self.assertTrue(dt.tzinfo is f44m)
    28722885        # Replacing with degenerate tzinfo raises an exception.
    28732886        self.assertRaises(ValueError, dt.astimezone, fnone)
    … …  
    28762889        # Replacing with same tzinfo makes no change.
    28772890        x = dt.astimezone(dt.tzinfo)
    2878         self.failUnless(x.tzinfo is f44m)
     2891        self.assertTrue(x.tzinfo is f44m)
    28792892        self.assertEqual(x.date(), dt.date())
    28802893        self.assertEqual(x.time(), dt.time())
    … …  
    28822895        # Replacing with different tzinfo does adjust.
    28832896        got = dt.astimezone(fm5h)
    2884         self.failUnless(got.tzinfo is fm5h)
     2897        self.assertTrue(got.tzinfo is fm5h)
    28852898        self.assertEqual(got.utcoffset(), timedelta(hours=-5))
    28862899        expected = dt - dt.utcoffset()  # in effect, convert to UTC
    … …  
    28902903        self.assertEqual(got.time(), expected.time())
    28912904        self.assertEqual(got.timetz(), expected.timetz())
    2892         self.failUnless(got.tzinfo is expected.tzinfo)
     2905        self.assertTrue(got.tzinfo is expected.tzinfo)
    28932906        self.assertEqual(got, expected)
    28942907
    … …  
    29652978        # But if they're not identical, it isn't ignored.
    29662979        t2 = t2.replace(tzinfo=Varies())
    2967         self.failUnless(t1 < t2)  # t1's offset counter still going up
     2980        self.assertTrue(t1 < t2)  # t1's offset counter still going up
    29682981
    29692982    def test_subclass_datetimetz(self):
    … …  
    31033116
    31043117        # Because we have a redundant spelling when DST begins, there is
    3105         # (unforunately) an hour when DST ends that can't be spelled at all in
     3118        # (unfortunately) an hour when DST ends that can't be spelled at all in
    31063119        # local time.  When DST ends, the clock jumps from 1:59 back to 1:00
    31073120        # again.  The hour 1:MM DST has no spelling then:  1:MM is taken to be
    … …  
    33163329        as_date = date.today()
    33173330        as_datetime = datetime.combine(as_date, time())
    3318         self.assert_(as_date != as_datetime)
    3319         self.assert_(as_datetime != as_date)
    3320         self.assert_(not as_date == as_datetime)
    3321         self.assert_(not as_datetime == as_date)
     3331        self.assertTrue(as_date != as_datetime)
     3332        self.assertTrue(as_datetime != as_date)
     3333        self.assertTrue(not as_date == as_datetime)
     3334        self.assertTrue(not as_datetime == as_date)
    33223335        self.assertRaises(TypeError, lambda: as_date < as_datetime)
    33233336        self.assertRaises(TypeError, lambda: as_datetime < as_date)
    … …  
    33313344        # Neverthelss, comparison should work with the base-class (date)
    33323345        # projection if use of a date method is forced.
    3333         self.assert_(as_date.__eq__(as_datetime))
     3346        self.assertTrue(as_date.__eq__(as_datetime))
    33343347        different_day = (as_date.day + 1) % 20 + 1
    3335         self.assert_(not as_date.__eq__(as_datetime.replace(day=
     3348        self.assertTrue(not as_date.__eq__(as_datetime.replace(day=
    33363349                                                     different_day)))
    33373350
Note: See TracChangeset for help on using the changeset viewer.