diff --git a/tests/regressiontests/admin_validation/tests.py b/tests/regressiontests/admin_validation/tests.py
--- a/tests/regressiontests/admin_validation/tests.py
+++ b/tests/regressiontests/admin_validation/tests.py
@@ -18,13 +18,6 @@
     fields = ['spam']
 
 class ValidationTestCase(TestCase):
-    def assertRaisesMessage(self, exc, msg, func, *args, **kwargs):
-        try:
-            func(*args, **kwargs)
-        except Exception, e:
-            self.assertEqual(msg, str(e))
-            self.assertTrue(isinstance(e, exc), "Expected %s, got %s" % (exc, type(e)))
-
     def test_readonly_and_editable(self):
         class SongAdmin(admin.ModelAdmin):
             readonly_fields = ["original_release"]
@@ -40,7 +33,7 @@
         # Regression test for #8027: custom ModelForms with fields/fieldsets
         """
         validate(ValidFields, Song)
-        self.assertRaisesMessage(ImproperlyConfigured,
+        self.assertRaisesRegexp(ImproperlyConfigured,
             "'InvalidFields.fields' refers to field 'spam' that is missing from the form.",
             validate,
             InvalidFields, Song)
@@ -51,7 +44,7 @@
         """
         class ExcludedFields1(admin.ModelAdmin):
             exclude = ('foo')
-        self.assertRaisesMessage(ImproperlyConfigured,
+        self.assertRaisesRegexp(ImproperlyConfigured,
             "'ExcludedFields1.exclude' must be a list or tuple.",
             validate,
             ExcludedFields1, Book)
@@ -59,8 +52,8 @@
     def test_exclude_duplicate_values(self):
         class ExcludedFields2(admin.ModelAdmin):
             exclude = ('name', 'name')
-        self.assertRaisesMessage(ImproperlyConfigured,
-            "There are duplicate field(s) in ExcludedFields2.exclude",
+        self.assertRaisesRegexp(ImproperlyConfigured,
+            "There are duplicate field\(s\) in ExcludedFields2.exclude",
             validate,
             ExcludedFields2, Book)
 
@@ -73,7 +66,7 @@
             model = Album
             inlines = [ExcludedFieldsInline]
 
-        self.assertRaisesMessage(ImproperlyConfigured,
+        self.assertRaisesRegexp(ImproperlyConfigured,
             "'ExcludedFieldsInline.exclude' must be a list or tuple.",
             validate,
             ExcludedFieldsAlbumAdmin, Album)
@@ -91,7 +84,7 @@
             model = Album
             inlines = [SongInline]
 
-        self.assertRaisesMessage(ImproperlyConfigured,
+        self.assertRaisesRegexp(ImproperlyConfigured,
             "SongInline cannot exclude the field 'album' - this is the foreign key to the parent model Album.",
             validate,
             AlbumAdmin, Album)
@@ -112,7 +105,7 @@
         class TwoAlbumFKAndAnEInline(admin.TabularInline):
             model = TwoAlbumFKAndAnE
 
-        self.assertRaisesMessage(Exception,
+        self.assertRaisesRegexp(Exception,
             "<class 'regressiontests.admin_validation.models.TwoAlbumFKAndAnE'> has more than 1 ForeignKey to <class 'regressiontests.admin_validation.models.Album'>",
             validate_inline,
             TwoAlbumFKAndAnEInline, None, Album)
@@ -157,8 +150,8 @@
         class SongAdmin(admin.ModelAdmin):
             readonly_fields = ("title", "nonexistant")
 
-        self.assertRaisesMessage(ImproperlyConfigured,
-            "SongAdmin.readonly_fields[1], 'nonexistant' is not a callable or an attribute of 'SongAdmin' or found in the model 'Song'.",
+        self.assertRaisesRegexp(ImproperlyConfigured,
+            "SongAdmin.readonly_fields\[1\], 'nonexistant' is not a callable or an attribute of 'SongAdmin' or found in the model 'Song'.",
             validate,
             SongAdmin, Song)
 
@@ -186,7 +179,7 @@
         class BookAdmin(admin.ModelAdmin):
             fields = ['authors']
 
-        self.assertRaisesMessage(ImproperlyConfigured,
+        self.assertRaisesRegexp(ImproperlyConfigured,
             "'BookAdmin.fields' can't include the ManyToManyField field 'authors' because 'authors' manually specifies a 'through' model.",
             validate,
             BookAdmin, Book)
@@ -197,8 +190,8 @@
                 ('Header 1', {'fields': ('name',)}),
                 ('Header 2', {'fields': ('authors',)}),
             )
-        self.assertRaisesMessage(ImproperlyConfigured,
-            "'FieldsetBookAdmin.fieldsets[1][1]['fields']' can't include the ManyToManyField field 'authors' because 'authors' manually specifies a 'through' model.",
+        self.assertRaisesRegexp(ImproperlyConfigured,
+            "'FieldsetBookAdmin.fieldsets\[1\]\[1\]\['fields'\]' can't include the ManyToManyField field 'authors' because 'authors' manually specifies a 'through' model.",
             validate,
             FieldsetBookAdmin, Book)
 
diff --git a/tests/regressiontests/custom_columns_regress/tests.py b/tests/regressiontests/custom_columns_regress/tests.py
--- a/tests/regressiontests/custom_columns_regress/tests.py
+++ b/tests/regressiontests/custom_columns_regress/tests.py
@@ -9,13 +9,6 @@
 
 class CustomColumnRegression(TestCase):
 
-    def assertRaisesMessage(self, exc, msg, func, *args, **kwargs):
-        try:
-            func(*args, **kwargs)
-        except Exception, e:
-            self.assertEqual(msg, str(e))
-            self.assertTrue(isinstance(e, exc), "Expected %s, got %s" % (exc, type(e)))
-
     def setUp(self):
         self.a1 = Author.objects.create(first_name='John', last_name='Smith')
         self.a2 = Author.objects.create(first_name='Peter', last_name='Jones')
@@ -42,7 +35,7 @@
         self.assertEqual(self.a1, Author.objects.get(first_name__exact='John'))
 
     def test_filter_on_nonexistant_field(self):
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             FieldError,
             "Cannot resolve keyword 'firstname' into field. Choices are: Author_ID, article, first_name, last_name, primary_set",
             Author.objects.filter,
@@ -53,14 +46,14 @@
         a = Author.objects.get(last_name__exact='Smith')
         self.assertEqual('John', a.first_name)
         self.assertEqual('Smith', a.last_name)
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             AttributeError,
             "'Author' object has no attribute 'firstname'",
             getattr,
             a, 'firstname'
         )
 
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             AttributeError,
             "'Author' object has no attribute 'last'",
             getattr,
diff --git a/tests/regressiontests/file_storage/tests.py b/tests/regressiontests/file_storage/tests.py
--- a/tests/regressiontests/file_storage/tests.py
+++ b/tests/regressiontests/file_storage/tests.py
@@ -13,6 +13,7 @@
 from django.core.files.storage import FileSystemStorage, get_storage_class
 from django.core.files.uploadedfile import UploadedFile
 from django.core.exceptions import ImproperlyConfigured
+#from django.test import TestCase
 from django.utils import unittest
 
 try:
@@ -32,14 +33,6 @@
         Image = None
 
 class GetStorageClassTests(unittest.TestCase):
-    def assertRaisesErrorWithMessage(self, error, message, callable,
-        *args, **kwargs):
-        self.assertRaises(error, callable, *args, **kwargs)
-        try:
-            callable(*args, **kwargs)
-        except error, e:
-            self.assertEqual(message, str(e))
-
     def test_get_filesystem_storage(self):
         """
         get_storage_class returns the class for a storage backend name/path.
@@ -52,7 +45,7 @@
         """
         get_storage_class raises an error if the requested import don't exist.
         """
-        self.assertRaisesErrorWithMessage(
+        self.assertRaisesRegexp(
             ImproperlyConfigured,
             "NonExistingStorage isn't a storage module.",
             get_storage_class,
@@ -62,7 +55,7 @@
         """
         get_storage_class raises an error if the requested class don't exist.
         """
-        self.assertRaisesErrorWithMessage(
+        self.assertRaisesRegexp(
             ImproperlyConfigured,
             'Storage module "django.core.files.storage" does not define a '\
                 '"NonExistingStorage" class.',
@@ -73,7 +66,7 @@
         """
         get_storage_class raises an error if the requested module don't exist.
         """
-        self.assertRaisesErrorWithMessage(
+        self.assertRaisesRegexp(
             ImproperlyConfigured,
             'Error importing storage module django.core.files.non_existing_'\
                 'storage: "No module named non_existing_storage"',
diff --git a/tests/regressiontests/fixtures_regress/tests.py b/tests/regressiontests/fixtures_regress/tests.py
--- a/tests/regressiontests/fixtures_regress/tests.py
+++ b/tests/regressiontests/fixtures_regress/tests.py
@@ -343,13 +343,6 @@
 
 
 class NaturalKeyFixtureTests(TestCase):
-    def assertRaisesMessage(self, exc, msg, func, *args, **kwargs):
-        try:
-            func(*args, **kwargs)
-        except Exception, e:
-            self.assertEqual(msg, str(e))
-            self.assertTrue(isinstance(e, exc), "Expected %s, got %s" % (exc, type(e)))
-
     def test_nk_deserialize(self):
         """
         Test for ticket #13030 - Python based parser version
@@ -507,7 +500,7 @@
         )
 
     def test_dependency_sorting_tight_circular(self):
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             CommandError,
             """Can't resolve dependencies for fixtures_regress.Circle1, fixtures_regress.Circle2 in serialized app list.""",
             sort_dependencies,
@@ -515,7 +508,7 @@
         )
 
     def test_dependency_sorting_tight_circular_2(self):
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             CommandError,
             """Can't resolve dependencies for fixtures_regress.Circle1, fixtures_regress.Circle2 in serialized app list.""",
             sort_dependencies,
@@ -523,7 +516,7 @@
         )
 
     def test_dependency_self_referential(self):
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             CommandError,
             """Can't resolve dependencies for fixtures_regress.Circle3 in serialized app list.""",
             sort_dependencies,
@@ -531,7 +524,7 @@
         )
 
     def test_dependency_sorting_long(self):
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             CommandError,
             """Can't resolve dependencies for fixtures_regress.Circle1, fixtures_regress.Circle2, fixtures_regress.Circle3 in serialized app list.""",
             sort_dependencies,
diff --git a/tests/regressiontests/forms/fields.py b/tests/regressiontests/forms/fields.py
--- a/tests/regressiontests/forms/fields.py
+++ b/tests/regressiontests/forms/fields.py
@@ -49,13 +49,6 @@
 
 class FieldsTests(TestCase):
 
-    def assertRaisesErrorWithMessage(self, error, message, callable, *args, **kwargs):
-        self.assertRaises(error, callable, *args, **kwargs)
-        try:
-            callable(*args, **kwargs)
-        except error, e:
-            self.assertEqual(message, str(e))
-
     def test_field_sets_widget_is_required(self):
         self.assertEqual(Field(required=True).widget.is_required, True)
         self.assertEqual(Field(required=False).widget.is_required, False)
@@ -66,8 +59,8 @@
         f = CharField()
         self.assertEqual(u'1', f.clean(1))
         self.assertEqual(u'hello', f.clean('hello'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
         self.assertEqual(u'[1, 2, 3]', f.clean([1, 2, 3]))
 
     def test_charfield_1(self):
@@ -82,19 +75,19 @@
         f = CharField(max_length=10, required=False)
         self.assertEqual(u'12345', f.clean('12345'))
         self.assertEqual(u'1234567890', f.clean('1234567890'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 10 characters (it has 11).']", f.clean, '1234567890a')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at most 10 characters \(it has 11\).'", f.clean, '1234567890a')
 
     def test_charfield_3(self):
         f = CharField(min_length=10, required=False)
         self.assertEqual(u'', f.clean(''))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at least 10 characters (it has 5).']", f.clean, '12345')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at least 10 characters \(it has 5\).'", f.clean, '12345')
         self.assertEqual(u'1234567890', f.clean('1234567890'))
         self.assertEqual(u'1234567890a', f.clean('1234567890a'))
 
     def test_charfield_4(self):
         f = CharField(min_length=10, required=True)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at least 10 characters (it has 5).']", f.clean, '12345')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at least 10 characters \(it has 5\).'", f.clean, '12345')
         self.assertEqual(u'1234567890', f.clean('1234567890'))
         self.assertEqual(u'1234567890a', f.clean('1234567890a'))
 
@@ -102,18 +95,18 @@
 
     def test_integerfield_5(self):
         f = IntegerField()
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(1, f.clean('1'))
         self.assertEqual(True, isinstance(f.clean('1'), int))
         self.assertEqual(23, f.clean('23'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, 'a')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a whole number.'", f.clean, 'a')
         self.assertEqual(42, f.clean(42))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, 3.14)
+        self.assertRaisesRegexp(ValidationError, "u'Enter a whole number.'", f.clean, 3.14)
         self.assertEqual(1, f.clean('1 '))
         self.assertEqual(1, f.clean(' 1'))
         self.assertEqual(1, f.clean(' 1 '))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, '1a')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a whole number.'", f.clean, '1a')
 
     def test_integerfield_6(self):
         f = IntegerField(required=False)
@@ -124,25 +117,25 @@
         self.assertEqual(1, f.clean('1'))
         self.assertEqual(True, isinstance(f.clean('1'), int))
         self.assertEqual(23, f.clean('23'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, 'a')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a whole number.'", f.clean, 'a')
         self.assertEqual(1, f.clean('1 '))
         self.assertEqual(1, f.clean(' 1'))
         self.assertEqual(1, f.clean(' 1 '))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, '1a')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a whole number.'", f.clean, '1a')
 
     def test_integerfield_7(self):
         f = IntegerField(max_value=10)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(1, f.clean(1))
         self.assertEqual(10, f.clean(10))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 10.']", f.clean, 11)
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is less than or equal to 10.'", f.clean, 11)
         self.assertEqual(10, f.clean('10'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 10.']", f.clean, '11')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is less than or equal to 10.'", f.clean, '11')
 
     def test_integerfield_8(self):
         f = IntegerField(min_value=10)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is greater than or equal to 10.']", f.clean, 1)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is greater than or equal to 10.'", f.clean, 1)
         self.assertEqual(10, f.clean(10))
         self.assertEqual(11, f.clean(11))
         self.assertEqual(10, f.clean('10'))
@@ -150,32 +143,32 @@
 
     def test_integerfield_9(self):
         f = IntegerField(min_value=10, max_value=20)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is greater than or equal to 10.']", f.clean, 1)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is greater than or equal to 10.'", f.clean, 1)
         self.assertEqual(10, f.clean(10))
         self.assertEqual(11, f.clean(11))
         self.assertEqual(10, f.clean('10'))
         self.assertEqual(11, f.clean('11'))
         self.assertEqual(20, f.clean(20))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 20.']", f.clean, 21)
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is less than or equal to 20.'", f.clean, 21)
 
     # FloatField ##################################################################
 
     def test_floatfield_10(self):
         f = FloatField()
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(1.0, f.clean('1'))
         self.assertEqual(True, isinstance(f.clean('1'), float))
         self.assertEqual(23.0, f.clean('23'))
         self.assertEqual(3.1400000000000001, f.clean('3.14'))
         self.assertEqual(3.1400000000000001, f.clean(3.14))
         self.assertEqual(42.0, f.clean(42))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, 'a')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, 'a')
         self.assertEqual(1.0, f.clean('1.0 '))
         self.assertEqual(1.0, f.clean(' 1.0'))
         self.assertEqual(1.0, f.clean(' 1.0 '))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, '1.0a')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, '1.0a')
 
     def test_floatfield_11(self):
         f = FloatField(required=False)
@@ -185,8 +178,8 @@
 
     def test_floatfield_12(self):
         f = FloatField(max_value=1.5, min_value=0.5)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 1.5.']", f.clean, '1.6')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is greater than or equal to 0.5.']", f.clean, '0.4')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is less than or equal to 1.5.'", f.clean, '1.6')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is greater than or equal to 0.5.'", f.clean, '0.4')
         self.assertEqual(1.5, f.clean('1.5'))
         self.assertEqual(0.5, f.clean('0.5'))
 
@@ -194,34 +187,34 @@
 
     def test_decimalfield_13(self):
         f = DecimalField(max_digits=4, decimal_places=2)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(f.clean('1'), Decimal("1"))
         self.assertEqual(True, isinstance(f.clean('1'), Decimal))
         self.assertEqual(f.clean('23'), Decimal("23"))
         self.assertEqual(f.clean('3.14'), Decimal("3.14"))
         self.assertEqual(f.clean(3.14), Decimal("3.14"))
         self.assertEqual(f.clean(Decimal('3.14')), Decimal("3.14"))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, 'NaN')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, 'Inf')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, '-Inf')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, 'a')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, u'łąść')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, 'NaN')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, 'Inf')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, '-Inf')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, 'a')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, u'łąść')
         self.assertEqual(f.clean('1.0 '), Decimal("1.0"))
         self.assertEqual(f.clean(' 1.0'), Decimal("1.0"))
         self.assertEqual(f.clean(' 1.0 '), Decimal("1.0"))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, '1.0a')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 4 digits in total.']", f.clean, '123.45')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 2 decimal places.']", f.clean, '1.234')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 2 digits before the decimal point.']", f.clean, '123.4')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, '1.0a')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 4 digits in total.'", f.clean, '123.45')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 2 decimal places.'", f.clean, '1.234')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 2 digits before the decimal point.'", f.clean, '123.4')
         self.assertEqual(f.clean('-12.34'), Decimal("-12.34"))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 4 digits in total.']", f.clean, '-123.45')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 4 digits in total.'", f.clean, '-123.45')
         self.assertEqual(f.clean('-.12'), Decimal("-0.12"))
         self.assertEqual(f.clean('-00.12'), Decimal("-0.12"))
         self.assertEqual(f.clean('-000.12'), Decimal("-0.12"))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 2 decimal places.']", f.clean, '-000.123')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 4 digits in total.']", f.clean, '-000.12345')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, '--0.12')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 2 decimal places.'", f.clean, '-000.123')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 4 digits in total.'", f.clean, '-000.12345')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a number.'", f.clean, '--0.12')
 
     def test_decimalfield_14(self):
         f = DecimalField(max_digits=4, decimal_places=2, required=False)
@@ -231,8 +224,8 @@
 
     def test_decimalfield_15(self):
         f = DecimalField(max_digits=4, decimal_places=2, max_value=Decimal('1.5'), min_value=Decimal('0.5'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 1.5.']", f.clean, '1.6')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is greater than or equal to 0.5.']", f.clean, '0.4')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is less than or equal to 1.5.'", f.clean, '1.6')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value is greater than or equal to 0.5.'", f.clean, '0.4')
         self.assertEqual(f.clean('1.5'), Decimal("1.5"))
         self.assertEqual(f.clean('0.5'), Decimal("0.5"))
         self.assertEqual(f.clean('.5'), Decimal("0.5"))
@@ -240,7 +233,7 @@
 
     def test_decimalfield_16(self):
         f = DecimalField(decimal_places=2)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 2 decimal places.']", f.clean, '0.00000001')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 2 decimal places.'", f.clean, '0.00000001')
 
     def test_decimalfield_17(self):
         f = DecimalField(max_digits=3)
@@ -250,13 +243,13 @@
         self.assertEqual(f.clean('0000000.100'), Decimal("0.100"))
         # Only leading whole zeros "collapse" to one digit.
         self.assertEqual(f.clean('000000.02'), Decimal('0.02'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 3 digits in total.']", f.clean, '000000.0002')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 3 digits in total.'", f.clean, '000000.0002')
         self.assertEqual(f.clean('.002'), Decimal("0.002"))
 
     def test_decimalfield_18(self):
         f = DecimalField(max_digits=2, decimal_places=2)
         self.assertEqual(f.clean('.01'), Decimal(".01"))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 0 digits before the decimal point.']", f.clean, '1.1')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure that there are no more than 0 digits before the decimal point.'", f.clean, '1.1')
 
     # DateField ###################################################################
 
@@ -274,10 +267,10 @@
         self.assertEqual(datetime.date(2006, 10, 25), f.clean('October 25, 2006'))
         self.assertEqual(datetime.date(2006, 10, 25), f.clean('25 October 2006'))
         self.assertEqual(datetime.date(2006, 10, 25), f.clean('25 October, 2006'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '2006-4-31')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '200a-10-25')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '25/10/06')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, '2006-4-31')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, '200a-10-25')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, '25/10/06')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
 
     def test_datefield_20(self):
         f = DateField(required=False)
@@ -291,9 +284,9 @@
         self.assertEqual(datetime.date(2006, 10, 25), f.clean(datetime.date(2006, 10, 25)))
         self.assertEqual(datetime.date(2006, 10, 25), f.clean(datetime.datetime(2006, 10, 25, 14, 30)))
         self.assertEqual(datetime.date(2006, 10, 25), f.clean('2006 10 25'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '2006-10-25')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '10/25/2006')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, '10/25/06')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, '2006-10-25')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, '10/25/2006')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, '10/25/06')
 
     # TimeField ###################################################################
 
@@ -303,8 +296,8 @@
         self.assertEqual(datetime.time(14, 25, 59), f.clean(datetime.time(14, 25, 59)))
         self.assertEqual(datetime.time(14, 25), f.clean('14:25'))
         self.assertEqual(datetime.time(14, 25, 59), f.clean('14:25:59'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, 'hello')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, '1:24 p.m.')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid time.'", f.clean, 'hello')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid time.'", f.clean, '1:24 p.m.')
 
     def test_timefield_23(self):
         f = TimeField(input_formats=['%I:%M %p'])
@@ -312,7 +305,7 @@
         self.assertEqual(datetime.time(14, 25, 59), f.clean(datetime.time(14, 25, 59)))
         self.assertEqual(datetime.time(4, 25), f.clean('4:25 AM'))
         self.assertEqual(datetime.time(16, 25), f.clean('4:25 PM'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, '14:30:45')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid time.'", f.clean, '14:30:45')
 
     # DateTimeField ###############################################################
 
@@ -334,8 +327,8 @@
         self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30), f.clean('10/25/06 14:30:00'))
         self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30), f.clean('10/25/06 14:30'))
         self.assertEqual(datetime.datetime(2006, 10, 25, 0, 0), f.clean('10/25/06'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, 'hello')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, '2006-10-25 4:30 p.m.')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date/time.'", f.clean, 'hello')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date/time.'", f.clean, '2006-10-25 4:30 p.m.')
 
     def test_datetimefield_25(self):
         f = DateTimeField(input_formats=['%Y %m %d %I:%M %p'])
@@ -344,7 +337,7 @@
         self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30, 59), f.clean(datetime.datetime(2006, 10, 25, 14, 30, 59)))
         self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30, 59, 200), f.clean(datetime.datetime(2006, 10, 25, 14, 30, 59, 200)))
         self.assertEqual(datetime.datetime(2006, 10, 25, 14, 30), f.clean('2006 10 25 2:30 PM'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, '2006-10-25 14:30:45')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date/time.'", f.clean, '2006-10-25 14:30:45')
 
     def test_datetimefield_26(self):
         f = DateTimeField(required=False)
@@ -359,67 +352,67 @@
         f = RegexField('^\d[A-F]\d$')
         self.assertEqual(u'2A2', f.clean('2A2'))
         self.assertEqual(u'3F3', f.clean('3F3'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '3G3')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, ' 2A2')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '2A2 ')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid value.'", f.clean, '3G3')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid value.'", f.clean, ' 2A2')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid value.'", f.clean, '2A2 ')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
 
     def test_regexfield_28(self):
         f = RegexField('^\d[A-F]\d$', required=False)
         self.assertEqual(u'2A2', f.clean('2A2'))
         self.assertEqual(u'3F3', f.clean('3F3'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '3G3')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid value.'", f.clean, '3G3')
         self.assertEqual(u'', f.clean(''))
 
     def test_regexfield_29(self):
         f = RegexField(re.compile('^\d[A-F]\d$'))
         self.assertEqual(u'2A2', f.clean('2A2'))
         self.assertEqual(u'3F3', f.clean('3F3'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '3G3')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, ' 2A2')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '2A2 ')
+        self.assertRaisesRegexp(ValidationError, "'Enter a valid value.'", f.clean, '3G3')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid value.'", f.clean, ' 2A2')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid value.'", f.clean, '2A2 ')
 
     def test_regexfield_30(self):
         f = RegexField('^\d\d\d\d$', error_message='Enter a four-digit number.')
         self.assertEqual(u'1234', f.clean('1234'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a four-digit number.']", f.clean, '123')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a four-digit number.']", f.clean, 'abcd')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a four-digit number.'", f.clean, '123')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a four-digit number.'", f.clean, 'abcd')
 
     def test_regexfield_31(self):
         f = RegexField('^\d+$', min_length=5, max_length=10)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at least 5 characters (it has 3).']", f.clean, '123')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at least 5 characters (it has 3).', u'Enter a valid value.']", f.clean, 'abc')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at least 5 characters \(it has 3\).'", f.clean, '123')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at least 5 characters \(it has 3\).', u'Enter a valid value.'", f.clean, 'abc')
         self.assertEqual(u'12345', f.clean('12345'))
         self.assertEqual(u'1234567890', f.clean('1234567890'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 10 characters (it has 11).']", f.clean, '12345678901')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '12345a')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at most 10 characters \(it has 11\).'", f.clean, '12345678901')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid value.'", f.clean, '12345a')
 
     # EmailField ##################################################################
 
     def test_emailfield_32(self):
         f = EmailField()
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(u'person@example.com', f.clean('person@example.com'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@bar')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@invalid-.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@-invalid.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@inv-.alid-.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@inv-.-alid.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'foo')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'foo@')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'foo@bar')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'example@invalid-.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'example@-invalid.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'example@inv-.alid-.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'example@inv-.-alid.com')
         self.assertEqual(u'example@valid-----hyphens.com', f.clean('example@valid-----hyphens.com'))
         self.assertEqual(u'example@valid-with-hyphens.com', f.clean('example@valid-with-hyphens.com'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'example@.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'example@.com')
         self.assertEqual(u'local@domain.with.idn.xyz\xe4\xf6\xfc\xdfabc.part.com', f.clean('local@domain.with.idn.xyzäöüßabc.part.com'))
 
     def test_email_regexp_for_performance(self):
         f = EmailField()
         # Check for runaway regex security problem. This will take for-freeking-ever
         # if the security fix isn't in place.
-        self.assertRaisesErrorWithMessage(
+        self.assertRaisesRegexp(
                 ValidationError,
-                "[u'Enter a valid e-mail address.']",
+                "u'Enter a valid e-mail address.'",
                 f.clean,
                 'viewx3dtextx26qx3d@yahoo.comx26latlngx3d15854521645943074058'
             )
@@ -430,39 +423,39 @@
         self.assertEqual(u'', f.clean(None))
         self.assertEqual(u'person@example.com', f.clean('person@example.com'))
         self.assertEqual(u'example@example.com', f.clean('      example@example.com  \t   \t '))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'foo@bar')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'foo')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'foo@')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'foo@bar')
 
     def test_emailfield_34(self):
         f = EmailField(min_length=10, max_length=15)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at least 10 characters (it has 9).']", f.clean, 'a@foo.com')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at least 10 characters \(it has 9\).'", f.clean, 'a@foo.com')
         self.assertEqual(u'alf@foo.com', f.clean('alf@foo.com'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 15 characters (it has 20).']", f.clean, 'alf123456788@foo.com')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at most 15 characters \(it has 20\).'", f.clean, 'alf123456788@foo.com')
 
     # FileField ##################################################################
 
     def test_filefield_35(self):
         f = FileField()
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '', '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '', '')
         self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None, '')
         self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', ''))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, SimpleUploadedFile('', ''), '')
+        self.assertRaisesRegexp(ValidationError, "u'No file was submitted. Check the encoding type on the form.'", f.clean, SimpleUploadedFile('', ''))
+        self.assertRaisesRegexp(ValidationError, "u'No file was submitted. Check the encoding type on the form.'", f.clean, SimpleUploadedFile('', ''), '')
         self.assertEqual('files/test3.pdf', f.clean(None, 'files/test3.pdf'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'No file was submitted. Check the encoding type on the form.']", f.clean, 'some content that is not a file')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'The submitted file is empty.']", f.clean, SimpleUploadedFile('name', None))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'The submitted file is empty.']", f.clean, SimpleUploadedFile('name', ''))
+        self.assertRaisesRegexp(ValidationError, "u'No file was submitted. Check the encoding type on the form.'", f.clean, 'some content that is not a file')
+        self.assertRaisesRegexp(ValidationError, "u'The submitted file is empty.'", f.clean, SimpleUploadedFile('name', None))
+        self.assertRaisesRegexp(ValidationError, "u'The submitted file is empty.'", f.clean, SimpleUploadedFile('name', ''))
         self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', 'Some File Content'))))
         self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('我隻氣墊船裝滿晒鱔.txt', 'मेरी मँडराने वाली नाव सर्पमीनों से भरी ह'))))
         self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', 'Some File Content'), 'files/test4.pdf')))
 
     def test_filefield_36(self):
         f = FileField(max_length = 5)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this filename has at most 5 characters (it has 18).']", f.clean, SimpleUploadedFile('test_maxlength.txt', 'hello world'))
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this filename has at most 5 characters \(it has 18\).'", f.clean, SimpleUploadedFile('test_maxlength.txt', 'hello world'))
         self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
         self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
         self.assertEqual(SimpleUploadedFile, type(f.clean(SimpleUploadedFile('name', 'Some File Content'))))
@@ -471,8 +464,8 @@
 
     def test_urlfield_37(self):
         f = URLField()
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(u'http://localhost/', f.clean('http://localhost'))
         self.assertEqual(u'http://example.com/', f.clean('http://example.com'))
         self.assertEqual(u'http://example.com./', f.clean('http://example.com.'))
@@ -482,28 +475,28 @@
         self.assertEqual(u'http://subdomain.domain.com/', f.clean('subdomain.domain.com'))
         self.assertEqual(u'http://200.8.9.10/', f.clean('http://200.8.9.10'))
         self.assertEqual(u'http://200.8.9.10:8000/test', f.clean('http://200.8.9.10:8000/test'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'foo')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example.')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'com.')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, '.')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://invalid-.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://-invalid.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://inv-.alid-.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://inv-.-alid.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'foo')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://example')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://example.')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'com.')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, '.')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://invalid-.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://-invalid.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://inv-.alid-.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://inv-.-alid.com')
         self.assertEqual(u'http://valid-----hyphens.com/', f.clean('http://valid-----hyphens.com'))
         self.assertEqual(u'http://some.idn.xyz\xe4\xf6\xfc\xdfabc.domain.com:123/blah', f.clean('http://some.idn.xyzäöüßabc.domain.com:123/blah'))
 
     def test_url_regex_ticket11198(self):
         f = URLField()
         # hangs "forever" if catastrophic backtracking in ticket:#11198 not fixed
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://%s' % ("X"*200,))
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://%s' % ("X"*200,))
 
         # a second test, to make sure the problem is really addressed, even on
         # domains that don't fail the domain label length check in the regex
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://%s' % ("X"*60,))
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://%s' % ("X"*60,))
 
     def test_urlfield_38(self):
         f = URLField(required=False)
@@ -511,16 +504,16 @@
         self.assertEqual(u'', f.clean(None))
         self.assertEqual(u'http://example.com/', f.clean('http://example.com'))
         self.assertEqual(u'http://www.example.com/', f.clean('http://www.example.com'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'foo')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example.')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'foo')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://example')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://example.')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://.com')
 
     def test_urlfield_39(self):
         f = URLField(verify_exists=True)
         self.assertEqual(u'http://www.google.com/', f.clean('http://www.google.com')) # This will fail if there's no Internet connection
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid URL.']", f.clean, 'http://example')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid URL.'", f.clean, 'http://example')
         self.assertRaises(ValidationError, f.clean, 'http://www.broken.djangoproject.com') # bad domain
         try:
             f.clean('http://www.broken.djangoproject.com') # bad domain
@@ -546,9 +539,9 @@
 
     def test_urlfield_41(self):
         f = URLField(min_length=15, max_length=20)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at least 15 characters (it has 13).']", f.clean, 'http://f.com')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at least 15 characters \(it has 13\).'", f.clean, 'http://f.com')
         self.assertEqual(u'http://example.com/', f.clean('http://example.com'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 20 characters (it has 38).']", f.clean, 'http://abcdefghijklmnopqrstuvwxyz.com')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at most 20 characters \(it has 38\).'", f.clean, 'http://abcdefghijklmnopqrstuvwxyz.com')
 
     def test_urlfield_42(self):
         f = URLField(required=False)
@@ -569,15 +562,15 @@
 
     def test_booleanfield_44(self):
         f = BooleanField()
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(True, f.clean(True))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, False)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, False)
         self.assertEqual(True, f.clean(1))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, 0)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, 0)
         self.assertEqual(True, f.clean('Django rocks'))
         self.assertEqual(True, f.clean('True'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, 'False')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, 'False')
 
     def test_booleanfield_45(self):
         f = BooleanField(required=False)
@@ -596,11 +589,11 @@
 
     def test_choicefield_46(self):
         f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual(u'1', f.clean(1))
         self.assertEqual(u'1', f.clean('1'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, '3')
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 3 is not one of the available choices.'", f.clean, '3')
 
     def test_choicefield_47(self):
         f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
@@ -608,12 +601,12 @@
         self.assertEqual(u'', f.clean(None))
         self.assertEqual(u'1', f.clean(1))
         self.assertEqual(u'1', f.clean('1'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, '3')
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 3 is not one of the available choices.'", f.clean, '3')
 
     def test_choicefield_48(self):
         f = ChoiceField(choices=[('J', 'John'), ('P', 'Paul')])
         self.assertEqual(u'J', f.clean('J'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. John is not one of the available choices.']", f.clean, 'John')
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. John is not one of the available choices.'", f.clean, 'John')
 
     def test_choicefield_49(self):
         f = ChoiceField(choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3','A'),('4','B'))), ('5','Other')])
@@ -623,7 +616,7 @@
         self.assertEqual(u'3', f.clean('3'))
         self.assertEqual(u'5', f.clean(5))
         self.assertEqual(u'5', f.clean('5'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, '6')
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 6 is not one of the available choices.'", f.clean, '6')
 
     # TypedChoiceField ############################################################
     # TypedChoiceField is just like ChoiceField, except that coerced types will
@@ -632,7 +625,7 @@
     def test_typedchoicefield_50(self):
         f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
         self.assertEqual(1, f.clean('1'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 2 is not one of the available choices.']", f.clean, '2')
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 2 is not one of the available choices.'", f.clean, '2')
 
     def test_typedchoicefield_51(self):
         # Different coercion, same validation.
@@ -648,9 +641,9 @@
         # Even more weirdness: if you have a valid choice but your coercion function
         # can't coerce, you'll still get a validation error. Don't do this!
         f = TypedChoiceField(choices=[('A', 'A'), ('B', 'B')], coerce=int)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. B is not one of the available choices.']", f.clean, 'B')
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. B is not one of the available choices.'", f.clean, 'B')
         # Required fields require values
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
 
     def test_typedchoicefield_54(self):
         # Non-required fields aren't required
@@ -712,17 +705,17 @@
 
     def test_multiplechoicefield_60(self):
         f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
         self.assertEqual([u'1'], f.clean([1]))
         self.assertEqual([u'1'], f.clean(['1']))
         self.assertEqual([u'1', u'2'], f.clean(['1', '2']))
         self.assertEqual([u'1', u'2'], f.clean([1, '2']))
         self.assertEqual([u'1', u'2'], f.clean((1, '2')))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, [])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, ())
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, ['3'])
+        self.assertRaisesRegexp(ValidationError, "u'Enter a list of values.'", f.clean, 'hello')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, [])
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, ())
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 3 is not one of the available choices.'", f.clean, ['3'])
 
     def test_multiplechoicefield_61(self):
         f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
@@ -733,10 +726,10 @@
         self.assertEqual([u'1', u'2'], f.clean(['1', '2']))
         self.assertEqual([u'1', u'2'], f.clean([1, '2']))
         self.assertEqual([u'1', u'2'], f.clean((1, '2')))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a list of values.'", f.clean, 'hello')
         self.assertEqual([], f.clean([]))
         self.assertEqual([], f.clean(()))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, ['3'])
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 3 is not one of the available choices.'", f.clean, ['3'])
 
     def test_multiplechoicefield_62(self):
         f = MultipleChoiceField(choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3','A'),('4','B'))), ('5','Other')])
@@ -746,24 +739,24 @@
         self.assertEqual([u'1', u'5'], f.clean([1, '5']))
         self.assertEqual([u'1', u'5'], f.clean(['1', 5]))
         self.assertEqual([u'1', u'5'], f.clean(['1', '5']))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, ['6'])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 6 is not one of the available choices.']", f.clean, ['1','6'])
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 6 is not one of the available choices.'", f.clean, ['6'])
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. 6 is not one of the available choices.'", f.clean, ['1','6'])
 
     # ComboField ##################################################################
 
     def test_combofield_63(self):
         f = ComboField(fields=[CharField(max_length=20), EmailField()])
         self.assertEqual(u'test@example.com', f.clean('test@example.com'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 20 characters (it has 28).']", f.clean, 'longemailaddress@example.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'not an e-mail')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at most 20 characters \(it has 28\).'", f.clean, 'longemailaddress@example.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'not an e-mail')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "u'This field is required.'", f.clean, None)
 
     def test_combofield_64(self):
         f = ComboField(fields=[CharField(max_length=20), EmailField()], required=False)
         self.assertEqual(u'test@example.com', f.clean('test@example.com'))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 20 characters (it has 28).']", f.clean, 'longemailaddress@example.com')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid e-mail address.']", f.clean, 'not an e-mail')
+        self.assertRaisesRegexp(ValidationError, "u'Ensure this value has at most 20 characters \(it has 28\).'", f.clean, 'longemailaddress@example.com')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid e-mail address.'", f.clean, 'not an e-mail')
         self.assertEqual(u'', f.clean(''))
         self.assertEqual(u'', f.clean(None))
 
@@ -792,7 +785,7 @@
         for exp, got in zip(expected, fix_os_paths(f.choices)):
             self.assertEqual(exp[1], got[1])
             self.assertTrue(got[0].endswith(exp[0]))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. fields.py is not one of the available choices.']", f.clean, 'fields.py')
+        self.assertRaisesRegexp(ValidationError, "u'Select a valid choice. fields.py is not one of the available choices.'", f.clean, 'fields.py')
         assert fix_os_paths(f.clean(path + 'fields.py')).endswith('/django/forms/fields.py')
 
     def test_filepathfield_67(self):
@@ -840,12 +833,12 @@
         f = SplitDateTimeField()
         assert isinstance(f.widget, SplitDateTimeWidget)
         self.assertEqual(datetime.datetime(2006, 1, 10, 7, 30), f.clean([datetime.date(2006, 1, 10), datetime.time(7, 30)]))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.', u'Enter a valid time.']", f.clean, ['hello', 'there'])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10', 'there'])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, ['hello', '07:30'])
+        self.assertRaisesRegexp(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesRegexp(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesRegexp(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
+        self.assertRaisesRegexp(ValidationError, "[u'Enter a valid date.', u'Enter a valid time.']", f.clean, ['hello', 'there'])
+        self.assertRaisesRegexp(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10', 'there'])
+        self.assertRaisesRegexp(ValidationError, "[u'Enter a valid date.']", f.clean, ['hello', '07:30'])
 
     def test_splitdatetimefield_70(self):
         f = SplitDateTimeField(required=False)
@@ -855,10 +848,10 @@
         self.assertEqual(None, f.clean(''))
         self.assertEqual(None, f.clean(['']))
         self.assertEqual(None, f.clean(['', '']))
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.', u'Enter a valid time.']", f.clean, ['hello', 'there'])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10', 'there'])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, ['hello', '07:30'])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10', ''])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, ['2006-01-10'])
-        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date.']", f.clean, ['', '07:30'])
+        self.assertRaisesRegexp(ValidationError, "u'Enter a list of values.'", f.clean, 'hello')
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.', u'Enter a valid time.'", f.clean, ['hello', 'there'])
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid time.'", f.clean, ['2006-01-10', 'there'])
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, ['hello', '07:30'])
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid time.'", f.clean, ['2006-01-10', ''])
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid time.'", f.clean, ['2006-01-10'])
+        self.assertRaisesRegexp(ValidationError, "u'Enter a valid date.'", f.clean, ['', '07:30'])
diff --git a/tests/regressiontests/forms/localflavor/be.py b/tests/regressiontests/forms/localflavor/be.py
--- a/tests/regressiontests/forms/localflavor/be.py
+++ b/tests/regressiontests/forms/localflavor/be.py
@@ -8,35 +8,28 @@
     """
     Test case to validate BE localflavor
     """
-    def assertRaisesErrorWithMessage(self, error, message, callable, *args, **kwargs):
-        self.assertRaises(error, callable, *args, **kwargs)
-        try:
-            callable(*args, **kwargs)
-        except error, e:
-            self.assertEqual(message, str(e))
-
     def test_postal_code_field(self):
         f = BEPostalCodeField()
         self.assertEqual(u'1451', f.clean('1451'))
         self.assertEqual(u'2540', f.clean('2540'))
-        err_message = "[u'Enter a valid postal code in the range and format 1XXX - 9XXX.']"
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '0287')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '14309')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '873')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '35 74')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '859A')
+        err_message = "\[u'Enter a valid postal code in the range and format 1XXX - 9XXX.'\]"
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '0287')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '14309')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '873')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '35 74')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '859A')
         err_message = "[u'This field is required.']"
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '')
         f = BEPostalCodeField(required=False)
         self.assertEqual(u'1451', f.clean('1451'))
         self.assertEqual(u'2540', f.clean('2540'))
         self.assertEqual(u'', f.clean(''))
-        err_message = "[u'Enter a valid postal code in the range and format 1XXX - 9XXX.']"
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '0287')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '14309')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '873')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '35 74')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '859A')
+        err_message = "\[u'Enter a valid postal code in the range and format 1XXX - 9XXX.'\]"
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '0287')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '14309')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '873')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '35 74')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '859A')
 
     def test_phone_number_field(self):
         f = BEPhoneNumberField()
@@ -51,17 +44,17 @@
         self.assertEqual(u'0412.34.56.78', f.clean('0412.34.56.78'))
         self.assertEqual(u'012345678', f.clean('012345678'))
         self.assertEqual(u'0412345678', f.clean('0412345678'))
-        err_message = "[u'Enter a valid phone number in one of the formats 0x xxx xx xx, 0xx xx xx xx, 04xx xx xx xx, 0x/xxx.xx.xx, 0xx/xx.xx.xx, 04xx/xx.xx.xx, 0xxxxxxxx, 04xxxxxxxx, 0x.xxx.xx.xx, 0xx.xx.xx.xx, 04xx.xx.xx.xx.']"
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '01234567')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '12/345.67.89')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/345.678.90')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/34.56.789')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '0123/45.67.89')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/345 678 90')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/34 56 789')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012.34 56 789')
-        err_message = "[u'This field is required.']"
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '')
+        err_message = "\[u'Enter a valid phone number in one of the formats 0x xxx xx xx, 0xx xx xx xx, 04xx xx xx xx, 0x/xxx.xx.xx, 0xx/xx.xx.xx, 04xx/xx.xx.xx, 0xxxxxxxx, 04xxxxxxxx, 0x.xxx.xx.xx, 0xx.xx.xx.xx, 04xx.xx.xx.xx.'\]"
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '01234567')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '12/345.67.89')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/345.678.90')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/34.56.789')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '0123/45.67.89')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/345 678 90')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/34 56 789')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012.34 56 789')
+        err_message = "\[u'This field is required.'\]"
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '')
         f = BEPhoneNumberField(required=False)
         self.assertEqual(u'01 234 56 78', f.clean('01 234 56 78'))
         self.assertEqual(u'01/234.56.78', f.clean('01/234.56.78'))
@@ -75,15 +68,15 @@
         self.assertEqual(u'012345678', f.clean('012345678'))
         self.assertEqual(u'0412345678', f.clean('0412345678'))
         self.assertEqual(u'', f.clean(''))
-        err_message = "[u'Enter a valid phone number in one of the formats 0x xxx xx xx, 0xx xx xx xx, 04xx xx xx xx, 0x/xxx.xx.xx, 0xx/xx.xx.xx, 04xx/xx.xx.xx, 0xxxxxxxx, 04xxxxxxxx, 0x.xxx.xx.xx, 0xx.xx.xx.xx, 04xx.xx.xx.xx.']"
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '01234567')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '12/345.67.89')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/345.678.90')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/34.56.789')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '0123/45.67.89')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/345 678 90')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012/34 56 789')
-        self.assertRaisesErrorWithMessage(ValidationError, err_message, f.clean, '012.34 56 789')
+        err_message = "\[u'Enter a valid phone number in one of the formats 0x xxx xx xx, 0xx xx xx xx, 04xx xx xx xx, 0x/xxx.xx.xx, 0xx/xx.xx.xx, 04xx/xx.xx.xx, 0xxxxxxxx, 04xxxxxxxx, 0x.xxx.xx.xx, 0xx.xx.xx.xx, 04xx.xx.xx.xx.'\]"
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '01234567')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '12/345.67.89')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/345.678.90')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/34.56.789')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '0123/45.67.89')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/345 678 90')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012/34 56 789')
+        self.assertRaisesRegexp(ValidationError, err_message, f.clean, '012.34 56 789')
 
     def test_phone_number_field(self):
         w = BERegionSelect()
diff --git a/tests/regressiontests/queries/tests.py b/tests/regressiontests/queries/tests.py
--- a/tests/regressiontests/queries/tests.py
+++ b/tests/regressiontests/queries/tests.py
@@ -21,13 +21,6 @@
     def assertValueQuerysetEqual(self, qs, values):
         return self.assertQuerysetEqual(qs, values, transform=lambda x: x)
 
-    def assertRaisesMessage(self, exc, msg, func, *args, **kwargs):
-        try:
-            func(*args, **kwargs)
-        except Exception, e:
-            self.assertEqual(msg, str(e))
-            self.assertTrue(isinstance(e, exc), "Expected %s, got %s" % (exc, type(e)))
-
 
 class Queries1Tests(BaseQuerysetTest):
     def setUp(self):
@@ -356,12 +349,12 @@
     def test_heterogeneous_qs_combination(self):
         # Combining querysets built on different models should behave in a well-defined
         # fashion. We raise an error.
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             AssertionError,
             'Cannot combine queries on two different base models.',
             lambda: Author.objects.all() & Tag.objects.all()
         )
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             AssertionError,
             'Cannot combine queries on two different base models.',
             lambda: Author.objects.all() | Tag.objects.all()
@@ -670,7 +663,7 @@
             []
         )
         q.query.low_mark = 1
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             AssertionError,
             'Cannot change a query once a slice has been taken',
             q.extra, select={'is_recent': "pub_date > '2006-01-01'"}
@@ -701,12 +694,12 @@
         )
 
         # Multi-valued values() and values_list() querysets should raise errors.
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             TypeError,
             'Cannot use a multi-field ValuesQuerySet as a filter value.',
             lambda: Tag.objects.filter(name__in=Tag.objects.filter(parent=self.t1).values('name', 'id'))
         )
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             TypeError,
             'Cannot use a multi-field ValuesListQuerySet as a filter value.',
             lambda: Tag.objects.filter(name__in=Tag.objects.filter(parent=self.t1).values_list('name', 'id'))
@@ -948,7 +941,7 @@
     def test_ticket8683(self):
         # Raise proper error when a DateQuerySet gets passed a wrong type of
         # field
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             AssertionError,
             "'name' isn't a DateField.",
             Item.objects.dates, 'name', 'month'
@@ -1461,7 +1454,7 @@
         self.assertQuerysetEqual(Article.objects.all()[0:0], [])
         self.assertQuerysetEqual(Article.objects.all()[0:0][:10], [])
         self.assertEqual(Article.objects.all()[:0].count(), 0)
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             AssertionError,
             'Cannot change a query once a slice has been taken.',
             Article.objects.all()[:0].latest, 'created'
@@ -1508,12 +1501,12 @@
     def test_infinite_loop(self):
         # If you're not careful, it's possible to introduce infinite loops via
         # default ordering on foreign keys in a cycle. We detect that.
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             FieldError,
             'Infinite loop caused by ordering.',
             LoopX.objects.all
         )
-        self.assertRaisesMessage(
+        self.assertRaisesRegexp(
             FieldError,
             'Infinite loop caused by ordering.',
             LoopZ.objects.all
diff --git a/tests/regressiontests/urlpatterns_reverse/tests.py b/tests/regressiontests/urlpatterns_reverse/tests.py
--- a/tests/regressiontests/urlpatterns_reverse/tests.py
+++ b/tests/regressiontests/urlpatterns_reverse/tests.py
@@ -133,21 +133,13 @@
 class NoURLPatternsTests(TestCase):
     urls = 'regressiontests.urlpatterns_reverse.no_urls'
 
-    def assertRaisesErrorWithMessage(self, error, message, callable,
-        *args, **kwargs):
-        self.assertRaises(error, callable, *args, **kwargs)
-        try:
-            callable(*args, **kwargs)
-        except error, e:
-            self.assertEqual(message, str(e))
-
     def test_no_urls_exception(self):
         """
         RegexURLResolver should raise an exception when no urlpatterns exist.
         """
         resolver = RegexURLResolver(r'^$', self.urls)
 
-        self.assertRaisesErrorWithMessage(ImproperlyConfigured,
+        self.assertRaisesRegexp(ImproperlyConfigured,
             "The included urlconf regressiontests.urlpatterns_reverse.no_urls "\
             "doesn't have any patterns in it", getattr, resolver, 'url_patterns')
 
diff --git a/tests/regressiontests/utils/datastructures.py b/tests/regressiontests/utils/datastructures.py
--- a/tests/regressiontests/utils/datastructures.py
+++ b/tests/regressiontests/utils/datastructures.py
@@ -2,22 +2,12 @@
 Tests for stuff in django.utils.datastructures.
 """
 import pickle
-import unittest
 
 from django.utils.datastructures import *
+from django.utils.unittest import TestCase
 
 
-class DatastructuresTestCase(unittest.TestCase):
-    def assertRaisesErrorWithMessage(self, error, message, callable,
-        *args, **kwargs):
-        self.assertRaises(error, callable, *args, **kwargs)
-        try:
-            callable(*args, **kwargs)
-        except error, e:
-            self.assertEqual(message, str(e))
-
-
-class SortedDictTests(DatastructuresTestCase):
+class SortedDictTests(TestCase):
     def setUp(self):
         self.d1 = SortedDict()
         self.d1[7] = 'seven'
@@ -123,7 +113,7 @@
         self.assertEquals(self.d1, {})
         self.assertEquals(self.d1.keyOrder, [])
 
-class MergeDictTests(DatastructuresTestCase):
+class MergeDictTests(TestCase):
 
     def test_simple_mergedict(self):
         d1 = {'chris':'cool', 'camri':'cute', 'cotton':'adorable',
@@ -177,7 +167,7 @@
                            ('key2', ['value2', 'value3']),
                            ('key4', ['value5', 'value6'])])
 
-class MultiValueDictTests(DatastructuresTestCase):
+class MultiValueDictTests(TestCase):
 
     def test_multivaluedict(self):
         d = MultiValueDict({'name': ['Adrian', 'Simon'],
@@ -196,9 +186,9 @@
         # MultiValueDictKeyError: "Key 'lastname' not found in
         # <MultiValueDict: {'position': ['Developer'],
         #                   'name': ['Adrian', 'Simon']}>"
-        self.assertRaisesErrorWithMessage(MultiValueDictKeyError,
-            '"Key \'lastname\' not found in <MultiValueDict: {\'position\':'\
-            ' [\'Developer\'], \'name\': [\'Adrian\', \'Simon\']}>"',
+        self.assertRaisesRegexp(MultiValueDictKeyError,
+            '"Key \'lastname\' not found in <MultiValueDict: \{\'position\':'\
+            ' \[\'Developer\'\], \'name\': \[\'Adrian\', \'Simon\'\]\}>"',
             d.__getitem__, 'lastname')
 
         self.assertEquals(d.get('lastname'), None)
@@ -212,7 +202,7 @@
                           ['Developer', 'Simon', 'Willison'])
 
 
-class DotExpandedDictTests(DatastructuresTestCase):
+class DotExpandedDictTests(TestCase):
 
     def test_dotexpandeddict(self):
 
@@ -226,13 +216,13 @@
         self.assertEquals(d['person']['2']['firstname'], ['Adrian'])
 
 
-class ImmutableListTests(DatastructuresTestCase):
+class ImmutableListTests(TestCase):
 
     def test_sort(self):
         d = ImmutableList(range(10))
 
         # AttributeError: ImmutableList object is immutable.
-        self.assertRaisesErrorWithMessage(AttributeError,
+        self.assertRaisesRegexp(AttributeError,
             'ImmutableList object is immutable.', d.sort)
 
         self.assertEquals(repr(d), '(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)')
@@ -243,11 +233,11 @@
         self.assertEquals(d[1], 1)
 
         # AttributeError: Object is immutable!
-        self.assertRaisesErrorWithMessage(AttributeError,
+        self.assertRaisesRegexp(AttributeError,
             'Object is immutable!', d.__setitem__, 1, 'test')
 
 
-class DictWrapperTests(DatastructuresTestCase):
+class DictWrapperTests(TestCase):
 
     def test_dictwrapper(self):
         f = lambda x: "*%s" % x
