Updated test assertions that have been deprecated by the move to unittest2. In summary, this means:

 assert_ -> assertTrue
 assertEquals -> assertEqual
 failUnless -> assertTrue

For full details, see http://www.voidspace.org.uk/python/articles/unittest2.shtml#deprecations

git-svn-id: http://code.djangoproject.com/svn/django/trunk@15728 bcc190cf-cafb-0310-a4f2-bffc1f526a37

7 files changed, 186 insertions, 186 deletions

diff --git a/tests/regressiontests/utils/datastructures.py b/tests/regressiontests/utils/datastructures.py
index 3c29a24a63..3d01ab8b6f 100644
--- a/tests/regressiontests/utils/datastructures.py
+++ b/tests/regressiontests/utils/datastructures.py
@@ -32,19 +32,19 @@ class SortedDictTests(DatastructuresTestCase):
         self.d2[7] = 'seven'
 
     def test_basic_methods(self):
-        self.assertEquals(self.d1.keys(), [7, 1, 9])
-        self.assertEquals(self.d1.values(), ['seven', 'one', 'nine'])
-        self.assertEquals(self.d1.items(), [(7, 'seven'), (1, 'one'), (9, 'nine')])
+        self.assertEqual(self.d1.keys(), [7, 1, 9])
+        self.assertEqual(self.d1.values(), ['seven', 'one', 'nine'])
+        self.assertEqual(self.d1.items(), [(7, 'seven'), (1, 'one'), (9, 'nine')])
 
     def test_overwrite_ordering(self):
         """ Overwriting an item keeps it's place. """
         self.d1[1] = 'ONE'
-        self.assertEquals(self.d1.values(), ['seven', 'ONE', 'nine'])
+        self.assertEqual(self.d1.values(), ['seven', 'ONE', 'nine'])
 
     def test_append_items(self):
         """ New items go to the end. """
         self.d1[0] = 'nil'
-        self.assertEquals(self.d1.keys(), [7, 1, 9, 0])
+        self.assertEqual(self.d1.keys(), [7, 1, 9, 0])
 
     def test_delete_and_insert(self):
         """
@@ -52,9 +52,9 @@ class SortedDictTests(DatastructuresTestCase):
         at the end.
         """
         del self.d2[7]
-        self.assertEquals(self.d2.keys(), [1, 9, 0])
+        self.assertEqual(self.d2.keys(), [1, 9, 0])
         self.d2[7] = 'lucky number 7'
-        self.assertEquals(self.d2.keys(), [1, 9, 0, 7])
+        self.assertEqual(self.d2.keys(), [1, 9, 0, 7])
 
     def test_change_keys(self):
         """
@@ -63,7 +63,7 @@ class SortedDictTests(DatastructuresTestCase):
         """
         k = self.d2.keys()
         k.remove(9)
-        self.assertEquals(self.d2.keys(), [1, 9, 0, 7])
+        self.assertEqual(self.d2.keys(), [1, 9, 0, 7])
 
     def test_init_keys(self):
         """
@@ -75,13 +75,13 @@ class SortedDictTests(DatastructuresTestCase):
         tuples = ((2, 'two'), (1, 'one'), (2, 'second-two'))
         d = SortedDict(tuples)
 
-        self.assertEquals(d.keys(), [2, 1])
+        self.assertEqual(d.keys(), [2, 1])
 
         real_dict = dict(tuples)
-        self.assertEquals(sorted(real_dict.values()), ['one', 'second-two'])
+        self.assertEqual(sorted(real_dict.values()), ['one', 'second-two'])
 
         # Here the order of SortedDict values *is* what we are testing
-        self.assertEquals(d.values(), ['second-two', 'one'])
+        self.assertEqual(d.values(), ['second-two', 'one'])
 
     def test_overwrite(self):
         self.d1[1] = 'not one'
@@ -90,39 +90,39 @@ class SortedDictTests(DatastructuresTestCase):
 
     def test_append(self):
         self.d1[13] = 'thirteen'
-        self.assertEquals(
+        self.assertEqual(
             repr(self.d1),
             "{7: 'seven', 1: 'one', 9: 'nine', 13: 'thirteen'}"
         )
 
     def test_pop(self):
-        self.assertEquals(self.d1.pop(1, 'missing'), 'one')
-        self.assertEquals(self.d1.pop(1, 'missing'), 'missing')
+        self.assertEqual(self.d1.pop(1, 'missing'), 'one')
+        self.assertEqual(self.d1.pop(1, 'missing'), 'missing')
 
         # We don't know which item will be popped in popitem(), so we'll
         # just check that the number of keys has decreased.
         l = len(self.d1)
         self.d1.popitem()
-        self.assertEquals(l - len(self.d1), 1)
+        self.assertEqual(l - len(self.d1), 1)
 
     def test_dict_equality(self):
         d = SortedDict((i, i) for i in xrange(3))
-        self.assertEquals(d, {0: 0, 1: 1, 2: 2})
+        self.assertEqual(d, {0: 0, 1: 1, 2: 2})
 
     def test_tuple_init(self):
         d = SortedDict(((1, "one"), (0, "zero"), (2, "two")))
-        self.assertEquals(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}")
+        self.assertEqual(repr(d), "{1: 'one', 0: 'zero', 2: 'two'}")
 
     def test_pickle(self):
-        self.assertEquals(
+        self.assertEqual(
             pickle.loads(pickle.dumps(self.d1, 2)),
             {7: 'seven', 1: 'one', 9: 'nine'}
         )
 
     def test_clear(self):
         self.d1.clear()
-        self.assertEquals(self.d1, {})
-        self.assertEquals(self.d1.keyOrder, [])
+        self.assertEqual(self.d1, {})
+        self.assertEqual(self.d1.keyOrder, [])
 
 class MergeDictTests(DatastructuresTestCase):
 
@@ -140,12 +140,12 @@ class MergeDictTests(DatastructuresTestCase):
 
         md = MergeDict(d1, d2, d3)
 
-        self.assertEquals(md['chris'], 'cool')
-        self.assertEquals(md['camri'], 'cute')
-        self.assertEquals(md['twoofme'], 'firstone')
+        self.assertEqual(md['chris'], 'cool')
+        self.assertEqual(md['camri'], 'cute')
+        self.assertEqual(md['twoofme'], 'firstone')
 
         md2 = md.copy()
-        self.assertEquals(md2['chris'], 'cool')
+        self.assertEqual(md2['chris'], 'cool')
 
     def test_mergedict_merges_multivaluedict(self):
         """ MergeDict can merge MultiValueDicts """
@@ -160,20 +160,20 @@ class MergeDictTests(DatastructuresTestCase):
 
         # Although 'key2' appears in both dictionaries,
         # only the first value is used.
-        self.assertEquals(mm.getlist('key2'), ['value2', 'value3'])
-        self.assertEquals(mm.getlist('key4'), ['value5', 'value6'])
-        self.assertEquals(mm.getlist('undefined'), [])
+        self.assertEqual(mm.getlist('key2'), ['value2', 'value3'])
+        self.assertEqual(mm.getlist('key4'), ['value5', 'value6'])
+        self.assertEqual(mm.getlist('undefined'), [])
 
-        self.assertEquals(sorted(mm.keys()), ['key1', 'key2', 'key4'])
-        self.assertEquals(len(mm.values()), 3)
+        self.assertEqual(sorted(mm.keys()), ['key1', 'key2', 'key4'])
+        self.assertEqual(len(mm.values()), 3)
 
         self.assertTrue('value1' in mm.values())
 
-        self.assertEquals(sorted(mm.items(), key=lambda k: k[0]),
+        self.assertEqual(sorted(mm.items(), key=lambda k: k[0]),
                           [('key1', 'value1'), ('key2', 'value3'),
                            ('key4', 'value6')])
 
-        self.assertEquals([(k,mm.getlist(k)) for k in sorted(mm)],
+        self.assertEqual([(k,mm.getlist(k)) for k in sorted(mm)],
                           [('key1', ['value1']),
                            ('key2', ['value2', 'value3']),
                            ('key4', ['value5', 'value6'])])
@@ -184,13 +184,13 @@ class MultiValueDictTests(DatastructuresTestCase):
         d = MultiValueDict({'name': ['Adrian', 'Simon'],
                             'position': ['Developer']})
 
-        self.assertEquals(d['name'], 'Simon')
-        self.assertEquals(d.get('name'), 'Simon')
-        self.assertEquals(d.getlist('name'), ['Adrian', 'Simon'])
-        self.assertEquals(list(d.iteritems()),
+        self.assertEqual(d['name'], 'Simon')
+        self.assertEqual(d.get('name'), 'Simon')
+        self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
+        self.assertEqual(list(d.iteritems()),
                           [('position', 'Developer'), ('name', 'Simon')])
 
-        self.assertEquals(list(d.iterlists()),
+        self.assertEqual(list(d.iterlists()),
                           [('position', ['Developer']),
                            ('name', ['Adrian', 'Simon'])])
 
@@ -202,14 +202,14 @@ class MultiValueDictTests(DatastructuresTestCase):
             ' [\'Developer\'], \'name\': [\'Adrian\', \'Simon\']}>"',
             d.__getitem__, 'lastname')
 
-        self.assertEquals(d.get('lastname'), None)
-        self.assertEquals(d.get('lastname', 'nonexistent'), 'nonexistent')
-        self.assertEquals(d.getlist('lastname'), [])
+        self.assertEqual(d.get('lastname'), None)
+        self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
+        self.assertEqual(d.getlist('lastname'), [])
 
         d.setlist('lastname', ['Holovaty', 'Willison'])
-        self.assertEquals(d.getlist('lastname'), ['Holovaty', 'Willison'])
-        self.assertEquals(d.values(), ['Developer', 'Simon', 'Willison'])
-        self.assertEquals(list(d.itervalues()),
+        self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
+        self.assertEqual(d.values(), ['Developer', 'Simon', 'Willison'])
+        self.assertEqual(list(d.itervalues()),
                           ['Developer', 'Simon', 'Willison'])
 
     def test_copy(self):
@@ -242,9 +242,9 @@ class DotExpandedDictTests(DatastructuresTestCase):
                              'person.2.firstname': ['Adrian'],
                              'person.2.lastname': ['Holovaty']})
 
-        self.assertEquals(d['person']['1']['lastname'], ['Willison'])
-        self.assertEquals(d['person']['2']['lastname'], ['Holovaty'])
-        self.assertEquals(d['person']['2']['firstname'], ['Adrian'])
+        self.assertEqual(d['person']['1']['lastname'], ['Willison'])
+        self.assertEqual(d['person']['2']['lastname'], ['Holovaty'])
+        self.assertEqual(d['person']['2']['firstname'], ['Adrian'])
 
 
 class ImmutableListTests(DatastructuresTestCase):
@@ -256,12 +256,12 @@ class ImmutableListTests(DatastructuresTestCase):
         self.assertRaisesErrorWithMessage(AttributeError,
             'ImmutableList object is immutable.', d.sort)
 
-        self.assertEquals(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)')
+        self.assertEqual(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)')
 
     def test_custom_warning(self):
         d = ImmutableList(range(10), warning="Object is immutable!")
 
-        self.assertEquals(d[1], 1)
+        self.assertEqual(d[1], 1)
 
         # AttributeError: Object is immutable!
         self.assertRaisesErrorWithMessage(AttributeError,
@@ -273,5 +273,5 @@ class DictWrapperTests(DatastructuresTestCase):
     def test_dictwrapper(self):
         f = lambda x: "*%s" % x
         d = DictWrapper({'a': 'a'}, f, 'xx_')
-        self.assertEquals("Normal: %(a)s. Modified: %(xx_a)s" % d,
+        self.assertEqual("Normal: %(a)s. Modified: %(xx_a)s" % d,
                           'Normal: a. Modified: *a')
diff --git a/tests/regressiontests/utils/dateformat.py b/tests/regressiontests/utils/dateformat.py
index e785eec724..b678fa0093 100644
--- a/tests/regressiontests/utils/dateformat.py
+++ b/tests/regressiontests/utils/dateformat.py
@@ -33,82 +33,82 @@ class DateFormatTests(unittest.TestCase):
 
     def test_date(self):
         d = date(2009, 5, 16)
-        self.assertEquals(date.fromtimestamp(int(format(d, 'U'))), d)
+        self.assertEqual(date.fromtimestamp(int(format(d, 'U'))), d)
 
     def test_naive_datetime(self):
         dt = datetime(2009, 5, 16, 5, 30, 30)
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt)
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt)
 
     def test_datetime_with_local_tzinfo(self):
         ltz = LocalTimezone(datetime.now())
         dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=ltz)
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt)
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt.replace(tzinfo=None))
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt)
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt.replace(tzinfo=None))
 
     def test_datetime_with_tzinfo(self):
         tz = FixedOffset(-510)
         ltz = LocalTimezone(datetime.now())
         dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz)
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), tz), dt)
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt)
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U'))), dt.astimezone(ltz).replace(tzinfo=None))
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), tz).utctimetuple(), dt.utctimetuple())
-        self.assertEquals(datetime.fromtimestamp(int(format(dt, 'U')), ltz).utctimetuple(), dt.utctimetuple())
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), tz), dt)
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt)
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt.astimezone(ltz).replace(tzinfo=None))
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), tz).utctimetuple(), dt.utctimetuple())
+        self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), ltz).utctimetuple(), dt.utctimetuple())
 
     def test_epoch(self):
         utc = FixedOffset(0)
         udt = datetime(1970, 1, 1, tzinfo=utc)
-        self.assertEquals(format(udt, 'U'), u'0')
+        self.assertEqual(format(udt, 'U'), u'0')
 
     def test_empty_format(self):
         my_birthday = datetime(1979, 7, 8, 22, 00)
 
-        self.assertEquals(dateformat.format(my_birthday, ''), u'')
+        self.assertEqual(dateformat.format(my_birthday, ''), u'')
 
     def test_am_pm(self):
         my_birthday = datetime(1979, 7, 8, 22, 00)
 
-        self.assertEquals(dateformat.format(my_birthday, 'a'), u'p.m.')
+        self.assertEqual(dateformat.format(my_birthday, 'a'), u'p.m.')
 
     def test_date_formats(self):
         my_birthday = datetime(1979, 7, 8, 22, 00)
         timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456)
 
-        self.assertEquals(dateformat.format(my_birthday, 'A'), u'PM')
-        self.assertEquals(dateformat.format(timestamp, 'c'), u'2008-05-19T11:45:23.123456')
-        self.assertEquals(dateformat.format(my_birthday, 'd'), u'08')
-        self.assertEquals(dateformat.format(my_birthday, 'j'), u'8')
-        self.assertEquals(dateformat.format(my_birthday, 'l'), u'Sunday')
-        self.assertEquals(dateformat.format(my_birthday, 'L'), u'False')
-        self.assertEquals(dateformat.format(my_birthday, 'm'), u'07')
-        self.assertEquals(dateformat.format(my_birthday, 'M'), u'Jul')
-        self.assertEquals(dateformat.format(my_birthday, 'b'), u'jul')
-        self.assertEquals(dateformat.format(my_birthday, 'n'), u'7')
-        self.assertEquals(dateformat.format(my_birthday, 'N'), u'July')
+        self.assertEqual(dateformat.format(my_birthday, 'A'), u'PM')
+        self.assertEqual(dateformat.format(timestamp, 'c'), u'2008-05-19T11:45:23.123456')
+        self.assertEqual(dateformat.format(my_birthday, 'd'), u'08')
+        self.assertEqual(dateformat.format(my_birthday, 'j'), u'8')
+        self.assertEqual(dateformat.format(my_birthday, 'l'), u'Sunday')
+        self.assertEqual(dateformat.format(my_birthday, 'L'), u'False')
+        self.assertEqual(dateformat.format(my_birthday, 'm'), u'07')
+        self.assertEqual(dateformat.format(my_birthday, 'M'), u'Jul')
+        self.assertEqual(dateformat.format(my_birthday, 'b'), u'jul')
+        self.assertEqual(dateformat.format(my_birthday, 'n'), u'7')
+        self.assertEqual(dateformat.format(my_birthday, 'N'), u'July')
 
     def test_time_formats(self):
         my_birthday = datetime(1979, 7, 8, 22, 00)
 
-        self.assertEquals(dateformat.format(my_birthday, 'P'), u'10 p.m.')
-        self.assertEquals(dateformat.format(my_birthday, 's'), u'00')
-        self.assertEquals(dateformat.format(my_birthday, 'S'), u'th')
-        self.assertEquals(dateformat.format(my_birthday, 't'), u'31')
-        self.assertEquals(dateformat.format(my_birthday, 'w'), u'0')
-        self.assertEquals(dateformat.format(my_birthday, 'W'), u'27')
-        self.assertEquals(dateformat.format(my_birthday, 'y'), u'79')
-        self.assertEquals(dateformat.format(my_birthday, 'Y'), u'1979')
-        self.assertEquals(dateformat.format(my_birthday, 'z'), u'189')
+        self.assertEqual(dateformat.format(my_birthday, 'P'), u'10 p.m.')
+        self.assertEqual(dateformat.format(my_birthday, 's'), u'00')
+        self.assertEqual(dateformat.format(my_birthday, 'S'), u'th')
+        self.assertEqual(dateformat.format(my_birthday, 't'), u'31')
+        self.assertEqual(dateformat.format(my_birthday, 'w'), u'0')
+        self.assertEqual(dateformat.format(my_birthday, 'W'), u'27')
+        self.assertEqual(dateformat.format(my_birthday, 'y'), u'79')
+        self.assertEqual(dateformat.format(my_birthday, 'Y'), u'1979')
+        self.assertEqual(dateformat.format(my_birthday, 'z'), u'189')
 
     def test_dateformat(self):
         my_birthday = datetime(1979, 7, 8, 22, 00)
 
-        self.assertEquals(dateformat.format(my_birthday, r'Y z \C\E\T'), u'1979 189 CET')
+        self.assertEqual(dateformat.format(my_birthday, r'Y z \C\E\T'), u'1979 189 CET')
 
-        self.assertEquals(dateformat.format(my_birthday, r'jS o\f F'), u'8th of July')
+        self.assertEqual(dateformat.format(my_birthday, r'jS o\f F'), u'8th of July')
 
     def test_futuredates(self):
         the_future = datetime(2100, 10, 25, 0, 00)
-        self.assertEquals(dateformat.format(the_future, r'Y'), u'2100')
+        self.assertEqual(dateformat.format(the_future, r'Y'), u'2100')
 
     def test_timezones(self):
         my_birthday = datetime(1979, 7, 8, 22, 00)
@@ -117,13 +117,13 @@ class DateFormatTests(unittest.TestCase):
         timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456)
 
         if self.tz_tests:
-            self.assertEquals(dateformat.format(my_birthday, 'O'), u'+0100')
-            self.assertEquals(dateformat.format(my_birthday, 'r'), u'Sun, 8 Jul 1979 22:00:00 +0100')
-            self.assertEquals(dateformat.format(my_birthday, 'T'), u'CET')
-            self.assertEquals(dateformat.format(my_birthday, 'U'), u'300315600')
-            self.assertEquals(dateformat.format(timestamp, 'u'), u'123456')
-            self.assertEquals(dateformat.format(my_birthday, 'Z'), u'3600')
-            self.assertEquals(dateformat.format(summertime, 'I'), u'1')
-            self.assertEquals(dateformat.format(summertime, 'O'), u'+0200')
-            self.assertEquals(dateformat.format(wintertime, 'I'), u'0')
-            self.assertEquals(dateformat.format(wintertime, 'O'), u'+0100')
+            self.assertEqual(dateformat.format(my_birthday, 'O'), u'+0100')
+            self.assertEqual(dateformat.format(my_birthday, 'r'), u'Sun, 8 Jul 1979 22:00:00 +0100')
+            self.assertEqual(dateformat.format(my_birthday, 'T'), u'CET')
+            self.assertEqual(dateformat.format(my_birthday, 'U'), u'300315600')
+            self.assertEqual(dateformat.format(timestamp, 'u'), u'123456')
+            self.assertEqual(dateformat.format(my_birthday, 'Z'), u'3600')
+            self.assertEqual(dateformat.format(summertime, 'I'), u'1')
+            self.assertEqual(dateformat.format(summertime, 'O'), u'+0200')
+            self.assertEqual(dateformat.format(wintertime, 'I'), u'0')
+            self.assertEqual(dateformat.format(wintertime, 'O'), u'+0100')
diff --git a/tests/regressiontests/utils/datetime_safe.py b/tests/regressiontests/utils/datetime_safe.py
index 458a6b79f8..c9c34dbf40 100644
--- a/tests/regressiontests/utils/datetime_safe.py
+++ b/tests/regressiontests/utils/datetime_safe.py
@@ -21,17 +21,17 @@ class DatetimeTests(unittest.TestCase):
         self.assertEqual(original_datetime(*self.just_safe).strftime('%Y-%m-%d'), datetime(*self.just_safe).strftime('%Y-%m-%d'))
 
     def test_safe_strftime(self):
-        self.assertEquals(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '1899-12-31 (weekday 0)')
-        self.assertEquals(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1900-01-01 (weekday 1)')
+        self.assertEqual(date(*self.just_unsafe[:3]).strftime('%Y-%m-%d (weekday %w)'), '1899-12-31 (weekday 0)')
+        self.assertEqual(date(*self.just_safe).strftime('%Y-%m-%d (weekday %w)'), '1900-01-01 (weekday 1)')
 
-        self.assertEquals(datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1899-12-31 23:59:59 (weekday 0)')
-        self.assertEquals(datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1900-01-01 00:00:00 (weekday 1)')
+        self.assertEqual(datetime(*self.just_unsafe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1899-12-31 23:59:59 (weekday 0)')
+        self.assertEqual(datetime(*self.just_safe).strftime('%Y-%m-%d %H:%M:%S (weekday %w)'), '1900-01-01 00:00:00 (weekday 1)')
 
         # %y will error before this date
-        self.assertEquals(date(*self.just_safe).strftime('%y'), '00')
-        self.assertEquals(datetime(*self.just_safe).strftime('%y'), '00')
+        self.assertEqual(date(*self.just_safe).strftime('%y'), '00')
+        self.assertEqual(datetime(*self.just_safe).strftime('%y'), '00')
 
-        self.assertEquals(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday')
+        self.assertEqual(date(1850, 8, 2).strftime("%Y/%m/%d was a %A"), '1850/08/02 was a Friday')
 
     def test_zero_padding(self):
         """
@@ -39,4 +39,4 @@ class DatetimeTests(unittest.TestCase):
 
         Check that pre-1000AD dates are padded with zeros if necessary
         """
-        self.assertEquals(date(1, 1, 1).strftime("%Y/%m/%d was a %A"), '0001/01/01 was a Monday')
+        self.assertEqual(date(1, 1, 1).strftime("%Y/%m/%d was a %A"), '0001/01/01 was a Monday')
diff --git a/tests/regressiontests/utils/simplelazyobject.py b/tests/regressiontests/utils/simplelazyobject.py
index 4a930dd69b..9eea8b5901 100644
--- a/tests/regressiontests/utils/simplelazyobject.py
+++ b/tests/regressiontests/utils/simplelazyobject.py
@@ -46,7 +46,7 @@ class TestUtilsSimpleLazyObject(unittest.TestCase):
         # For debugging, it will really confuse things if there is no clue that
         # SimpleLazyObject is actually a proxy object. So we don't
         # proxy __repr__
-        self.assert_("SimpleLazyObject" in repr(SimpleLazyObject(complex_object)))
+        self.assertTrue("SimpleLazyObject" in repr(SimpleLazyObject(complex_object)))
 
     def test_str(self):
         self.assertEqual("I am _ComplexObject('joe')", str(SimpleLazyObject(complex_object)))
diff --git a/tests/regressiontests/utils/termcolors.py b/tests/regressiontests/utils/termcolors.py
index 7efac0dc9f..23fcf557f8 100644
--- a/tests/regressiontests/utils/termcolors.py
+++ b/tests/regressiontests/utils/termcolors.py
@@ -4,145 +4,145 @@ from django.utils.termcolors import parse_color_setting, PALETTES, DEFAULT_PALET
 class TermColorTests(unittest.TestCase):
 
     def test_empty_string(self):
-        self.assertEquals(parse_color_setting(''), PALETTES[DEFAULT_PALETTE])
+        self.assertEqual(parse_color_setting(''), PALETTES[DEFAULT_PALETTE])
 
     def test_simple_palette(self):
-        self.assertEquals(parse_color_setting('light'), PALETTES[LIGHT_PALETTE])
-        self.assertEquals(parse_color_setting('dark'), PALETTES[DARK_PALETTE])
-        self.assertEquals(parse_color_setting('nocolor'), None)
+        self.assertEqual(parse_color_setting('light'), PALETTES[LIGHT_PALETTE])
+        self.assertEqual(parse_color_setting('dark'), PALETTES[DARK_PALETTE])
+        self.assertEqual(parse_color_setting('nocolor'), None)
 
     def test_fg(self):
-        self.assertEquals(parse_color_setting('error=green'),
+        self.assertEqual(parse_color_setting('error=green'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
 
     def test_fg_bg(self):
-        self.assertEquals(parse_color_setting('error=green/blue'),
+        self.assertEqual(parse_color_setting('error=green/blue'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'bg':'blue'}))
 
     def test_fg_opts(self):
-        self.assertEquals(parse_color_setting('error=green,blink'),
+        self.assertEqual(parse_color_setting('error=green,blink'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'opts': ('blink',)}))
-        self.assertEquals(parse_color_setting('error=green,bold,blink'),
+        self.assertEqual(parse_color_setting('error=green,bold,blink'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'opts': ('blink','bold')}))
 
     def test_fg_bg_opts(self):
-        self.assertEquals(parse_color_setting('error=green/blue,blink'),
+        self.assertEqual(parse_color_setting('error=green/blue,blink'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'bg':'blue', 'opts': ('blink',)}))
-        self.assertEquals(parse_color_setting('error=green/blue,bold,blink'),
+        self.assertEqual(parse_color_setting('error=green/blue,bold,blink'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'bg':'blue', 'opts': ('blink','bold')}))
 
     def test_override_palette(self):
-        self.assertEquals(parse_color_setting('light;error=green'),
+        self.assertEqual(parse_color_setting('light;error=green'),
                           dict(PALETTES[LIGHT_PALETTE],
                             ERROR={'fg':'green'}))
 
     def test_override_nocolor(self):
-        self.assertEquals(parse_color_setting('nocolor;error=green'),
+        self.assertEqual(parse_color_setting('nocolor;error=green'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg': 'green'}))
 
     def test_reverse_override(self):
-        self.assertEquals(parse_color_setting('error=green;light'), PALETTES[LIGHT_PALETTE])
+        self.assertEqual(parse_color_setting('error=green;light'), PALETTES[LIGHT_PALETTE])
 
     def test_multiple_roles(self):
-        self.assertEquals(parse_color_setting('error=green;sql_field=blue'),
+        self.assertEqual(parse_color_setting('error=green;sql_field=blue'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'},
                             SQL_FIELD={'fg':'blue'}))
 
     def test_override_with_multiple_roles(self):
-        self.assertEquals(parse_color_setting('light;error=green;sql_field=blue'),
+        self.assertEqual(parse_color_setting('light;error=green;sql_field=blue'),
                           dict(PALETTES[LIGHT_PALETTE],
                             ERROR={'fg':'green'},
                             SQL_FIELD={'fg':'blue'}))
 
     def test_empty_definition(self):
-        self.assertEquals(parse_color_setting(';'), None)
-        self.assertEquals(parse_color_setting('light;'), PALETTES[LIGHT_PALETTE])
-        self.assertEquals(parse_color_setting(';;;'), None)
+        self.assertEqual(parse_color_setting(';'), None)
+        self.assertEqual(parse_color_setting('light;'), PALETTES[LIGHT_PALETTE])
+        self.assertEqual(parse_color_setting(';;;'), None)
 
     def test_empty_options(self):
-        self.assertEquals(parse_color_setting('error=green,'),
+        self.assertEqual(parse_color_setting('error=green,'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
-        self.assertEquals(parse_color_setting('error=green,,,'),
+        self.assertEqual(parse_color_setting('error=green,,,'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
-        self.assertEquals(parse_color_setting('error=green,,blink,,'),
+        self.assertEqual(parse_color_setting('error=green,,blink,,'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'opts': ('blink',)}))
 
     def test_bad_palette(self):
-        self.assertEquals(parse_color_setting('unknown'), None)
+        self.assertEqual(parse_color_setting('unknown'), None)
 
     def test_bad_role(self):
-        self.assertEquals(parse_color_setting('unknown='), None)
-        self.assertEquals(parse_color_setting('unknown=green'), None)
-        self.assertEquals(parse_color_setting('unknown=green;sql_field=blue'),
+        self.assertEqual(parse_color_setting('unknown='), None)
+        self.assertEqual(parse_color_setting('unknown=green'), None)
+        self.assertEqual(parse_color_setting('unknown=green;sql_field=blue'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             SQL_FIELD={'fg':'blue'}))
 
     def test_bad_color(self):
-        self.assertEquals(parse_color_setting('error='), None)
-        self.assertEquals(parse_color_setting('error=;sql_field=blue'),
+        self.assertEqual(parse_color_setting('error='), None)
+        self.assertEqual(parse_color_setting('error=;sql_field=blue'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             SQL_FIELD={'fg':'blue'}))
-        self.assertEquals(parse_color_setting('error=unknown'), None)
-        self.assertEquals(parse_color_setting('error=unknown;sql_field=blue'),
+        self.assertEqual(parse_color_setting('error=unknown'), None)
+        self.assertEqual(parse_color_setting('error=unknown;sql_field=blue'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             SQL_FIELD={'fg':'blue'}))
-        self.assertEquals(parse_color_setting('error=green/unknown'),
+        self.assertEqual(parse_color_setting('error=green/unknown'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
-        self.assertEquals(parse_color_setting('error=green/blue/something'),
+        self.assertEqual(parse_color_setting('error=green/blue/something'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'bg': 'blue'}))
-        self.assertEquals(parse_color_setting('error=green/blue/something,blink'),
+        self.assertEqual(parse_color_setting('error=green/blue/something,blink'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'bg': 'blue', 'opts': ('blink',)}))
 
     def test_bad_option(self):
-        self.assertEquals(parse_color_setting('error=green,unknown'),
+        self.assertEqual(parse_color_setting('error=green,unknown'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
-        self.assertEquals(parse_color_setting('error=green,unknown,blink'),
+        self.assertEqual(parse_color_setting('error=green,unknown,blink'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'opts': ('blink',)}))
 
     def test_role_case(self):
-        self.assertEquals(parse_color_setting('ERROR=green'),
+        self.assertEqual(parse_color_setting('ERROR=green'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
-        self.assertEquals(parse_color_setting('eRrOr=green'),
+        self.assertEqual(parse_color_setting('eRrOr=green'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
 
     def test_color_case(self):
-        self.assertEquals(parse_color_setting('error=GREEN'),
+        self.assertEqual(parse_color_setting('error=GREEN'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
-        self.assertEquals(parse_color_setting('error=GREEN/BLUE'),
+        self.assertEqual(parse_color_setting('error=GREEN/BLUE'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'bg':'blue'}))
 
-        self.assertEquals(parse_color_setting('error=gReEn'),
+        self.assertEqual(parse_color_setting('error=gReEn'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green'}))
-        self.assertEquals(parse_color_setting('error=gReEn/bLuE'),
+        self.assertEqual(parse_color_setting('error=gReEn/bLuE'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'bg':'blue'}))
 
     def test_opts_case(self):
-        self.assertEquals(parse_color_setting('error=green,BLINK'),
+        self.assertEqual(parse_color_setting('error=green,BLINK'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'opts': ('blink',)}))
 
-        self.assertEquals(parse_color_setting('error=green,bLiNk'),
+        self.assertEqual(parse_color_setting('error=green,bLiNk'),
                           dict(PALETTES[NOCOLOR_PALETTE],
                             ERROR={'fg':'green', 'opts': ('blink',)}))
diff --git a/tests/regressiontests/utils/timesince.py b/tests/regressiontests/utils/timesince.py
index 774aa3f7cd..c0fe590028 100644
--- a/tests/regressiontests/utils/timesince.py
+++ b/tests/regressiontests/utils/timesince.py
@@ -19,31 +19,31 @@ class TimesinceTests(unittest.TestCase):
 
     def test_equal_datetimes(self):
         """ equal datetimes. """
-        self.assertEquals(timesince(self.t, self.t), u'0 minutes')
+        self.assertEqual(timesince(self.t, self.t), u'0 minutes')
 
     def test_ignore_microseconds_and_seconds(self):
         """ Microseconds and seconds are ignored. """
-        self.assertEquals(timesince(self.t, self.t+self.onemicrosecond),
+        self.assertEqual(timesince(self.t, self.t+self.onemicrosecond),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t+self.onesecond),
+        self.assertEqual(timesince(self.t, self.t+self.onesecond),
             u'0 minutes')
 
     def test_other_units(self):
         """ Test other units. """
-        self.assertEquals(timesince(self.t, self.t+self.oneminute),
+        self.assertEqual(timesince(self.t, self.t+self.oneminute),
             u'1 minute')
-        self.assertEquals(timesince(self.t, self.t+self.onehour), u'1 hour')
-        self.assertEquals(timesince(self.t, self.t+self.oneday), u'1 day')
-        self.assertEquals(timesince(self.t, self.t+self.oneweek), u'1 week')
-        self.assertEquals(timesince(self.t, self.t+self.onemonth),
+        self.assertEqual(timesince(self.t, self.t+self.onehour), u'1 hour')
+        self.assertEqual(timesince(self.t, self.t+self.oneday), u'1 day')
+        self.assertEqual(timesince(self.t, self.t+self.oneweek), u'1 week')
+        self.assertEqual(timesince(self.t, self.t+self.onemonth),
             u'1 month')
-        self.assertEquals(timesince(self.t, self.t+self.oneyear), u'1 year')
+        self.assertEqual(timesince(self.t, self.t+self.oneyear), u'1 year')
 
     def test_multiple_units(self):
         """ Test multiple units. """
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t+2*self.oneday+6*self.onehour), u'2 days, 6 hours')
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t+2*self.oneweek+2*self.oneday), u'2 weeks, 2 days')
 
     def test_display_first_unit(self):
@@ -51,11 +51,11 @@ class TimesinceTests(unittest.TestCase):
         If the two differing units aren't adjacent, only the first unit is
         displayed.
         """
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t+2*self.oneweek+3*self.onehour+4*self.oneminute),
             u'2 weeks')
 
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t+4*self.oneday+5*self.oneminute), u'4 days')
 
     def test_display_second_before_first(self):
@@ -63,30 +63,30 @@ class TimesinceTests(unittest.TestCase):
         When the second date occurs before the first, we should always
         get 0 minutes.
         """
-        self.assertEquals(timesince(self.t, self.t-self.onemicrosecond),
+        self.assertEqual(timesince(self.t, self.t-self.onemicrosecond),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t-self.onesecond),
+        self.assertEqual(timesince(self.t, self.t-self.onesecond),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t-self.oneminute),
+        self.assertEqual(timesince(self.t, self.t-self.oneminute),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t-self.onehour),
+        self.assertEqual(timesince(self.t, self.t-self.onehour),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t-self.oneday),
+        self.assertEqual(timesince(self.t, self.t-self.oneday),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t-self.oneweek),
+        self.assertEqual(timesince(self.t, self.t-self.oneweek),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t-self.onemonth),
+        self.assertEqual(timesince(self.t, self.t-self.onemonth),
             u'0 minutes')
-        self.assertEquals(timesince(self.t, self.t-self.oneyear),
+        self.assertEqual(timesince(self.t, self.t-self.oneyear),
             u'0 minutes')
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t-2*self.oneday-6*self.onehour), u'0 minutes')
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t-2*self.oneweek-2*self.oneday), u'0 minutes')
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t-2*self.oneweek-3*self.onehour-4*self.oneminute),
             u'0 minutes')
-        self.assertEquals(timesince(self.t,
+        self.assertEqual(timesince(self.t,
             self.t-4*self.oneday-5*self.oneminute), u'0 minutes')
 
     def test_different_timezones(self):
@@ -95,13 +95,13 @@ class TimesinceTests(unittest.TestCase):
         now_tz = datetime.datetime.now(LocalTimezone(now))
         now_tz_i = datetime.datetime.now(FixedOffset((3 * 60) + 15))
 
-        self.assertEquals(timesince(now), u'0 minutes')
-        self.assertEquals(timesince(now_tz), u'0 minutes')
-        self.assertEquals(timeuntil(now_tz, now_tz_i), u'0 minutes')
+        self.assertEqual(timesince(now), u'0 minutes')
+        self.assertEqual(timesince(now_tz), u'0 minutes')
+        self.assertEqual(timeuntil(now_tz, now_tz_i), u'0 minutes')
 
     def test_both_date_objects(self):
         """ Timesince should work with both date objects (#9672) """
         today = datetime.date.today()
-        self.assertEquals(timeuntil(today+self.oneday, today), u'1 day')
-        self.assertEquals(timeuntil(today-self.oneday, today), u'0 minutes')
-        self.assertEquals(timeuntil(today+self.oneweek, today), u'1 week')
+        self.assertEqual(timeuntil(today+self.oneday, today), u'1 day')
+        self.assertEqual(timeuntil(today-self.oneday, today), u'0 minutes')
+        self.assertEqual(timeuntil(today+self.oneweek, today), u'1 week')
diff --git a/tests/regressiontests/utils/tzinfo.py b/tests/regressiontests/utils/tzinfo.py
index edbb9a70da..f2bc0b219a 100644
--- a/tests/regressiontests/utils/tzinfo.py
+++ b/tests/regressiontests/utils/tzinfo.py
@@ -5,14 +5,14 @@ from django.utils.tzinfo import FixedOffset
 class TzinfoTests(unittest.TestCase):
 
     def test_fixedoffset(self):
-        self.assertEquals(repr(FixedOffset(0)), '+0000')
-        self.assertEquals(repr(FixedOffset(60)), '+0100')
-        self.assertEquals(repr(FixedOffset(-60)), '-0100')
-        self.assertEquals(repr(FixedOffset(280)), '+0440')
-        self.assertEquals(repr(FixedOffset(-280)), '-0440')
-        self.assertEquals(repr(FixedOffset(-78.4)), '-0118')
-        self.assertEquals(repr(FixedOffset(78.4)), '+0118')
-        self.assertEquals(repr(FixedOffset(-5.5*60)), '-0530')
-        self.assertEquals(repr(FixedOffset(5.5*60)), '+0530')
-        self.assertEquals(repr(FixedOffset(-.5*60)), '-0030')
-        self.assertEquals(repr(FixedOffset(.5*60)), '+0030')
+        self.assertEqual(repr(FixedOffset(0)), '+0000')
+        self.assertEqual(repr(FixedOffset(60)), '+0100')
+        self.assertEqual(repr(FixedOffset(-60)), '-0100')
+        self.assertEqual(repr(FixedOffset(280)), '+0440')
+        self.assertEqual(repr(FixedOffset(-280)), '-0440')
+        self.assertEqual(repr(FixedOffset(-78.4)), '-0118')
+        self.assertEqual(repr(FixedOffset(78.4)), '+0118')
+        self.assertEqual(repr(FixedOffset(-5.5*60)), '-0530')
+        self.assertEqual(repr(FixedOffset(5.5*60)), '+0530')
+        self.assertEqual(repr(FixedOffset(-.5*60)), '-0030')
+        self.assertEqual(repr(FixedOffset(.5*60)), '+0030')