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

22 files changed, 169 insertions, 169 deletions

diff --git a/django/contrib/auth/tests/basic.py b/django/contrib/auth/tests/basic.py
index 132e7f77f9..6a3b656850 100644
--- a/django/contrib/auth/tests/basic.py
+++ b/django/contrib/auth/tests/basic.py
@@ -61,7 +61,7 @@ class BasicTestCase(TestCase):
         command_output = new_io.getvalue().strip()
         self.assertEqual(command_output, 'Superuser created successfully.')
         u = User.objects.get(username="joe")
-        self.assertEquals(u.email, 'joe@somewhere.org')
+        self.assertEqual(u.email, 'joe@somewhere.org')
 
         # created password should be unusable
         self.assertFalse(u.has_usable_password())
@@ -78,7 +78,7 @@ class BasicTestCase(TestCase):
         command_output = new_io.getvalue().strip()
         self.assertEqual(command_output, '')
         u = User.objects.get(username="joe2")
-        self.assertEquals(u.email, 'joe2@somewhere.org')
+        self.assertEqual(u.email, 'joe2@somewhere.org')
         self.assertFalse(u.has_usable_password())
 
 
@@ -90,6 +90,6 @@ class BasicTestCase(TestCase):
             stdout=new_io
         )
         u = User.objects.get(username="joe+admin@somewhere.org")
-        self.assertEquals(u.email, 'joe@somewhere.org')
+        self.assertEqual(u.email, 'joe@somewhere.org')
         self.assertFalse(u.has_usable_password())
 
diff --git a/django/contrib/auth/tests/decorators.py b/django/contrib/auth/tests/decorators.py
index 2aafeaac16..bd3f0115f5 100644
--- a/django/contrib/auth/tests/decorators.py
+++ b/django/contrib/auth/tests/decorators.py
@@ -32,7 +32,7 @@ class LoginRequiredTestCase(AuthViewsTestCase):
         """
         response = self.client.get(view_url)
         self.assertEqual(response.status_code, 302)
-        self.assert_(login_url in response['Location'])
+        self.assertTrue(login_url in response['Location'])
         self.login()
         response = self.client.get(view_url)
         self.assertEqual(response.status_code, 200)
diff --git a/django/contrib/auth/tests/remote_user.py b/django/contrib/auth/tests/remote_user.py
index 6115edcfd0..ad8733fb60 100644
--- a/django/contrib/auth/tests/remote_user.py
+++ b/django/contrib/auth/tests/remote_user.py
@@ -30,15 +30,15 @@ class RemoteUserTest(TestCase):
         num_users = User.objects.count()
 
         response = self.client.get('/remote_user/')
-        self.assert_(response.context['user'].is_anonymous())
+        self.assertTrue(response.context['user'].is_anonymous())
         self.assertEqual(User.objects.count(), num_users)
 
         response = self.client.get('/remote_user/', REMOTE_USER=None)
-        self.assert_(response.context['user'].is_anonymous())
+        self.assertTrue(response.context['user'].is_anonymous())
         self.assertEqual(User.objects.count(), num_users)
 
         response = self.client.get('/remote_user/', REMOTE_USER='')
-        self.assert_(response.context['user'].is_anonymous())
+        self.assertTrue(response.context['user'].is_anonymous())
         self.assertEqual(User.objects.count(), num_users)
 
     def test_unknown_user(self):
@@ -115,7 +115,7 @@ class RemoteUserNoCreateTest(RemoteUserTest):
     def test_unknown_user(self):
         num_users = User.objects.count()
         response = self.client.get('/remote_user/', REMOTE_USER='newuser')
-        self.assert_(response.context['user'].is_anonymous())
+        self.assertTrue(response.context['user'].is_anonymous())
         self.assertEqual(User.objects.count(), num_users)
 
 
diff --git a/django/contrib/auth/tests/views.py b/django/contrib/auth/tests/views.py
index baea1fc95f..b03489c7d2 100644
--- a/django/contrib/auth/tests/views.py
+++ b/django/contrib/auth/tests/views.py
@@ -40,53 +40,53 @@ class AuthViewsTestCase(TestCase):
             'password': password
             }
         )
-        self.assertEquals(response.status_code, 302)
-        self.assert_(response['Location'].endswith(settings.LOGIN_REDIRECT_URL))
-        self.assert_(SESSION_KEY in self.client.session)
+        self.assertEqual(response.status_code, 302)
+        self.assertTrue(response['Location'].endswith(settings.LOGIN_REDIRECT_URL))
+        self.assertTrue(SESSION_KEY in self.client.session)
 
 class PasswordResetTest(AuthViewsTestCase):
 
     def test_email_not_found(self):
         "Error is raised if the provided email address isn't currently registered"
         response = self.client.get('/password_reset/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         response = self.client.post('/password_reset/', {'email': 'not_a_real_email@email.com'})
         self.assertContains(response, "That e-mail address doesn't have an associated user account")
-        self.assertEquals(len(mail.outbox), 0)
+        self.assertEqual(len(mail.outbox), 0)
 
     def test_email_found(self):
         "Email is sent if a valid email address is provided for password reset"
         response = self.client.post('/password_reset/', {'email': 'staffmember@example.com'})
-        self.assertEquals(response.status_code, 302)
-        self.assertEquals(len(mail.outbox), 1)
-        self.assert_("http://" in mail.outbox[0].body)
-        self.assertEquals(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertTrue("http://" in mail.outbox[0].body)
+        self.assertEqual(settings.DEFAULT_FROM_EMAIL, mail.outbox[0].from_email)
 
     def test_email_found_custom_from(self):
         "Email is sent if a valid email address is provided for password reset when a custom from_email is provided."
         response = self.client.post('/password_reset_from_email/', {'email': 'staffmember@example.com'})
-        self.assertEquals(response.status_code, 302)
-        self.assertEquals(len(mail.outbox), 1)
-        self.assertEquals("staffmember@example.com", mail.outbox[0].from_email)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(len(mail.outbox), 1)
+        self.assertEqual("staffmember@example.com", mail.outbox[0].from_email)
 
     def _test_confirm_start(self):
         # Start by creating the email
         response = self.client.post('/password_reset/', {'email': 'staffmember@example.com'})
-        self.assertEquals(response.status_code, 302)
-        self.assertEquals(len(mail.outbox), 1)
+        self.assertEqual(response.status_code, 302)
+        self.assertEqual(len(mail.outbox), 1)
         return self._read_signup_email(mail.outbox[0])
 
     def _read_signup_email(self, email):
         urlmatch = re.search(r"https?://[^/]*(/.*reset/\S*)", email.body)
-        self.assert_(urlmatch is not None, "No URL found in sent email")
+        self.assertTrue(urlmatch is not None, "No URL found in sent email")
         return urlmatch.group(), urlmatch.groups()[0]
 
     def test_confirm_valid(self):
         url, path = self._test_confirm_start()
         response = self.client.get(path)
         # redirect to a 'complete' page:
-        self.assertEquals(response.status_code, 200)
-        self.assert_("Please enter your new password" in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("Please enter your new password" in response.content)
 
     def test_confirm_invalid(self):
         url, path = self._test_confirm_start()
@@ -95,20 +95,20 @@ class PasswordResetTest(AuthViewsTestCase):
         path = path[:-5] + ("0"*4) + path[-1]
 
         response = self.client.get(path)
-        self.assertEquals(response.status_code, 200)
-        self.assert_("The password reset link was invalid" in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("The password reset link was invalid" in response.content)
 
     def test_confirm_invalid_user(self):
         # Ensure that we get a 200 response for a non-existant user, not a 404
         response = self.client.get('/reset/123456-1-1/')
-        self.assertEquals(response.status_code, 200)
-        self.assert_("The password reset link was invalid" in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("The password reset link was invalid" in response.content)
 
     def test_confirm_overflow_user(self):
         # Ensure that we get a 200 response for a base36 user id that overflows int
         response = self.client.get('/reset/zzzzzzzzzzzzz-1-1/')
-        self.assertEquals(response.status_code, 200)
-        self.assert_("The password reset link was invalid" in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("The password reset link was invalid" in response.content)
 
     def test_confirm_invalid_post(self):
         # Same as test_confirm_invalid, but trying
@@ -120,29 +120,29 @@ class PasswordResetTest(AuthViewsTestCase):
                                            'new_password2':' anewpassword'})
         # Check the password has not been changed
         u = User.objects.get(email='staffmember@example.com')
-        self.assert_(not u.check_password("anewpassword"))
+        self.assertTrue(not u.check_password("anewpassword"))
 
     def test_confirm_complete(self):
         url, path = self._test_confirm_start()
         response = self.client.post(path, {'new_password1': 'anewpassword',
                                            'new_password2': 'anewpassword'})
         # It redirects us to a 'complete' page:
-        self.assertEquals(response.status_code, 302)
+        self.assertEqual(response.status_code, 302)
         # Check the password has been changed
         u = User.objects.get(email='staffmember@example.com')
-        self.assert_(u.check_password("anewpassword"))
+        self.assertTrue(u.check_password("anewpassword"))
 
         # Check we can't use the link again
         response = self.client.get(path)
-        self.assertEquals(response.status_code, 200)
-        self.assert_("The password reset link was invalid" in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("The password reset link was invalid" in response.content)
 
     def test_confirm_different_passwords(self):
         url, path = self._test_confirm_start()
         response = self.client.post(path, {'new_password1': 'anewpassword',
                                            'new_password2':' x'})
-        self.assertEquals(response.status_code, 200)
-        self.assert_("The two password fields didn't match" in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("The two password fields didn't match" in response.content)
 
 class ChangePasswordTest(AuthViewsTestCase):
 
@@ -152,8 +152,8 @@ class ChangePasswordTest(AuthViewsTestCase):
             'password': password
             }
         )
-        self.assertEquals(response.status_code, 200)
-        self.assert_("Please enter a correct username and password. Note that both fields are case-sensitive." in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("Please enter a correct username and password. Note that both fields are case-sensitive." in response.content)
 
     def logout(self):
         response = self.client.get('/logout/')
@@ -166,8 +166,8 @@ class ChangePasswordTest(AuthViewsTestCase):
             'new_password2': 'password1',
             }
         )
-        self.assertEquals(response.status_code, 200)
-        self.assert_("Your old password was entered incorrectly. Please enter it again." in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("Your old password was entered incorrectly. Please enter it again." in response.content)
 
     def test_password_change_fails_with_mismatched_passwords(self):
         self.login()
@@ -177,8 +177,8 @@ class ChangePasswordTest(AuthViewsTestCase):
             'new_password2': 'donuts',
             }
         )
-        self.assertEquals(response.status_code, 200)
-        self.assert_("The two password fields didn't match." in response.content)
+        self.assertEqual(response.status_code, 200)
+        self.assertTrue("The two password fields didn't match." in response.content)
 
     def test_password_change_succeeds(self):
         self.login()
@@ -188,8 +188,8 @@ class ChangePasswordTest(AuthViewsTestCase):
             'new_password2': 'password1',
             }
         )
-        self.assertEquals(response.status_code, 302)
-        self.assert_(response['Location'].endswith('/password_change/done/'))
+        self.assertEqual(response.status_code, 302)
+        self.assertTrue(response['Location'].endswith('/password_change/done/'))
         self.fail_login()
         self.login(password='password1')
 
@@ -197,14 +197,14 @@ class LoginTest(AuthViewsTestCase):
 
     def test_current_site_in_context_after_login(self):
         response = self.client.get(reverse('django.contrib.auth.views.login'))
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         if Site._meta.installed:
             site = Site.objects.get_current()
-            self.assertEquals(response.context['site'], site)
-            self.assertEquals(response.context['site_name'], site.name)
+            self.assertEqual(response.context['site'], site)
+            self.assertEqual(response.context['site_name'], site.name)
         else:
             self.assertIsInstance(response.context['site'], RequestSite)
-        self.assert_(isinstance(response.context['form'], AuthenticationForm), 
+        self.assertTrue(isinstance(response.context['form'], AuthenticationForm),
                      'Login form is not an AuthenticationForm')
 
     def test_security_check(self, password='password'):
@@ -226,7 +226,7 @@ class LoginTest(AuthViewsTestCase):
                 'password': password,
                 }
             )
-            self.assertEquals(response.status_code, 302)
+            self.assertEqual(response.status_code, 302)
             self.assertFalse(bad_url in response['Location'],
                              "%s should be blocked" % bad_url)
 
@@ -249,14 +249,14 @@ class LoginTest(AuthViewsTestCase):
                     'password': password,
                 }
             )
-            self.assertEquals(response.status_code, 302)
+            self.assertEqual(response.status_code, 302)
             self.assertTrue(good_url in response['Location'],
                             "%s should be allowed" % good_url)
 
 
 class LoginURLSettings(AuthViewsTestCase):
     urls = 'django.contrib.auth.tests.urls'
-    
+
     def setUp(self):
         super(LoginURLSettings, self).setUp()
         self.old_LOGIN_URL = settings.LOGIN_URL
@@ -268,7 +268,7 @@ class LoginURLSettings(AuthViewsTestCase):
     def get_login_required_url(self, login_url):
         settings.LOGIN_URL = login_url
         response = self.client.get('/login_required/')
-        self.assertEquals(response.status_code, 302)
+        self.assertEqual(response.status_code, 302)
         return response['Location']
 
     def test_standard_login_url(self):
@@ -317,14 +317,14 @@ class LogoutTest(AuthViewsTestCase):
     urls = 'django.contrib.auth.tests.urls'
 
     def confirm_logged_out(self):
-        self.assert_(SESSION_KEY not in self.client.session)
+        self.assertTrue(SESSION_KEY not in self.client.session)
 
     def test_logout_default(self):
         "Logout without next_page option renders the default template"
         self.login()
         response = self.client.get('/logout/')
-        self.assertEquals(200, response.status_code)
-        self.assert_('Logged out' in response.content)
+        self.assertEqual(200, response.status_code)
+        self.assertTrue('Logged out' in response.content)
         self.confirm_logged_out()
 
     def test_14377(self):
@@ -338,20 +338,20 @@ class LogoutTest(AuthViewsTestCase):
         self.login()
         response = self.client.get('/logout/next_page/')
         self.assertEqual(response.status_code, 302)
-        self.assert_(response['Location'].endswith('/somewhere/'))
+        self.assertTrue(response['Location'].endswith('/somewhere/'))
 
         response = self.client.get('/logout/next_page/?next=/login/')
         self.assertEqual(response.status_code, 302)
-        self.assert_(response['Location'].endswith('/login/'))
+        self.assertTrue(response['Location'].endswith('/login/'))
 
         self.confirm_logged_out()
 
-    def test_logout_with_next_page_specified(self): 
+    def test_logout_with_next_page_specified(self):
         "Logout with next_page option given redirects to specified resource"
         self.login()
         response = self.client.get('/logout/next_page/')
         self.assertEqual(response.status_code, 302)
-        self.assert_(response['Location'].endswith('/somewhere/'))
+        self.assertTrue(response['Location'].endswith('/somewhere/'))
         self.confirm_logged_out()
 
     def test_logout_with_redirect_argument(self):
@@ -359,7 +359,7 @@ class LogoutTest(AuthViewsTestCase):
         self.login()
         response = self.client.get('/logout/?next=/login/')
         self.assertEqual(response.status_code, 302)
-        self.assert_(response['Location'].endswith('/login/'))
+        self.assertTrue(response['Location'].endswith('/login/'))
         self.confirm_logged_out()
 
     def test_logout_with_custom_redirect_argument(self):
@@ -367,7 +367,7 @@ class LogoutTest(AuthViewsTestCase):
         self.login()
         response = self.client.get('/logout/custom_query/?follow=/somewhere/')
         self.assertEqual(response.status_code, 302)
-        self.assert_(response['Location'].endswith('/somewhere/'))
+        self.assertTrue(response['Location'].endswith('/somewhere/'))
         self.confirm_logged_out()
 
     def test_security_check(self, password='password'):
@@ -386,7 +386,7 @@ class LogoutTest(AuthViewsTestCase):
             }
             self.login()
             response = self.client.get(nasty_url)
-            self.assertEquals(response.status_code, 302)
+            self.assertEqual(response.status_code, 302)
             self.assertFalse(bad_url in response['Location'],
                              "%s should be blocked" % bad_url)
             self.confirm_logged_out()
@@ -407,7 +407,7 @@ class LogoutTest(AuthViewsTestCase):
             }
             self.login()
             response = self.client.get(safe_url)
-            self.assertEquals(response.status_code, 302)
+            self.assertEqual(response.status_code, 302)
             self.assertTrue(good_url in response['Location'],
                             "%s should be allowed" % good_url)
             self.confirm_logged_out()
diff --git a/django/contrib/flatpages/tests/csrf.py b/django/contrib/flatpages/tests/csrf.py
index 36b915317f..969ae8d7e9 100644
--- a/django/contrib/flatpages/tests/csrf.py
+++ b/django/contrib/flatpages/tests/csrf.py
@@ -34,13 +34,13 @@ class FlatpageCSRFTests(TestCase):
     def test_view_flatpage(self):
         "A flatpage can be served through a view, even when the middleware is in use"
         response = self.client.get('/flatpage_root/flatpage/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_view_non_existent_flatpage(self):
         "A non-existent flatpage raises 404 when served through a view, even when the middleware is in use"
         response = self.client.get('/flatpage_root/no_such_flatpage/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
 
     def test_view_authenticated_flatpage(self):
         "A flatpage served through a view can require authentication"
@@ -49,31 +49,31 @@ class FlatpageCSRFTests(TestCase):
         User.objects.create_user('testuser', 'test@example.com', 's3krit')
         self.client.login(username='testuser',password='s3krit')
         response = self.client.get('/flatpage_root/sekrit/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
 
     def test_fallback_flatpage(self):
         "A flatpage can be served by the fallback middlware"
         response = self.client.get('/flatpage/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_fallback_non_existent_flatpage(self):
         "A non-existent flatpage raises a 404 when served by the fallback middlware"
         response = self.client.get('/no_such_flatpage/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
 
     def test_post_view_flatpage(self):
         "POSTing to a flatpage served through a view will raise a CSRF error if no token is provided (Refs #14156)"
         response = self.client.post('/flatpage_root/flatpage/')
-        self.assertEquals(response.status_code, 403)
+        self.assertEqual(response.status_code, 403)
 
     def test_post_fallback_flatpage(self):
         "POSTing to a flatpage served by the middleware will raise a CSRF error if no token is provided (Refs #14156)"
         response = self.client.post('/flatpage/')
-        self.assertEquals(response.status_code, 403)
+        self.assertEqual(response.status_code, 403)
 
     def test_post_unknown_page(self):
         "POSTing to an unknown page isn't caught as a 403 CSRF error"
         response = self.client.post('/no_such_page/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
diff --git a/django/contrib/flatpages/tests/middleware.py b/django/contrib/flatpages/tests/middleware.py
index b971aab458..e01ca33d6d 100644
--- a/django/contrib/flatpages/tests/middleware.py
+++ b/django/contrib/flatpages/tests/middleware.py
@@ -30,13 +30,13 @@ class FlatpageMiddlewareTests(TestCase):
     def test_view_flatpage(self):
         "A flatpage can be served through a view, even when the middleware is in use"
         response = self.client.get('/flatpage_root/flatpage/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_view_non_existent_flatpage(self):
         "A non-existent flatpage raises 404 when served through a view, even when the middleware is in use"
         response = self.client.get('/flatpage_root/no_such_flatpage/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
 
     def test_view_authenticated_flatpage(self):
         "A flatpage served through a view can require authentication"
@@ -45,19 +45,19 @@ class FlatpageMiddlewareTests(TestCase):
         User.objects.create_user('testuser', 'test@example.com', 's3krit')
         self.client.login(username='testuser',password='s3krit')
         response = self.client.get('/flatpage_root/sekrit/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
 
     def test_fallback_flatpage(self):
         "A flatpage can be served by the fallback middlware"
         response = self.client.get('/flatpage/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_fallback_non_existent_flatpage(self):
         "A non-existent flatpage raises a 404 when served by the fallback middlware"
         response = self.client.get('/no_such_flatpage/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
 
     def test_fallback_authenticated_flatpage(self):
         "A flatpage served by the middleware can require authentication"
@@ -66,5 +66,5 @@ class FlatpageMiddlewareTests(TestCase):
         User.objects.create_user('testuser', 'test@example.com', 's3krit')
         self.client.login(username='testuser',password='s3krit')
         response = self.client.get('/sekrit/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
diff --git a/django/contrib/flatpages/tests/templatetags.py b/django/contrib/flatpages/tests/templatetags.py
index 9f42381c29..282041cee9 100644
--- a/django/contrib/flatpages/tests/templatetags.py
+++ b/django/contrib/flatpages/tests/templatetags.py
@@ -35,7 +35,7 @@ class FlatpageTemplateTagTests(TestCase):
                 "{{ page.title }},"
                 "{% endfor %}"
             ).render(Context())
-        self.assertEquals(out, "A Flatpage,A Nested Flatpage,")
+        self.assertEqual(out, "A Flatpage,A Nested Flatpage,")
 
     def test_get_flatpages_tag_for_anon_user(self):
         "The flatpage template tag retrives unregistered flatpages for an anonymous user"
@@ -48,7 +48,7 @@ class FlatpageTemplateTagTests(TestCase):
             ).render(Context({
                 'anonuser': AnonymousUser()
             }))
-        self.assertEquals(out, "A Flatpage,A Nested Flatpage,")
+        self.assertEqual(out, "A Flatpage,A Nested Flatpage,")
 
     def test_get_flatpages_tag_for_user(self):
         "The flatpage template tag retrives all flatpages for an authenticated user"
@@ -61,7 +61,7 @@ class FlatpageTemplateTagTests(TestCase):
             ).render(Context({
                 'me': self.me
             }))
-        self.assertEquals(out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage,")
+        self.assertEqual(out, "A Flatpage,A Nested Flatpage,Sekrit Nested Flatpage,Sekrit Flatpage,")
 
     def test_get_flatpages_with_prefix(self):
         "The flatpage template tag retrives unregistered prefixed flatpages by default"
@@ -72,7 +72,7 @@ class FlatpageTemplateTagTests(TestCase):
                 "{{ page.title }},"
                 "{% endfor %}"
             ).render(Context())
-        self.assertEquals(out, "A Nested Flatpage,")
+        self.assertEqual(out, "A Nested Flatpage,")
 
     def test_get_flatpages_with_prefix_for_anon_user(self):
         "The flatpage template tag retrives unregistered prefixed flatpages for an anonymous user"
@@ -85,7 +85,7 @@ class FlatpageTemplateTagTests(TestCase):
             ).render(Context({
                 'anonuser': AnonymousUser()
             }))
-        self.assertEquals(out, "A Nested Flatpage,")
+        self.assertEqual(out, "A Nested Flatpage,")
 
     def test_get_flatpages_with_prefix_for_user(self):
         "The flatpage template tag retrive prefixed flatpages for an authenticated user"
@@ -98,7 +98,7 @@ class FlatpageTemplateTagTests(TestCase):
             ).render(Context({
                 'me': self.me
             }))
-        self.assertEquals(out, "A Nested Flatpage,Sekrit Nested Flatpage,")
+        self.assertEqual(out, "A Nested Flatpage,Sekrit Nested Flatpage,")
 
     def test_get_flatpages_with_variable_prefix(self):
         "The prefix for the flatpage template tag can be a template variable"
@@ -111,7 +111,7 @@ class FlatpageTemplateTagTests(TestCase):
             ).render(Context({
                 'location_prefix': '/location/'
             }))
-        self.assertEquals(out, "A Nested Flatpage,")
+        self.assertEqual(out, "A Nested Flatpage,")
 
     def test_parsing_errors(self):
         "There are various ways that the flatpages template tag won't parse"
diff --git a/django/contrib/flatpages/tests/views.py b/django/contrib/flatpages/tests/views.py
index 4a54e5697e..a8853bc883 100644
--- a/django/contrib/flatpages/tests/views.py
+++ b/django/contrib/flatpages/tests/views.py
@@ -31,13 +31,13 @@ class FlatpageViewTests(TestCase):
     def test_view_flatpage(self):
         "A flatpage can be served through a view"
         response = self.client.get('/flatpage_root/flatpage/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it flat!</p>")
 
     def test_view_non_existent_flatpage(self):
         "A non-existent flatpage raises 404 when served through a view"
         response = self.client.get('/flatpage_root/no_such_flatpage/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
 
     def test_view_authenticated_flatpage(self):
         "A flatpage served through a view can require authentication"
@@ -46,18 +46,18 @@ class FlatpageViewTests(TestCase):
         User.objects.create_user('testuser', 'test@example.com', 's3krit')
         self.client.login(username='testuser',password='s3krit')
         response = self.client.get('/flatpage_root/sekrit/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it sekrit!</p>")
 
     def test_fallback_flatpage(self):
         "A fallback flatpage won't be served if the middleware is disabled"
         response = self.client.get('/flatpage/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
 
     def test_fallback_non_existent_flatpage(self):
         "A non-existent flatpage won't be served if the fallback middlware is disabled"
         response = self.client.get('/no_such_flatpage/')
-        self.assertEquals(response.status_code, 404)
+        self.assertEqual(response.status_code, 404)
 
     def test_view_flatpage_special_chars(self):
         "A flatpage with special chars in the URL can be served through a view"
@@ -71,5 +71,5 @@ class FlatpageViewTests(TestCase):
         fp.sites.add(1)
 
         response = self.client.get('/flatpage_root/some.very_special~chars-here/')
-        self.assertEquals(response.status_code, 200)
+        self.assertEqual(response.status_code, 200)
         self.assertContains(response, "<p>Isn't it special!</p>")
diff --git a/django/contrib/formtools/tests/__init__.py b/django/contrib/formtools/tests/__init__.py
index 4ad039a537..cc38546866 100644
--- a/django/contrib/formtools/tests/__init__.py
+++ b/django/contrib/formtools/tests/__init__.py
@@ -65,8 +65,8 @@ class PreviewTests(TestCase):
         response = self.client.get('/test1/')
         stage = self.input % 1
         self.assertContains(response, stage, 1)
-        self.assertEquals(response.context['custom_context'], True)
-        self.assertEquals(response.context['form'].initial, {'field1': 'Works!'})
+        self.assertEqual(response.context['custom_context'], True)
+        self.assertEqual(response.context['form'].initial, {'field1': 'Works!'})
 
     def test_form_preview(self):
         """
@@ -291,14 +291,14 @@ class WizardTests(TestCase):
         step should be zero for the first form
         """
         response = self.client.get('/wizard/')
-        self.assertEquals(0, response.context['step0'])
+        self.assertEqual(0, response.context['step0'])
 
     def test_step_increments(self):
         """
         step should be incremented when we go to the next page
         """
         response = self.client.post('/wizard/', {"0-field":"test", "wizard_step":"0"})
-        self.assertEquals(1, response.context['step0'])
+        self.assertEqual(1, response.context['step0'])
 
     def test_bad_hash(self):
         """
@@ -308,7 +308,7 @@ class WizardTests(TestCase):
                                     {"0-field":"test",
                                      "1-field":"test2",
                                      "wizard_step": "1"})
-        self.assertEquals(0, response.context['step0'])
+        self.assertEqual(0, response.context['step0'])
 
     def test_good_hash_django12(self):
         """
@@ -322,7 +322,7 @@ class WizardTests(TestCase):
                 "hash_0": "2fdbefd4c0cad51509478fbacddf8b13",
                 "wizard_step": "1"}
         response = self.client.post('/wizard/', data)
-        self.assertEquals(2, response.context['step0'])
+        self.assertEqual(2, response.context['step0'])
 
     def test_good_hash_django12_subclass(self):
         """
@@ -337,7 +337,7 @@ class WizardTests(TestCase):
                 "hash_0": "2fdbefd4c0cad51509478fbacddf8b13",
                 "wizard_step": "1"}
         response = self.client.post('/wizard2/', data)
-        self.assertEquals(0, response.context['step0'])
+        self.assertEqual(0, response.context['step0'])
 
     def test_good_hash_current(self):
         """
@@ -349,7 +349,7 @@ class WizardTests(TestCase):
                 "hash_0": "7e9cea465f6a10a6fb47fcea65cb9a76350c9a5c",
                 "wizard_step": "1"}
         response = self.client.post('/wizard/', data)
-        self.assertEquals(2, response.context['step0'])
+        self.assertEqual(2, response.context['step0'])
 
     def test_14498(self):
         """
diff --git a/django/contrib/gis/gdal/tests/test_geom.py b/django/contrib/gis/gdal/tests/test_geom.py
index 1a1f2b9f34..18ee21ce95 100644
--- a/django/contrib/gis/gdal/tests/test_geom.py
+++ b/django/contrib/gis/gdal/tests/test_geom.py
@@ -49,8 +49,8 @@ class OGRGeomTest(unittest.TestCase, TestDataMixin):
     def test00b_geomtype_25d(self):
         "Testing OGRGeomType object with 25D types."
         wkb25bit = OGRGeomType.wkb25bit
-        self.failUnless(OGRGeomType(wkb25bit + 1) == 'Point25D')
-        self.failUnless(OGRGeomType('MultiLineString25D') == (5 + wkb25bit))
+        self.assertTrue(OGRGeomType(wkb25bit + 1) == 'Point25D')
+        self.assertTrue(OGRGeomType('MultiLineString25D') == (5 + wkb25bit))
         self.assertEqual('GeometryCollectionField', OGRGeomType('GeometryCollection25D').django)
 
     def test01a_wkt(self):
diff --git a/django/contrib/gis/geos/tests/test_geos.py b/django/contrib/gis/geos/tests/test_geos.py
index cc54becd3f..8342b580ed 100644
--- a/django/contrib/gis/geos/tests/test_geos.py
+++ b/django/contrib/gis/geos/tests/test_geos.py
@@ -867,7 +867,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
             g1 = g.transform(4326, clone=True)
             self.assertEqual(g1.tuple, g.tuple)
             self.assertEqual(g1.srid, 4326)
-            self.assert_(g1 is not g, "Clone didn't happen")
+            self.assertTrue(g1 is not g, "Clone didn't happen")
 
         old_has_gdal = gdal.HAS_GDAL
         try:
@@ -883,7 +883,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
             g1 = g.transform(4326, clone=True)
             self.assertEqual(g1.tuple, g.tuple)
             self.assertEqual(g1.srid, 4326)
-            self.assert_(g1 is not g, "Clone didn't happen")
+            self.assertTrue(g1 is not g, "Clone didn't happen")
         finally:
             gdal.HAS_GDAL = old_has_gdal
 
@@ -907,7 +907,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
 
             g = GEOSGeometry('POINT (-104.609 38.255)', srid=None)
             g1 = g.transform(2774, clone=True)
-            self.assert_(g1 is None)
+            self.assertTrue(g1 is None)
 
             g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1)
             g.transform(2774)
@@ -916,7 +916,7 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
 
             g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1)
             g1 = g.transform(2774, clone=True)
-            self.assert_(g1 is None)
+            self.assertTrue(g1 is None)
 
         finally:
             warnings.simplefilter('default', UserWarning)
@@ -1032,17 +1032,17 @@ class GEOSTest(unittest.TestCase, TestDataMixin):
         if not GEOS_PREPARE: return
 
         g = GEOSGeometry("POINT(0 0)")
-        self.assert_(g.valid)
-        self.assert_(isinstance(g.valid_reason, basestring))
+        self.assertTrue(g.valid)
+        self.assertTrue(isinstance(g.valid_reason, basestring))
         self.assertEqual(g.valid_reason, "Valid Geometry")
 
         print "\nBEGIN - expecting GEOS_NOTICE; safe to ignore.\n"
 
         g = GEOSGeometry("LINESTRING(0 0, 0 0)")
 
-        self.assert_(not g.valid)
-        self.assert_(isinstance(g.valid_reason, basestring))
-        self.assert_(g.valid_reason.startswith("Too few points in geometry component"))
+        self.assertTrue(not g.valid)
+        self.assertTrue(isinstance(g.valid_reason, basestring))
+        self.assertTrue(g.valid_reason.startswith("Too few points in geometry component"))
 
         print "\nEND - expecting GEOS_NOTICE; safe to ignore.\n"
 
diff --git a/django/contrib/gis/geos/tests/test_mutable_list.py b/django/contrib/gis/geos/tests/test_mutable_list.py
index 7fb0fce5ea..3e63a25e95 100644
--- a/django/contrib/gis/geos/tests/test_mutable_list.py
+++ b/django/contrib/gis/geos/tests/test_mutable_list.py
@@ -362,26 +362,26 @@ class ListMixinTest(unittest.TestCase):
 
         pl, ul = self.lists_of_len()
         self.assertEqual(pl, ul, 'cmp for equal')
-        self.assert_(pl >= ul, 'cmp for gte self')
-        self.assert_(pl <= ul, 'cmp for lte self')
-        self.assert_(ul >= pl, 'cmp for self gte')
-        self.assert_(ul <= pl, 'cmp for self lte')
-
-        self.assert_(pl + [5] > ul, 'cmp')
-        self.assert_(pl + [5] >= ul, 'cmp')
-        self.assert_(pl < ul + [2], 'cmp')
-        self.assert_(pl <= ul + [2], 'cmp')
-        self.assert_(ul + [5] > pl, 'cmp')
-        self.assert_(ul + [5] >= pl, 'cmp')
-        self.assert_(ul < pl + [2], 'cmp')
-        self.assert_(ul <= pl + [2], 'cmp')
+        self.assertTrue(pl >= ul, 'cmp for gte self')
+        self.assertTrue(pl <= ul, 'cmp for lte self')
+        self.assertTrue(ul >= pl, 'cmp for self gte')
+        self.assertTrue(ul <= pl, 'cmp for self lte')
+
+        self.assertTrue(pl + [5] > ul, 'cmp')
+        self.assertTrue(pl + [5] >= ul, 'cmp')
+        self.assertTrue(pl < ul + [2], 'cmp')
+        self.assertTrue(pl <= ul + [2], 'cmp')
+        self.assertTrue(ul + [5] > pl, 'cmp')
+        self.assertTrue(ul + [5] >= pl, 'cmp')
+        self.assertTrue(ul < pl + [2], 'cmp')
+        self.assertTrue(ul <= pl + [2], 'cmp')
 
         pl[1] = 20
-        self.assert_(pl > ul, 'cmp for gt self')
-        self.assert_(ul < pl, 'cmp for self lt')
+        self.assertTrue(pl > ul, 'cmp for gt self')
+        self.assertTrue(ul < pl, 'cmp for self lt')
         pl[1] = -20
-        self.assert_(pl < ul, 'cmp for lt self')
-        self.assert_(pl < ul, 'cmp for lt self')
+        self.assertTrue(pl < ul, 'cmp for lt self')
+        self.assertTrue(pl < ul, 'cmp for lt self')
 
 class ListMixinTestSingle(ListMixinTest):
     listType = UserListB
diff --git a/django/contrib/gis/tests/geo3d/tests.py b/django/contrib/gis/tests/geo3d/tests.py
index f57445c4eb..324002e1d7 100644
--- a/django/contrib/gis/tests/geo3d/tests.py
+++ b/django/contrib/gis/tests/geo3d/tests.py
@@ -72,7 +72,7 @@ class Geo3DTest(TestCase):
             pnt = Point(x, y, z, srid=4326)
             City3D.objects.create(name=name, point=pnt)
             city = City3D.objects.get(name=name)
-            self.failUnless(city.point.hasz)
+            self.assertTrue(city.point.hasz)
             self.assertEqual(z, city.point.z)
 
         # Interstate (2D / 3D and Geographic/Projected variants)
@@ -93,7 +93,7 @@ class Geo3DTest(TestCase):
             interstate = Interstate3D.objects.get(name=name)
             interstate_proj = InterstateProj3D.objects.get(name=name)
             for i in [interstate, interstate_proj]:
-                self.failUnless(i.line.hasz)
+                self.assertTrue(i.line.hasz)
                 self.assertEqual(exp_z, tuple(i.line.z))
 
         # Creating 3D Polygon.
@@ -101,7 +101,7 @@ class Geo3DTest(TestCase):
         Polygon2D.objects.create(name='2D BBox', poly=bbox2d)
         Polygon3D.objects.create(name='3D BBox', poly=bbox3d)
         p3d = Polygon3D.objects.get(name='3D BBox')
-        self.failUnless(p3d.poly.hasz)
+        self.assertTrue(p3d.poly.hasz)
         self.assertEqual(bbox3d, p3d.poly)
 
     def test01a_3d_layermapping(self):
@@ -138,7 +138,7 @@ class Geo3DTest(TestCase):
         # KML should be 3D.
         # `SELECT ST_AsKML(point, 6) FROM geo3d_city3d WHERE name = 'Houston';`
         ref_kml_regex = re.compile(r'^<Point><coordinates>-95.363\d+,29.763\d+,18</coordinates></Point>$')
-        self.failUnless(ref_kml_regex.match(h.kml))
+        self.assertTrue(ref_kml_regex.match(h.kml))
 
     def test02b_geojson(self):
         "Test GeoQuerySet.geojson() with Z values."
@@ -146,7 +146,7 @@ class Geo3DTest(TestCase):
         # GeoJSON should be 3D
         # `SELECT ST_AsGeoJSON(point, 6) FROM geo3d_city3d WHERE name='Houston';`
         ref_json_regex = re.compile(r'^{"type":"Point","coordinates":\[-95.363151,29.763374,18(\.0+)?\]}$')
-        self.failUnless(ref_json_regex.match(h.geojson))
+        self.assertTrue(ref_json_regex.match(h.geojson))
 
     def test03a_union(self):
         "Testing the Union aggregate of 3D models."
@@ -155,7 +155,7 @@ class Geo3DTest(TestCase):
         ref_ewkt = 'SRID=4326;MULTIPOINT(-123.305196 48.462611 15,-104.609252 38.255001 1433,-97.521157 34.464642 380,-96.801611 32.782057 147,-95.363151 29.763374 18,-95.23506 38.971823 251,-87.650175 41.850385 181,174.783117 -41.315268 14)'
         ref_union = GEOSGeometry(ref_ewkt)
         union = City3D.objects.aggregate(Union('point'))['point__union']
-        self.failUnless(union.hasz)
+        self.assertTrue(union.hasz)
         self.assertEqual(ref_union, union)
 
     def test03b_extent(self):
diff --git a/django/contrib/gis/tests/geoapp/tests.py b/django/contrib/gis/tests/geoapp/tests.py
index a1f251ddda..296f128834 100644
--- a/django/contrib/gis/tests/geoapp/tests.py
+++ b/django/contrib/gis/tests/geoapp/tests.py
@@ -133,11 +133,11 @@ class GeoModelTest(TestCase):
             # No precision parameter for Oracle :-/
             gml_regex = re.compile(r'^<gml:Point srsName="SDO:4326" xmlns:gml="http://www.opengis.net/gml"><gml:coordinates decimal="\." cs="," ts=" ">-104.60925\d+,38.25500\d+ </gml:coordinates></gml:Point>')
             for ptown in [ptown1, ptown2]:
-                self.failUnless(gml_regex.match(ptown.gml))
+                self.assertTrue(gml_regex.match(ptown.gml))
         else:
             gml_regex = re.compile(r'^<gml:Point srsName="EPSG:4326"><gml:coordinates>-104\.60925\d+,38\.255001</gml:coordinates></gml:Point>')
             for ptown in [ptown1, ptown2]:
-                self.failUnless(gml_regex.match(ptown.gml))
+                self.assertTrue(gml_regex.match(ptown.gml))
 
     def test03c_geojson(self):
         "Testing GeoJSON output from the database using GeoQuerySet.geojson()."
@@ -678,15 +678,15 @@ class GeoModelTest(TestCase):
 
         # SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.1)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino';
         ref = fromstr('MULTIPOLYGON(((12.4 44,12.5 44,12.5 43.9,12.4 43.9,12.4 44)))')
-        self.failUnless(ref.equals_exact(Country.objects.snap_to_grid(0.1).get(name='San Marino').snap_to_grid, tol))
+        self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.1).get(name='San Marino').snap_to_grid, tol))
 
         # SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.05, 0.23)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino';
         ref = fromstr('MULTIPOLYGON(((12.4 43.93,12.45 43.93,12.5 43.93,12.45 43.93,12.4 43.93)))')
-        self.failUnless(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23).get(name='San Marino').snap_to_grid, tol))
+        self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23).get(name='San Marino').snap_to_grid, tol))
 
         # SELECT AsText(ST_SnapToGrid("geoapp_country"."mpoly", 0.5, 0.17, 0.05, 0.23)) FROM "geoapp_country" WHERE "geoapp_country"."name" = 'San Marino';
         ref = fromstr('MULTIPOLYGON(((12.4 43.87,12.45 43.87,12.45 44.1,12.5 44.1,12.5 43.87,12.45 43.87,12.4 43.87)))')
-        self.failUnless(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23, 0.5, 0.17).get(name='San Marino').snap_to_grid, tol))
+        self.assertTrue(ref.equals_exact(Country.objects.snap_to_grid(0.05, 0.23, 0.5, 0.17).get(name='San Marino').snap_to_grid, tol))
 
     @no_mysql
     @no_spatialite
diff --git a/django/contrib/gis/tests/relatedapp/tests.py b/django/contrib/gis/tests/relatedapp/tests.py
index c8aeb28d2a..250783b2de 100644
--- a/django/contrib/gis/tests/relatedapp/tests.py
+++ b/django/contrib/gis/tests/relatedapp/tests.py
@@ -173,8 +173,8 @@ class RelatedGeoModelTest(TestCase):
         for m, d, t in zip(gqs, gvqs, gvlqs):
             # The values should be Geometry objects and not raw strings returned
             # by the spatial database.
-            self.failUnless(isinstance(d['point'], Geometry))
-            self.failUnless(isinstance(t[1], Geometry))
+            self.assertTrue(isinstance(d['point'], Geometry))
+            self.assertTrue(isinstance(t[1], Geometry))
             self.assertEqual(m.point, d['point'])
             self.assertEqual(m.point, t[1])
 
@@ -207,8 +207,8 @@ class RelatedGeoModelTest(TestCase):
         combined = qs1 | qs2
         names = [c.name for c in combined]
         self.assertEqual(2, len(names))
-        self.failUnless('Aurora' in names)
-        self.failUnless('Kecksburg' in names)
+        self.assertTrue('Aurora' in names)
+        self.assertTrue('Kecksburg' in names)
 
     def test11_geoquery_pickle(self):
         "Ensuring GeoQuery objects are unpickled correctly.  See #10839."
diff --git a/django/contrib/gis/tests/test_geoforms.py b/django/contrib/gis/tests/test_geoforms.py
index 4d55bf5274..59fab0166e 100644
--- a/django/contrib/gis/tests/test_geoforms.py
+++ b/django/contrib/gis/tests/test_geoforms.py
@@ -26,7 +26,7 @@ class GeometryFieldTest(unittest.TestCase):
         xform_geom = GEOSGeometry('POINT (951640.547328465 4219369.26171664)', srid=32140)
         # The cleaned geometry should be transformed to 32140.
         cleaned_geom = fld.clean('SRID=4326;POINT (-95.363151 29.763374)')
-        self.failUnless(xform_geom.equals_exact(cleaned_geom, tol))
+        self.assertTrue(xform_geom.equals_exact(cleaned_geom, tol))
 
     def test02_null(self):
         "Testing GeometryField's handling of null (None) geometries."
diff --git a/django/contrib/gis/tests/test_measure.py b/django/contrib/gis/tests/test_measure.py
index 5e5e27c381..8ca6be1c40 100644
--- a/django/contrib/gis/tests/test_measure.py
+++ b/django/contrib/gis/tests/test_measure.py
@@ -107,7 +107,7 @@ class DistanceTest(unittest.TestCase):
         self.assertEqual(d4.m, 10)
 
         a5 = d1 * D(m=10)
-        self.assert_(isinstance(a5, Area))
+        self.assertTrue(isinstance(a5, Area))
         self.assertEqual(a5.sq_m, 100*10)
 
         try:
@@ -151,9 +151,9 @@ class DistanceTest(unittest.TestCase):
         d2 = D(km=1)
         d3 = D(km=0)
 
-        self.assert_(d2 > d1)
-        self.assert_(d1 == d1)
-        self.assert_(d1 < d2)
+        self.assertTrue(d2 > d1)
+        self.assertTrue(d1 == d1)
+        self.assertTrue(d1 < d2)
         self.failIf(d3)
 
     def testUnitsStr(self):
@@ -309,9 +309,9 @@ class AreaTest(unittest.TestCase):
         a2 = A(sq_km=1)
         a3 = A(sq_km=0)
 
-        self.assert_(a2 > a1)
-        self.assert_(a1 == a1)
-        self.assert_(a1 < a2)
+        self.assertTrue(a2 > a1)
+        self.assertTrue(a1 == a1)
+        self.assertTrue(a1 < a2)
         self.failIf(a3)
 
     def testUnitsStr(self):
diff --git a/django/contrib/messages/tests/base.py b/django/contrib/messages/tests/base.py
index b1fe04f430..28fde7050d 100644
--- a/django/contrib/messages/tests/base.py
+++ b/django/contrib/messages/tests/base.py
@@ -349,7 +349,7 @@ class BaseTest(TestCase):
         self.assertFalse(storage.used)
         # After iterating the storage engine directly, the used flag is set.
         data = list(storage)
-        self.assert_(storage.used)
+        self.assertTrue(storage.used)
         # The data does not disappear because it has been iterated.
         self.assertEqual(data, list(storage))
 
@@ -357,7 +357,7 @@ class BaseTest(TestCase):
         storage = self.get_existing_storage()
         self.assertFalse(storage.added_new)
         storage.add(constants.INFO, 'Test message 3')
-        self.assert_(storage.added_new)
+        self.assertTrue(storage.added_new)
 
     def test_default_level(self):
         # get_level works even with no storage on the request.
@@ -378,7 +378,7 @@ class BaseTest(TestCase):
         storage = self.storage_class(request)
         request._messages = storage
 
-        self.assert_(set_level(request, 5))
+        self.assertTrue(set_level(request, 5))
         self.assertEqual(get_level(request), 5)
 
         add_level_messages(storage)
@@ -389,7 +389,7 @@ class BaseTest(TestCase):
         storage = self.storage_class(request)
         request._messages = storage
 
-        self.assert_(set_level(request, 30))
+        self.assertTrue(set_level(request, 30))
         self.assertEqual(get_level(request), 30)
 
         add_level_messages(storage)
diff --git a/django/contrib/messages/tests/cookie.py b/django/contrib/messages/tests/cookie.py
index 9aadcf47b2..d5671755f2 100644
--- a/django/contrib/messages/tests/cookie.py
+++ b/django/contrib/messages/tests/cookie.py
@@ -83,7 +83,7 @@ class CookieTest(BaseTest):
         self.assertEqual(cookie_storing, 4)
 
         self.assertEqual(len(unstored_messages), 1)
-        self.assert_(unstored_messages[0].message == '0' * msg_size)
+        self.assertTrue(unstored_messages[0].message == '0' * msg_size)
 
     def test_json_encoder_decoder(self):
         """
diff --git a/django/contrib/sitemaps/tests/basic.py b/django/contrib/sitemaps/tests/basic.py
index 39d02262e9..cbc5c49872 100644
--- a/django/contrib/sitemaps/tests/basic.py
+++ b/django/contrib/sitemaps/tests/basic.py
@@ -40,7 +40,7 @@ class SitemapTests(TestCase):
         # Retrieve the sitemap.
         response = self.client.get('/simple/index.xml')
         # Check for all the important bits:
-        self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap>
 </sitemapindex>
@@ -51,7 +51,7 @@ class SitemapTests(TestCase):
         # Retrieve the sitemap.
         response = self.client.get('/simple/custom-index.xml')
         # Check for all the important bits:
-        self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
 <!-- This is a customised template -->
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <sitemap><loc>%s/simple/sitemap-simple.xml</loc></sitemap>
@@ -63,7 +63,7 @@ class SitemapTests(TestCase):
         # Retrieve the sitemap.
         response = self.client.get('/simple/sitemap.xml')
         # Check for all the important bits:
-        self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
 </urlset>
@@ -74,7 +74,7 @@ class SitemapTests(TestCase):
         # Retrieve the sitemap.
         response = self.client.get('/simple/custom-sitemap.xml')
         # Check for all the important bits:
-        self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
 <!-- This is a customised template -->
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <url><loc>%s/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
@@ -105,7 +105,7 @@ class SitemapTests(TestCase):
         for username in User.objects.values_list("username", flat=True):
             expected += "<url><loc>%s/users/%s/</loc></url>" % (self.base_url, username)
         # Check for all the important bits:
-        self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 %s
 </urlset>
@@ -148,7 +148,7 @@ class SitemapTests(TestCase):
         # Retrieve the sitemap.
         response = self.client.get('/simple/sitemap.xml')
         # Check for all the important bits:
-        self.assertEquals(response.content, """<?xml version="1.0" encoding="UTF-8"?>
+        self.assertEqual(response.content, """<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 <url><loc>http://testserver/location/</loc><lastmod>%s</lastmod><changefreq>never</changefreq><priority>0.5</priority></url>
 </urlset>
diff --git a/django/contrib/sites/tests.py b/django/contrib/sites/tests.py
index 85cb53c403..17ab1f2a7c 100644
--- a/django/contrib/sites/tests.py
+++ b/django/contrib/sites/tests.py
@@ -18,7 +18,7 @@ class SitesFrameworkTests(TestCase):
     def test_site_manager(self):
         # Make sure that get_current() does not return a deleted Site object.
         s = Site.objects.get_current()
-        self.assert_(isinstance(s, Site))
+        self.assertTrue(isinstance(s, Site))
         s.delete()
         self.assertRaises(ObjectDoesNotExist, Site.objects.get_current)
 
@@ -41,7 +41,7 @@ class SitesFrameworkTests(TestCase):
             "SERVER_PORT": "80",
         }
         site = get_current_site(request)
-        self.assert_(isinstance(site, Site))
+        self.assertTrue(isinstance(site, Site))
         self.assertEqual(site.id, settings.SITE_ID)
 
         # Test that an exception is raised if the sites framework is installed
@@ -52,5 +52,5 @@ class SitesFrameworkTests(TestCase):
         # A RequestSite is returned if the sites framework is not installed
         Site._meta.installed = False
         site = get_current_site(request)
-        self.assert_(isinstance(site, RequestSite))
+        self.assertTrue(isinstance(site, RequestSite))
         self.assertEqual(site.name, u"example.com")
diff --git a/django/utils/unittest/case.py b/django/utils/unittest/case.py
index fd5623b03c..5ae602957b 100644
--- a/django/utils/unittest/case.py
+++ b/django/utils/unittest/case.py
@@ -831,8 +831,8 @@ class TestCase(unittest.TestCase):
             self.fail(self._formatMessage(msg, standardMsg))
 
     def assertDictEqual(self, d1, d2, msg=None):
-        self.assert_(isinstance(d1, dict), 'First argument is not a dictionary')
-        self.assert_(isinstance(d2, dict), 'Second argument is not a dictionary')
+        self.assertTrue(isinstance(d1, dict), 'First argument is not a dictionary')
+        self.assertTrue(isinstance(d2, dict), 'Second argument is not a dictionary')
 
         if d1 != d2:
             standardMsg = '%s != %s' % (safe_repr(d1, True), safe_repr(d2, True))
@@ -909,9 +909,9 @@ class TestCase(unittest.TestCase):
 
     def assertMultiLineEqual(self, first, second, msg=None):
         """Assert that two multi-line strings are equal."""
-        self.assert_(isinstance(first, basestring), (
+        self.assertTrue(isinstance(first, basestring), (
                 'First argument is not a string'))
-        self.assert_(isinstance(second, basestring), (
+        self.assertTrue(isinstance(second, basestring), (
                 'Second argument is not a string'))
 
         if first != second: