diff --git a/django/test/testcases.py b/django/test/testcases.py
index 8c73c63..b1a37d9 100644
--- a/django/test/testcases.py
+++ b/django/test/testcases.py
@@ -273,34 +273,41 @@ class TransactionTestCase(unittest.TestCase):
             clear_url_caches()
 
     def assertRedirects(self, response, expected_url, status_code=302,
-                        target_status_code=200, host=None):
+                        target_status_code=200, host=None, msg_prefix=""):
         """Asserts that a response redirected to a specific URL, and that the
         redirect URL can be loaded.
 
         Note that assertRedirects won't work for external links since it uses
         TestClient to do a request.
         """
+        if msg_prefix:
+            msg_prefix += ": "
+
         if hasattr(response, 'redirect_chain'):
             # The request was a followed redirect
             self.failUnless(len(response.redirect_chain) > 0,
-                ("Response didn't redirect as expected: Response code was %d"
-                " (expected %d)" % (response.status_code, status_code)))
+                msg_prefix + "Response didn't redirect as expected: Response"
+                " code was %d (expected %d)" %
+                    (response.status_code, status_code))
 
             self.assertEqual(response.redirect_chain[0][1], status_code,
-                ("Initial response didn't redirect as expected: Response code was %d"
-                 " (expected %d)" % (response.redirect_chain[0][1], status_code)))
+                msg_prefix + "Initial response didn't redirect as expected:"
+                " Response code was %d (expected %d)" %
+                    (response.redirect_chain[0][1], status_code))
 
             url, status_code = response.redirect_chain[-1]
 
             self.assertEqual(response.status_code, target_status_code,
-                ("Response didn't redirect as expected: Final Response code was %d"
-                " (expected %d)" % (response.status_code, target_status_code)))
+                msg_prefix + "Response didn't redirect as expected: Final"
+                " Response code was %d (expected %d)" %
+                    (response.status_code, target_status_code))
 
         else:
             # Not a followed redirect
             self.assertEqual(response.status_code, status_code,
-                ("Response didn't redirect as expected: Response code was %d"
-                 " (expected %d)" % (response.status_code, status_code)))
+                msg_prefix + "Response didn't redirect as expected: Response"
+                " code was %d (expected %d)" %
+                    (response.status_code, status_code))
 
             url = response['Location']
             scheme, netloc, path, query, fragment = urlsplit(url)
@@ -310,9 +317,9 @@ class TransactionTestCase(unittest.TestCase):
             # Get the redirection page, using the same client that was used
             # to obtain the original response.
             self.assertEqual(redirect_response.status_code, target_status_code,
-                ("Couldn't retrieve redirection page '%s': response code was %d"
-                 " (expected %d)") %
-                     (path, redirect_response.status_code, target_status_code))
+                msg_prefix + "Couldn't retrieve redirection page '%s':"
+                " response code was %d (expected %d)" %
+                    (path, redirect_response.status_code, target_status_code))
 
         e_scheme, e_netloc, e_path, e_query, e_fragment = urlsplit(expected_url)
         if not (e_scheme or e_netloc):
@@ -320,10 +327,11 @@ class TransactionTestCase(unittest.TestCase):
                 e_query, e_fragment))
 
         self.assertEqual(url, expected_url,
-            "Response redirected to '%s', expected '%s'" % (url, expected_url))
-
+            msg_prefix + "Response redirected to '%s', expected '%s'" %
+                (url, expected_url))
 
-    def assertContains(self, response, text, count=None, status_code=200):
+    def assertContains(self, response, text, count=None, status_code=200,
+                       msg_prefix=""):
         """
         Asserts that a response indicates that a page was retrieved
         successfully, (i.e., the HTTP status code was as expected), and that
@@ -331,42 +339,52 @@ class TransactionTestCase(unittest.TestCase):
         If ``count`` is None, the count doesn't matter - the assertion is true
         if the text occurs at least once in the response.
         """
+        if msg_prefix:
+            msg_prefix += ": "
+
         self.assertEqual(response.status_code, status_code,
-            "Couldn't retrieve page: Response code was %d (expected %d)'" %
-                (response.status_code, status_code))
+            msg_prefix + "Couldn't retrieve page: Response code was %d"
+            " (expected %d)" % (response.status_code, status_code))
         text = smart_str(text, response._charset)
         real_count = response.content.count(text)
         if count is not None:
             self.assertEqual(real_count, count,
-                "Found %d instances of '%s' in response (expected %d)" %
-                    (real_count, text, count))
+                msg_prefix + "Found %d instances of '%s' in response"
+                " (expected %d)" % (real_count, text, count))
         else:
             self.failUnless(real_count != 0,
-                            "Couldn't find '%s' in response" % text)
+                msg_prefix + "Couldn't find '%s' in response" % text)
 
-    def assertNotContains(self, response, text, status_code=200):
+    def assertNotContains(self, response, text, status_code=200,
+                          msg_prefix=""):
         """
         Asserts that a response indicates that a page was retrieved
         successfully, (i.e., the HTTP status code was as expected), and that
         ``text`` doesn't occurs in the content of the response.
         """
+        if msg_prefix:
+            msg_prefix += ": "
+
         self.assertEqual(response.status_code, status_code,
-            "Couldn't retrieve page: Response code was %d (expected %d)'" %
-                (response.status_code, status_code))
+            msg_prefix + "Couldn't retrieve page: Response code was %d"
+            " (expected %d)" % (response.status_code, status_code))
         text = smart_str(text, response._charset)
-        self.assertEqual(response.content.count(text),
-             0, "Response should not contain '%s'" % text)
+        self.assertEqual(response.content.count(text), 0,
+            msg_prefix + "Response should not contain '%s'" % text)
 
-    def assertFormError(self, response, form, field, errors):
+    def assertFormError(self, response, form, field, errors, msg_prefix=""):
         """
         Asserts that a form used to render the response has a specific field
         error.
         """
+        if msg_prefix:
+            msg_prefix += ": "
+
         # Put context(s) into a list to simplify processing.
         contexts = to_list(response.context)
         if not contexts:
-            self.fail('Response did not use any contexts to render the'
-                      ' response')
+            self.fail(msg_prefix + "Response did not use any contexts to"
+                      "render the response")
 
         # Put error(s) into a list to simplify processing.
         errors = to_list(errors)
@@ -382,50 +400,57 @@ class TransactionTestCase(unittest.TestCase):
                     if field in context[form].errors:
                         field_errors = context[form].errors[field]
                         self.failUnless(err in field_errors,
-                                        "The field '%s' on form '%s' in"
-                                        " context %d does not contain the"
-                                        " error '%s' (actual errors: %s)" %
-                                            (field, form, i, err,
-                                             repr(field_errors)))
+                            msg_prefix + "The field '%s' on form '%s' in"
+                            " context %d does not contain the error '%s'"
+                            " (actual errors: %s)" %
+                                (field, form, i, err, repr(field_errors)))
                     elif field in context[form].fields:
-                        self.fail("The field '%s' on form '%s' in context %d"
-                                  " contains no errors" % (field, form, i))
+                        self.fail(msg_prefix + "The field '%s' on form '%s'"
+                                  " in context %d contains no errors" %
+                                      (field, form, i))
                     else:
-                        self.fail("The form '%s' in context %d does not"
-                                  " contain the field '%s'" %
+                        self.fail(msg_prefix + "The form '%s' in context %d"
+                                  " does not contain the field '%s'" %
                                       (form, i, field))
                 else:
                     non_field_errors = context[form].non_field_errors()
                     self.failUnless(err in non_field_errors,
-                        "The form '%s' in context %d does not contain the"
-                        " non-field error '%s' (actual errors: %s)" %
+                        msg_prefix + "The form '%s' in context %d does not"
+                        " contain the non-field error '%s'"
+                        " (actual errors: %s)" %
                             (form, i, err, non_field_errors))
         if not found_form:
-            self.fail("The form '%s' was not used to render the response" %
-                          form)
+            self.fail(msg_prefix + "The form '%s' was not used to render the"
+                      " response" % form)
 
-    def assertTemplateUsed(self, response, template_name):
+    def assertTemplateUsed(self, response, template_name, msg_prefix=""):
         """
         Asserts that the template with the provided name was used in rendering
         the response.
         """
+        if msg_prefix:
+            msg_prefix += ": "
+
         template_names = [t.name for t in to_list(response.template)]
         if not template_names:
-            self.fail('No templates used to render the response')
+            self.fail(msg_prefix + "No templates used to render the response")
         self.failUnless(template_name in template_names,
-            (u"Template '%s' was not a template used to render the response."
-             u" Actual template(s) used: %s") % (template_name,
-                                                 u', '.join(template_names)))
+            msg_prefix + "Template '%s' was not a template used to render"
+            " the response. Actual template(s) used: %s" %
+                (template_name, u', '.join(template_names)))
 
-    def assertTemplateNotUsed(self, response, template_name):
+    def assertTemplateNotUsed(self, response, template_name, msg_prefix=""):
         """
         Asserts that the template with the provided name was NOT used in
         rendering the response.
         """
+        if msg_prefix:
+            msg_prefix += ": "
+
         template_names = [t.name for t in to_list(response.template)]
         self.failIf(template_name in template_names,
-            (u"Template '%s' was used unexpectedly in rendering the"
-             u" response") % template_name)
+            msg_prefix + "Template '%s' was used unexpectedly in rendering"
+            " the response" % template_name)
 
 class TestCase(TransactionTestCase):
     """
diff --git a/tests/regressiontests/test_client_regress/models.py b/tests/regressiontests/test_client_regress/models.py
index be2cb8f..813087c 100644
--- a/tests/regressiontests/test_client_regress/models.py
+++ b/tests/regressiontests/test_client_regress/models.py
@@ -31,39 +31,85 @@ class AssertContainsTests(TestCase):
         self.assertContains(response, 'twice', 2)
 
         try:
+            self.assertContains(response, 'text', status_code=999)
+        except AssertionError, e:
+            self.assertEquals(str(e), "Couldn't retrieve page: Response code was 200 (expected 999)")
+        try:
+            self.assertContains(response, 'text', status_code=999, msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Couldn't retrieve page: Response code was 200 (expected 999)")
+
+        try:
+            self.assertNotContains(response, 'text', status_code=999)
+        except AssertionError, e:
+            self.assertEquals(str(e), "Couldn't retrieve page: Response code was 200 (expected 999)")
+        try:
+            self.assertNotContains(response, 'text', status_code=999, msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Couldn't retrieve page: Response code was 200 (expected 999)")
+
+        try:
             self.assertNotContains(response, 'once')
         except AssertionError, e:
             self.assertEquals(str(e), "Response should not contain 'once'")
+        try:
+            self.assertNotContains(response, 'once', msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Response should not contain 'once'")
 
         try:
             self.assertContains(response, 'never', 1)
         except AssertionError, e:
             self.assertEquals(str(e), "Found 0 instances of 'never' in response (expected 1)")
+        try:
+            self.assertContains(response, 'never', 1, msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Found 0 instances of 'never' in response (expected 1)")
 
         try:
             self.assertContains(response, 'once', 0)
         except AssertionError, e:
             self.assertEquals(str(e), "Found 1 instances of 'once' in response (expected 0)")
+        try:
+            self.assertContains(response, 'once', 0, msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Found 1 instances of 'once' in response (expected 0)")
 
         try:
             self.assertContains(response, 'once', 2)
         except AssertionError, e:
             self.assertEquals(str(e), "Found 1 instances of 'once' in response (expected 2)")
+        try:
+            self.assertContains(response, 'once', 2, msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Found 1 instances of 'once' in response (expected 2)")
 
         try:
             self.assertContains(response, 'twice', 1)
         except AssertionError, e:
             self.assertEquals(str(e), "Found 2 instances of 'twice' in response (expected 1)")
+        try:
+            self.assertContains(response, 'twice', 1, msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Found 2 instances of 'twice' in response (expected 1)")
 
         try:
             self.assertContains(response, 'thrice')
         except AssertionError, e:
             self.assertEquals(str(e), "Couldn't find 'thrice' in response")
+        try:
+            self.assertContains(response, 'thrice', msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Couldn't find 'thrice' in response")
 
         try:
             self.assertContains(response, 'thrice', 3)
         except AssertionError, e:
             self.assertEquals(str(e), "Found 0 instances of 'thrice' in response (expected 3)")
+        try:
+            self.assertContains(response, 'thrice', 3, msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEquals(str(e), "abc: Found 0 instances of 'thrice' in response (expected 3)")
 
     def test_unicode_contains(self):
         "Unicode characters can be found in template context"
@@ -79,6 +125,7 @@ class AssertContainsTests(TestCase):
         self.assertNotContains(r, u'はたけ')
         self.assertNotContains(r, '\xe3\x81\xaf\xe3\x81\x9f\xe3\x81\x91'.decode('utf-8'))
 
+
 class AssertTemplateUsedTests(TestCase):
     fixtures = ['testdata.json']
 
@@ -290,6 +337,10 @@ class AssertFormErrorTests(TestCase):
             self.assertFormError(response, 'wrong_form', 'some_field', 'Some error.')
         except AssertionError, e:
             self.assertEqual(str(e), "The form 'wrong_form' was not used to render the response")
+        try:
+            self.assertFormError(response, 'wrong_form', 'some_field', 'Some error.', msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEqual(str(e), "abc: The form 'wrong_form' was not used to render the response")
 
     def test_unknown_field(self):
         "An assertion is raised if the field name is unknown"
@@ -308,6 +359,10 @@ class AssertFormErrorTests(TestCase):
             self.assertFormError(response, 'form', 'some_field', 'Some error.')
         except AssertionError, e:
             self.assertEqual(str(e), "The form 'form' in context 0 does not contain the field 'some_field'")
+        try:
+            self.assertFormError(response, 'form', 'some_field', 'Some error.', msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEqual(str(e), "abc: The form 'form' in context 0 does not contain the field 'some_field'")
 
     def test_noerror_field(self):
         "An assertion is raised if the field doesn't have any errors"
@@ -326,6 +381,10 @@ class AssertFormErrorTests(TestCase):
             self.assertFormError(response, 'form', 'value', 'Some error.')
         except AssertionError, e:
             self.assertEqual(str(e), "The field 'value' on form 'form' in context 0 contains no errors")
+        try:
+            self.assertFormError(response, 'form', 'value', 'Some error.', msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEqual(str(e), "abc: The field 'value' on form 'form' in context 0 contains no errors")
 
     def test_unknown_error(self):
         "An assertion is raised if the field doesn't contain the provided error"
@@ -344,6 +403,10 @@ class AssertFormErrorTests(TestCase):
             self.assertFormError(response, 'form', 'email', 'Some error.')
         except AssertionError, e:
             self.assertEqual(str(e), "The field 'email' on form 'form' in context 0 does not contain the error 'Some error.' (actual errors: [u'Enter a valid e-mail address.'])")
+        try:
+            self.assertFormError(response, 'form', 'email', 'Some error.', msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEqual(str(e), "abc: The field 'email' on form 'form' in context 0 does not contain the error 'Some error.' (actual errors: [u'Enter a valid e-mail address.'])")
 
     def test_unknown_nonfield_error(self):
         """
@@ -365,6 +428,10 @@ class AssertFormErrorTests(TestCase):
             self.assertFormError(response, 'form', None, 'Some error.')
         except AssertionError, e:
             self.assertEqual(str(e), "The form 'form' in context 0 does not contain the non-field error 'Some error.' (actual errors: )")
+        try:
+            self.assertFormError(response, 'form', None, 'Some error.', msg_prefix='abc')
+        except AssertionError, e:
+            self.assertEqual(str(e), "abc: The form 'form' in context 0 does not contain the non-field error 'Some error.' (actual errors: )")
 
 class LoginTests(TestCase):
     fixtures = ['testdata']
