[soc2009/model-validation] some test refactoring

git-svn-id: http://code.djangoproject.com/svn/django/branches/soc2009/model-validation@11086 bcc190cf-cafb-0310-a4f2-bffc1f526a37

1 files changed, 165 insertions, 790 deletions

diff --git a/tests/regressiontests/forms/fields_unit.py b/tests/regressiontests/forms/fields_unit.py
index 77e008facb..a8e4f285aa 100644
--- a/tests/regressiontests/forms/fields_unit.py
+++ b/tests/regressiontests/forms/fields_unit.py
@@ -28,20 +28,19 @@ def fix_os_paths(x):
 class TestFields(TestCase):
     # CharField ###################################################################
 
+    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_converted_0(self):
         f = CharField()
         self.assertEqual(u'1', f.clean(1))
         self.assertEqual(u'hello', f.clean('hello'))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
         self.assertEqual(u'[1, 2, 3]', f.clean([1, 2, 3]))
 
     def test_converted_1(self):
@@ -56,35 +55,19 @@ class TestFields(TestCase):
         f = CharField(max_length=10, required=False)
         self.assertEqual(u'12345', f.clean('12345'))
         self.assertEqual(u'1234567890', f.clean('1234567890'))
-        self.assertRaises(ValidationError, f.clean, '1234567890a')
-        try:
-            f.clean('1234567890a')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at most 10 characters (it has 11).']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 10 characters (it has 11).']", f.clean, '1234567890a')
 
     def test_converted_3(self):
         f = CharField(min_length=10, required=False)
         self.assertEqual(u'', f.clean(''))
-        self.assertRaises(ValidationError, f.clean, '12345')
-        try:
-            f.clean('12345')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at least 10 characters (it has 5).']", str(e))
+        self.assertRaisesErrorWithMessage(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_converted_4(self):
         f = CharField(min_length=10, required=True)
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '12345')
-        try:
-            f.clean('12345')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at least 10 characters (it has 5).']", str(e))
+        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.assertEqual(u'1234567890', f.clean('1234567890'))
         self.assertEqual(u'1234567890a', f.clean('1234567890a'))
 
@@ -92,38 +75,18 @@ class TestFields(TestCase):
 
     def test_converted_5(self):
         f = IntegerField()
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, 'a')
-        try:
-            f.clean('a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a whole number.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, 'a')
         self.assertEqual(42, f.clean(42))
-        self.assertRaises(ValidationError, f.clean, 3.14)
-        try:
-            f.clean(3.14)
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a whole number.']", str(e))
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, '1a')
-        try:
-            f.clean('1a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a whole number.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, '1a')
 
     def test_converted_6(self):
         f = IntegerField(required=False)
@@ -134,53 +97,25 @@ class TestFields(TestCase):
         self.assertEqual(1, f.clean('1'))
         self.assertEqual(True, isinstance(f.clean('1'), int))
         self.assertEqual(23, f.clean('23'))
-        self.assertRaises(ValidationError, f.clean, 'a')
-        try:
-            f.clean('a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a whole number.']", str(e))
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, '1a')
-        try:
-            f.clean('1a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a whole number.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a whole number.']", f.clean, '1a')
 
     def test_converted_7(self):
         f = IntegerField(max_value=10)
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
         self.assertEqual(1, f.clean(1))
         self.assertEqual(10, f.clean(10))
-        self.assertRaises(ValidationError, f.clean, 11)
-        try:
-            f.clean(11)
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is less than or equal to 10.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 10.']", f.clean, 11)
         self.assertEqual(10, f.clean('10'))
-        self.assertRaises(ValidationError, f.clean, '11')
-        try:
-            f.clean('11')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is less than or equal to 10.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 10.']", f.clean, '11')
 
     def test_converted_8(self):
         f = IntegerField(min_value=10)
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 1)
-        try:
-            f.clean(1)
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is greater than or equal to 10.']", str(e))
+        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.assertEqual(10, f.clean(10))
         self.assertEqual(11, f.clean(11))
         self.assertEqual(10, f.clean('10'))
@@ -188,60 +123,32 @@ class TestFields(TestCase):
 
     def test_converted_9(self):
         f = IntegerField(min_value=10, max_value=20)
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 1)
-        try:
-            f.clean(1)
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is greater than or equal to 10.']", str(e))
+        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.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.assertRaises(ValidationError, f.clean, 21)
-        try:
-            f.clean(21)
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is less than or equal to 20.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value is less than or equal to 20.']", f.clean, 21)
 
     # FloatField ##################################################################
 
     def test_converted_10(self):
         f = FloatField()
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, 'a')
-        try:
-            f.clean('a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a number.']", str(e))
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, '1.0a')
-        try:
-            f.clean('1.0a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a number.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, '1.0a')
 
     def test_converted_11(self):
         f = FloatField(required=False)
@@ -251,16 +158,8 @@ class TestFields(TestCase):
 
     def test_converted_12(self):
         f = FloatField(max_value=1.5, min_value=0.5)
-        self.assertRaises(ValidationError, f.clean, '1.6')
-        try:
-            f.clean('1.6')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is less than or equal to 1.5.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '0.4')
-        try:
-            f.clean('0.4')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is greater than or equal to 0.5.']", str(e))
+        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.assertEqual(1.5, f.clean('1.5'))
         self.assertEqual(0.5, f.clean('0.5'))
     
@@ -268,79 +167,31 @@ class TestFields(TestCase):
 
     def test_converted_13(self):
         f = DecimalField(max_digits=4, decimal_places=2)
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
         self.assertEqual(True, f.clean('1') == Decimal("1"))
         self.assertEqual(True, isinstance(f.clean('1'), Decimal))
         self.assertEqual(True, f.clean('23') == Decimal("23"))
         self.assertEqual(True, f.clean('3.14') == Decimal("3.14"))
         self.assertEqual(True, f.clean(3.14) == Decimal("3.14"))
         self.assertEqual(True, f.clean(Decimal('3.14')) == Decimal("3.14"))
-        self.assertRaises(ValidationError, f.clean, 'a')
-        try:
-            f.clean('a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a number.']", str(e))
-        self.assertRaises(ValidationError, f.clean, u'łąść')
-        try:
-            f.clean(u'łąść')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a number.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, 'a')
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a number.']", f.clean, u'łąść')
         self.assertEqual(True, f.clean('1.0 ') == Decimal("1.0"))
         self.assertEqual(True, f.clean(' 1.0') == Decimal("1.0"))
         self.assertEqual(True, f.clean(' 1.0 ') == Decimal("1.0"))
-        self.assertRaises(ValidationError, f.clean, '1.0a')
-        try:
-            f.clean('1.0a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a number.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '123.45')
-        try:
-            f.clean('123.45')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 4 digits in total.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '1.234')
-        try:
-            f.clean('1.234')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 2 decimal places.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '123.4')
-        try:
-            f.clean('123.4')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 2 digits before the decimal point.']", str(e))
+        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.assertEqual(True, f.clean('-12.34') == Decimal("-12.34"))
-        self.assertRaises(ValidationError, f.clean, '-123.45')
-        try:
-            f.clean('-123.45')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 4 digits in total.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 4 digits in total.']", f.clean, '-123.45')
         self.assertEqual(True, f.clean('-.12') == Decimal("-0.12"))
         self.assertEqual(True, f.clean('-00.12') == Decimal("-0.12"))
         self.assertEqual(True, f.clean('-000.12') == Decimal("-0.12"))
-        self.assertRaises(ValidationError, f.clean, '-000.123')
-        try:
-            f.clean('-000.123')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 2 decimal places.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '-000.12345')
-        try:
-            f.clean('-000.12345')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 4 digits in total.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '--0.12')
-        try:
-            f.clean('--0.12')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a number.']", str(e))
+        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')
 
     def test_converted_14(self):
         f = DecimalField(max_digits=4, decimal_places=2, required=False)
@@ -350,16 +201,8 @@ class TestFields(TestCase):
 
     def test_converted_15(self):
         f = DecimalField(max_digits=4, decimal_places=2, max_value=Decimal('1.5'), min_value=Decimal('0.5'))
-        self.assertRaises(ValidationError, f.clean, '1.6')
-        try:
-            f.clean('1.6')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is less than or equal to 1.5.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '0.4')
-        try:
-            f.clean('0.4')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value is greater than or equal to 0.5.']", str(e))
+        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.assertEqual(True, f.clean('1.5') == Decimal("1.5"))
         self.assertEqual(True, f.clean('0.5') == Decimal("0.5"))
         self.assertEqual(True, f.clean('.5') == Decimal("0.5"))
@@ -367,11 +210,7 @@ class TestFields(TestCase):
 
     def test_converted_16(self):
         f = DecimalField(decimal_places=2)
-        self.assertRaises(ValidationError, f.clean, '0.00000001')
-        try:
-            f.clean('0.00000001')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 2 decimal places.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 2 decimal places.']", f.clean, '0.00000001')
 
     def test_converted_17(self):
         f = DecimalField(max_digits=3)
@@ -381,21 +220,13 @@ class TestFields(TestCase):
         self.assertEqual(True, f.clean('0000000.100') == Decimal("0.100"))
         # Only leading whole zeros "collapse" to one digit.
         self.assertEqual(True, f.clean('000000.02') == Decimal('0.02'))
-        self.assertRaises(ValidationError, f.clean, '000000.0002')
-        try:
-            f.clean('000000.0002')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 3 digits in total.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 3 digits in total.']", f.clean, '000000.0002')
         self.assertEqual(True, f.clean('.002') == Decimal("0.002"))
 
     def test_converted_18(self):
         f = DecimalField(max_digits=2, decimal_places=2)
         self.assertEqual(True, f.clean('.01') == Decimal(".01"))
-        self.assertRaises(ValidationError, f.clean, '1.1')
-        try:
-            f.clean('1.1')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure that there are no more than 0 digits before the decimal point.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure that there are no more than 0 digits before the decimal point.']", f.clean, '1.1')
 
     # DateField ###################################################################
 
@@ -413,26 +244,10 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, '2006-4-31')
-        try:
-            f.clean('2006-4-31')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '200a-10-25')
-        try:
-            f.clean('200a-10-25')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '25/10/06')
-        try:
-            f.clean('25/10/06')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        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)
 
     def test_converted_20(self):
         f = DateField(required=False)
@@ -446,21 +261,9 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, '2006-10-25')
-        try:
-            f.clean('2006-10-25')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '10/25/2006')
-        try:
-            f.clean('10/25/2006')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '10/25/06')
-        try:
-            f.clean('10/25/06')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
+        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')
 
     # TimeField ###################################################################
 
@@ -470,16 +273,8 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, 'hello')
-        try:
-            f.clean('hello')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '1:24 p.m.')
-        try:
-            f.clean('1:24 p.m.')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid time.']", str(e))
+        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.')
 
     def test_converted_23(self):
         f = TimeField(input_formats=['%I:%M %p'])
@@ -487,11 +282,7 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, '14:30:45')
-        try:
-            f.clean('14:30:45')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid time.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid time.']", f.clean, '14:30:45')
 
     # DateTimeField ###############################################################
 
@@ -513,16 +304,8 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, 'hello')
-        try:
-            f.clean('hello')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date/time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '2006-10-25 4:30 p.m.')
-        try:
-            f.clean('2006-10-25 4:30 p.m.')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date/time.']", str(e))
+        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.')
 
     def test_converted_25(self):
         f = DateTimeField(input_formats=['%Y %m %d %I:%M %p'])
@@ -531,11 +314,7 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, '2006-10-25 14:30:45')
-        try:
-            f.clean('2006-10-25 14:30:45')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date/time.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid date/time.']", f.clean, '2006-10-25 14:30:45')
 
     def test_converted_26(self):
         f = DateTimeField(required=False)
@@ -550,147 +329,55 @@ class TestFields(TestCase):
         f = RegexField('^\d[A-F]\d$')
         self.assertEqual(u'2A2', f.clean('2A2'))
         self.assertEqual(u'3F3', f.clean('3F3'))
-        self.assertRaises(ValidationError, f.clean, '3G3')
-        try:
-            f.clean('3G3')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ' 2A2')
-        try:
-            f.clean(' 2A2')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '2A2 ')
-        try:
-            f.clean('2A2 ')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        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, '')
 
     def test_converted_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.assertRaises(ValidationError, f.clean, '3G3')
-        try:
-            f.clean('3G3')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a valid value.']", f.clean, '3G3')
         self.assertEqual(u'', f.clean(''))
 
     def test_converted_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.assertRaises(ValidationError, f.clean, '3G3')
-        try:
-            f.clean('3G3')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ' 2A2')
-        try:
-            f.clean(' 2A2')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '2A2 ')
-        try:
-            f.clean('2A2 ')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
+        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 ')
 
     def test_converted_30(self):
         f = RegexField('^\d\d\d\d$', error_message='Enter a four-digit number.')
         self.assertEqual(u'1234', f.clean('1234'))
-        self.assertRaises(ValidationError, f.clean, '123')
-        try:
-            f.clean('123')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a four-digit number.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'abcd')
-        try:
-            f.clean('abcd')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a four-digit number.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a four-digit number.']", f.clean, '123')
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a four-digit number.']", f.clean, 'abcd')
 
     def test_converted_31(self):
         f = RegexField('^\d+$', min_length=5, max_length=10)
-        self.assertRaises(ValidationError, f.clean, '123')
-        try:
-            f.clean('123')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at least 5 characters (it has 3).']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'abc')
-        try:
-            f.clean('abc')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at least 5 characters (it has 3).']", str(e))
+        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).']", f.clean, 'abc')
         self.assertEqual(u'12345', f.clean('12345'))
         self.assertEqual(u'1234567890', f.clean('1234567890'))
-        self.assertRaises(ValidationError, f.clean, '12345678901')
-        try:
-            f.clean('12345678901')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at most 10 characters (it has 11).']", str(e))
-        self.assertRaises(ValidationError, f.clean, '12345a')
-        try:
-            f.clean('12345a')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid value.']", str(e))
+        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')
 
     # EmailField ##################################################################
 
     def test_converted_32(self):
         f = EmailField()
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
         self.assertEqual(u'person@example.com', f.clean('person@example.com'))
-        self.assertRaises(ValidationError, f.clean, 'foo')
-        try:
-            f.clean('foo')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'foo@')
-        try:
-            f.clean('foo@')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'foo@bar')
-        try:
-            f.clean('foo@bar')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'example@invalid-.com')
-        try:
-            f.clean('example@invalid-.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'example@-invalid.com')
-        try:
-            f.clean('example@-invalid.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'example@inv-.alid-.com')
-        try:
-            f.clean('example@inv-.alid-.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'example@inv-.-alid.com')
-        try:
-            f.clean('example@inv-.-alid.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
+        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.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'))
 
@@ -699,99 +386,39 @@ class TestFields(TestCase):
         self.assertEqual(u'', f.clean(''))
         self.assertEqual(u'', f.clean(None))
         self.assertEqual(u'person@example.com', f.clean('person@example.com'))
-        self.assertRaises(ValidationError, f.clean, 'foo')
-        try:
-            f.clean('foo')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'foo@')
-        try:
-            f.clean('foo@')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'foo@bar')
-        try:
-            f.clean('foo@bar')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
+        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')
 
     def test_converted_34(self):
         f = EmailField(min_length=10, max_length=15)
-        self.assertRaises(ValidationError, f.clean, 'a@foo.com')
-        try:
-            f.clean('a@foo.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at least 10 characters (it has 9).']", str(e))
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, 'alf123456788@foo.com')
-        try:
-            f.clean('alf123456788@foo.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at most 15 characters (it has 20).']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 15 characters (it has 20).']", f.clean, 'alf123456788@foo.com')
 
     # FileField ##################################################################
 
     def test_converted_35(self):
         f = FileField()
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '', '')
-        try:
-            f.clean('', '')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '', '')
         self.assertEqual('files/test1.pdf', f.clean('', 'files/test1.pdf'))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None, '')
-        try:
-            f.clean(None, '')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None, '')
         self.assertEqual('files/test2.pdf', f.clean(None, 'files/test2.pdf'))
-        self.assertRaises(ValidationError, f.clean, SimpleUploadedFile('', ''))
-        try:
-            f.clean(SimpleUploadedFile('', ''))
-        except ValidationError, e:
-            self.assertEqual("[u'No file was submitted. Check the encoding type on the form.']", str(e))
-        self.assertRaises(ValidationError, f.clean, SimpleUploadedFile('', ''), '')
-        try:
-            f.clean(SimpleUploadedFile('', ''), '')
-        except ValidationError, e:
-            self.assertEqual("[u'No file was submitted. Check the encoding type on the form.']", str(e))
+        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.assertEqual('files/test3.pdf', f.clean(None, 'files/test3.pdf'))
-        self.assertRaises(ValidationError, f.clean, 'some content that is not a file')
-        try:
-            f.clean('some content that is not a file')
-        except ValidationError, e:
-            self.assertEqual("[u'No file was submitted. Check the encoding type on the form.']", str(e))
-        self.assertRaises(ValidationError, f.clean, SimpleUploadedFile('name', None))
-        try:
-            f.clean(SimpleUploadedFile('name', None))
-        except ValidationError, e:
-            self.assertEqual("[u'The submitted file is empty.']", str(e))
-        self.assertRaises(ValidationError, f.clean, SimpleUploadedFile('name', ''))
-        try:
-            f.clean(SimpleUploadedFile('name', ''))
-        except ValidationError, e:
-            self.assertEqual("[u'The submitted file is empty.']", str(e))
+        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.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_converted_36(self):
         f = FileField(max_length = 5)
-        self.assertRaises(ValidationError, f.clean, SimpleUploadedFile('test_maxlength.txt', 'hello world'))
-        try:
-            f.clean(SimpleUploadedFile('test_maxlength.txt', 'hello world'))
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this filename has at most 5 characters (it has 18).']", str(e))
+        self.assertRaisesErrorWithMessage(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'))))
@@ -800,16 +427,8 @@ class TestFields(TestCase):
 
     def test_converted_37(self):
         f = URLField()
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(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://www.example.com/', f.clean('http://www.example.com'))
@@ -818,51 +437,15 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, 'foo')
-        try:
-            f.clean('foo')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://')
-        try:
-            f.clean('http://')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://example')
-        try:
-            f.clean('http://example')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://example.')
-        try:
-            f.clean('http://example.')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://.com')
-        try:
-            f.clean('http://.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://invalid-.com')
-        try:
-            f.clean('http://invalid-.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://-invalid.com')
-        try:
-            f.clean('http://-invalid.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://inv-.alid-.com')
-        try:
-            f.clean('http://inv-.alid-.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://inv-.-alid.com')
-        try:
-            f.clean('http://inv-.-alid.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
+        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.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.assertEqual(u'http://valid-----hyphens.com/', f.clean('http://valid-----hyphens.com'))
 
     def test_converted_38(self):
@@ -871,40 +454,16 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, 'foo')
-        try:
-            f.clean('foo')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://')
-        try:
-            f.clean('http://')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://example')
-        try:
-            f.clean('http://example')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://example.')
-        try:
-            f.clean('http://example.')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'http://.com')
-        try:
-            f.clean('http://.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
+        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')
 
     def test_converted_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.assertRaises(ValidationError, f.clean, 'http://example')
-        try:
-            f.clean('http://example')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid URL.']", str(e))
+        self.assertRaisesErrorWithMessage(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
@@ -923,17 +482,9 @@ class TestFields(TestCase):
 
     def test_converted_41(self):
         f = URLField(min_length=15, max_length=20)
-        self.assertRaises(ValidationError, f.clean, 'http://f.com')
-        try:
-            f.clean('http://f.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at least 15 characters (it has 13).']", str(e))
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, 'http://abcdefghijklmnopqrstuvwxyz.com')
-        try:
-            f.clean('http://abcdefghijklmnopqrstuvwxyz.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at most 20 characters (it has 38).']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Ensure this value has at most 20 characters (it has 38).']", f.clean, 'http://abcdefghijklmnopqrstuvwxyz.com')
 
     def test_converted_42(self):
         f = URLField(required=False)
@@ -950,35 +501,15 @@ class TestFields(TestCase):
 
     def test_converted_44(self):
         f = BooleanField()
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
         self.assertEqual(True, f.clean(True))
-        self.assertRaises(ValidationError, f.clean, False)
-        try:
-            f.clean(False)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, False)
         self.assertEqual(True, f.clean(1))
-        self.assertRaises(ValidationError, f.clean, 0)
-        try:
-            f.clean(0)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, 0)
         self.assertEqual(True, f.clean('Django rocks'))
         self.assertEqual(True, f.clean('True'))
-        self.assertRaises(ValidationError, f.clean, 'False')
-        try:
-            f.clean('False')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, 'False')
 
     def test_converted_45(self):
         f = BooleanField(required=False)
@@ -997,23 +528,11 @@ class TestFields(TestCase):
 
     def test_converted_46(self):
         f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')])
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, None)
         self.assertEqual(u'1', f.clean(1))
         self.assertEqual(u'1', f.clean('1'))
-        self.assertRaises(ValidationError, f.clean, '3')
-        try:
-            f.clean('3')
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 3 is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, '3')
 
     def test_converted_47(self):
         f = ChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
@@ -1021,20 +540,12 @@ class TestFields(TestCase):
         self.assertEqual(u'', f.clean(None))
         self.assertEqual(u'1', f.clean(1))
         self.assertEqual(u'1', f.clean('1'))
-        self.assertRaises(ValidationError, f.clean, '3')
-        try:
-            f.clean('3')
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 3 is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, '3')
 
     def test_converted_48(self):
         f = ChoiceField(choices=[('J', 'John'), ('P', 'Paul')])
         self.assertEqual(u'J', f.clean('J'))
-        self.assertRaises(ValidationError, f.clean, 'John')
-        try:
-            f.clean('John')
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. John is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. John is not one of the available choices.']", f.clean, 'John')
 
     def test_converted_49(self):
         f = ChoiceField(choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3','A'),('4','B'))), ('5','Other')])
@@ -1044,11 +555,7 @@ class TestFields(TestCase):
         self.assertEqual(u'3', f.clean('3'))
         self.assertEqual(u'5', f.clean(5))
         self.assertEqual(u'5', f.clean('5'))
-        self.assertRaises(ValidationError, f.clean, '6')
-        try:
-            f.clean('6')
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 6 is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(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
@@ -1057,11 +564,7 @@ class TestFields(TestCase):
     def test_converted_50(self):
         f = TypedChoiceField(choices=[(1, "+1"), (-1, "-1")], coerce=int)
         self.assertEqual(1, f.clean('1'))
-        self.assertRaises(ValidationError, f.clean, '2')
-        try:
-            f.clean('2')
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 2 is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 2 is not one of the available choices.']", f.clean, '2')
 
     def test_converted_51(self):
         # Different coercion, same validation.
@@ -1077,17 +580,9 @@ class TestFields(TestCase):
         # 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.assertRaises(ValidationError, f.clean, 'B')
-        try:
-            f.clean('B')
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. B is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. B is not one of the available choices.']", f.clean, 'B')
         # Required fields require values
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
 
     def test_converted_54(self):
         # Non-required fields aren't required
@@ -1149,41 +644,17 @@ class TestFields(TestCase):
 
     def test_converted_60(self):
         f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')])
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'This field is required.']", f.clean, '')
+        self.assertRaisesErrorWithMessage(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.assertRaises(ValidationError, f.clean, 'hello')
-        try:
-            f.clean('hello')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a list of values.']", str(e))
-        self.assertRaises(ValidationError, f.clean, [])
-        try:
-            f.clean([])
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ())
-        try:
-            f.clean(())
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['3'])
-        try:
-            f.clean(['3'])
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 3 is not one of the available choices.']", str(e))
+        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'])
 
     def test_converted_61(self):
         f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')], required=False)
@@ -1194,18 +665,10 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, 'hello')
-        try:
-            f.clean('hello')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a list of values.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Enter a list of values.']", f.clean, 'hello')
         self.assertEqual([], f.clean([]))
         self.assertEqual([], f.clean(()))
-        self.assertRaises(ValidationError, f.clean, ['3'])
-        try:
-            f.clean(['3'])
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 3 is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(ValidationError, "[u'Select a valid choice. 3 is not one of the available choices.']", f.clean, ['3'])
 
     def test_converted_62(self):
         f = MultipleChoiceField(choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3','A'),('4','B'))), ('5','Other')])
@@ -1215,56 +678,24 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, ['6'])
-        try:
-            f.clean(['6'])
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 6 is not one of the available choices.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['1','6'])
-        try:
-            f.clean(['1','6'])
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. 6 is not one of the available choices.']", str(e))
+        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'])
 
     # ComboField ##################################################################
 
     def test_converted_63(self):
         f = ComboField(fields=[CharField(max_length=20), EmailField()])
         self.assertEqual(u'test@example.com', f.clean('test@example.com'))
-        self.assertRaises(ValidationError, f.clean, 'longemailaddress@example.com')
-        try:
-            f.clean('longemailaddress@example.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at most 20 characters (it has 28).']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'not an e-mail')
-        try:
-            f.clean('not an e-mail')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
+        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)
 
     def test_converted_64(self):
         f = ComboField(fields=[CharField(max_length=20), EmailField()], required=False)
         self.assertEqual(u'test@example.com', f.clean('test@example.com'))
-        self.assertRaises(ValidationError, f.clean, 'longemailaddress@example.com')
-        try:
-            f.clean('longemailaddress@example.com')
-        except ValidationError, e:
-            self.assertEqual("[u'Ensure this value has at most 20 characters (it has 28).']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'not an e-mail')
-        try:
-            f.clean('not an e-mail')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid e-mail address.']", str(e))
+        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.assertEqual(u'', f.clean(''))
         self.assertEqual(u'', f.clean(None))
     
@@ -1293,11 +724,7 @@ class TestFields(TestCase):
         for exp, got in zip(expected, fix_os_paths(f.choices)):
             self.assertEqual(exp[1], got[1])
             assert got[0].endswith(exp[0])
-        self.assertRaises(ValidationError, f.clean, 'fields.py')
-        try:
-            f.clean('fields.py')
-        except ValidationError, e:
-            self.assertEqual("[u'Select a valid choice. fields.py is not one of the available choices.']", str(e))
+        self.assertRaisesErrorWithMessage(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_converted_67(self):
@@ -1345,36 +772,12 @@ class TestFields(TestCase):
         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.assertRaises(ValidationError, f.clean, None)
-        try:
-            f.clean(None)
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, '')
-        try:
-            f.clean('')
-        except ValidationError, e:
-            self.assertEqual("[u'This field is required.']", str(e))
-        self.assertRaises(ValidationError, f.clean, 'hello')
-        try:
-            f.clean('hello')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a list of values.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['hello', 'there'])
-        try:
-            f.clean(['hello', 'there'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.', u'Enter a valid time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['2006-01-10', 'there'])
-        try:
-            f.clean(['2006-01-10', 'there'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['hello', '07:30'])
-        try:
-            f.clean(['hello', '07:30'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
+        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'])
 
     def test_converted_70(self):
         f = SplitDateTimeField(required=False)
@@ -1384,39 +787,11 @@ class TestFields(TestCase):
         self.assertEqual(None, f.clean(''))
         self.assertEqual(None, f.clean(['']))
         self.assertEqual(None, f.clean(['', '']))
-        self.assertRaises(ValidationError, f.clean, 'hello')
-        try:
-            f.clean('hello')
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a list of values.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['hello', 'there'])
-        try:
-            f.clean(['hello', 'there'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.', u'Enter a valid time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['2006-01-10', 'there'])
-        try:
-            f.clean(['2006-01-10', 'there'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['hello', '07:30'])
-        try:
-            f.clean(['hello', '07:30'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['2006-01-10', ''])
-        try:
-            f.clean(['2006-01-10', ''])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['2006-01-10'])
-        try:
-            f.clean(['2006-01-10'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid time.']", str(e))
-        self.assertRaises(ValidationError, f.clean, ['', '07:30'])
-        try:
-            f.clean(['', '07:30'])
-        except ValidationError, e:
-            self.assertEqual("[u'Enter a valid date.']", str(e))
+        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'])