Add 'bound' to TooShort|Long|Big|Smallissue65

Using a common superclass.

Unify a bunch of the tests for these and remove duplication.

4 files changed, 216 insertions, 281 deletions

diff --git a/src/zope/schema/_bootstrapinterfaces.py b/src/zope/schema/_bootstrapinterfaces.py
index 9bbae59..8d996d2 100644
--- a/src/zope/schema/_bootstrapinterfaces.py
+++ b/src/zope/schema/_bootstrapinterfaces.py
@@ -94,21 +94,77 @@ class WrongType(ValidationError):
         self.expected_type = expected_type
         self.value = value
 
-class TooBig(ValidationError):
+
+class OutOfBounds(ValidationError):
+    """
+    A value was out of the allowed bounds.
+
+    This is the common superclass for `OrderableOutOfBounds` and
+    `LenOutOfBounds`, which in turn are the superclasses for `TooBig`
+    and `TooSmall`, and `TooLong` and `TooShort`, respectively.
+
+    .. versionadded:: 4.7.0
+    """
+
+    #: The value that was exceeded
+    bound = None
+
+    #: A constant for `violation_direction`.
+    TOO_LARGE = object()
+
+    #: A constant for `violation_direction`.
+    TOO_SMALL = object()
+
+    #: Whether the value was too large or
+    #: not large enough. One of the values
+    #: defined by the constants `TOO_LARGE`
+    #: or `TOO_SMALL`
+    violation_direction = None
+
+    def __init__(self, value=None, bound=None, *args):
+        """
+        OutOfBounds(value, bound)
+        """
+        super(OutOfBounds, self).__init__(value, bound, *args)
+        self.value = value
+        self.bound = bound
+
+class OrderableOutOfBounds(OutOfBounds):
+    """
+    A value was too big or too small in comparison to another value.
+
+    .. versionadded:: 4.7.0
+    """
+
+class TooBig(OrderableOutOfBounds):
     __doc__ = _("""Value is too big""")
 
+    violation_direction = OutOfBounds.TOO_LARGE
 
-class TooSmall(ValidationError):
+class TooSmall(OrderableOutOfBounds):
     __doc__ = _("""Value is too small""")
 
+    violation_direction = OutOfBounds.TOO_SMALL
+
 
-class TooLong(ValidationError):
+class LenOutOfBounds(OutOfBounds):
+    """
+    The length of the value was out of bounds.
+
+    .. versionadded:: 4.7.0
+    """
+
+
+class TooLong(LenOutOfBounds):
     __doc__ = _("""Value is too long""")
 
+    violation_direction = OutOfBounds.TOO_LARGE
 
-class TooShort(ValidationError):
+class TooShort(LenOutOfBounds):
     __doc__ = _("""Value is too short""")
 
+    violation_direction = OutOfBounds.TOO_SMALL
+
 
 class InvalidValue(ValidationError):
     __doc__ = _("""Invalid value""")
diff --git a/src/zope/schema/interfaces.py b/src/zope/schema/interfaces.py
index dbdc913..7223397 100644
--- a/src/zope/schema/interfaces.py
+++ b/src/zope/schema/interfaces.py
@@ -41,9 +41,12 @@ from zope.schema._bootstrapinterfaces import IContextAwareDefaultFactory
 from zope.schema._bootstrapinterfaces import IFromUnicode
 from zope.schema._bootstrapinterfaces import IValidatable
 from zope.schema._bootstrapinterfaces import InvalidValue
+from zope.schema._bootstrapinterfaces import LenOutOfBounds
 from zope.schema._bootstrapinterfaces import NotAContainer
 from zope.schema._bootstrapinterfaces import NotAnInterface
 from zope.schema._bootstrapinterfaces import NotAnIterator
+from zope.schema._bootstrapinterfaces import OrderableOutOfBounds
+from zope.schema._bootstrapinterfaces import OutOfBounds
 from zope.schema._bootstrapinterfaces import RequiredMissing
 from zope.schema._bootstrapinterfaces import SchemaNotCorrectlyImplemented
 from zope.schema._bootstrapinterfaces import SchemaNotFullyImplemented
@@ -57,6 +60,8 @@ from zope.schema._bootstrapinterfaces import ValidationError
 from zope.schema._bootstrapinterfaces import WrongContainedType
 from zope.schema._bootstrapinterfaces import WrongType
 
+
+
 from zope.schema._compat import PY3
 
 from zope.schema._messageid import _
@@ -68,10 +73,13 @@ __all__ = [
     'InvalidId',
     'InvalidURI',
     'InvalidValue',
+    'LenOutOfBounds',
     'NotAContainer',
     'NotAnInterface',
     'NotAnIterator',
     'NotUnique',
+    'OrderableOutOfBounds',
+    'OutOfBounds',
     'RequiredMissing',
     'SchemaNotCorrectlyImplemented',
     'SchemaNotFullyImplemented',
@@ -86,6 +94,7 @@ __all__ = [
     'WrongContainedType',
     'WrongType',
 
+
     # Interfaces
     'IASCII',
     'IASCIILine',
diff --git a/src/zope/schema/tests/test__bootstrapfields.py b/src/zope/schema/tests/test__bootstrapfields.py
index e724a0d..11ed308 100644
--- a/src/zope/schema/tests/test__bootstrapfields.py
+++ b/src/zope/schema/tests/test__bootstrapfields.py
@@ -138,6 +138,81 @@ class OrderableMissingValueMixin(object):
         self.assertEqual(self.mvm_missing_value, field.missing_value)
 
 
+class OrderableTestsMixin(object):
+
+    def assertRaisesTooBig(self, field, value):
+        from zope.schema.interfaces import TooBig
+        with self.assertRaises(TooBig) as exc:
+            field.validate(value)
+
+        ex = exc.exception
+        self.assertEqual(value, ex.value)
+        self.assertEqual(field.max, ex.bound)
+        self.assertEqual(TooBig.TOO_LARGE, ex.violation_direction)
+
+    def assertRaisesTooSmall(self, field, value):
+        from zope.schema.interfaces import TooSmall
+        with self.assertRaises(TooSmall) as exc:
+            field.validate(value)
+
+        ex = exc.exception
+        self.assertEqual(value, ex.value)
+        self.assertEqual(field.min, ex.bound)
+        self.assertEqual(TooSmall.TOO_SMALL, ex.violation_direction)
+
+    MIN = 10
+    MAX = 20
+    VALID = (10, 11, 19, 20)
+    TOO_SMALL = (9, -10)
+    TOO_BIG = (21, 22)
+
+    def test_validate_min(self):
+        field = self._makeOne(min=self.MIN)
+        for value in self.VALID + self.TOO_BIG:
+            field.validate(value)
+        for value in self.TOO_SMALL:
+            self.assertRaisesTooSmall(field, value)
+
+    def test_validate_max(self):
+        field = self._makeOne(max=self.MAX)
+        for value in self.VALID + self.TOO_SMALL:
+            field.validate(value)
+        for value in self.TOO_BIG:
+            self.assertRaisesTooBig(field, value)
+
+    def test_validate_min_and_max(self):
+        field = self._makeOne(min=self.MIN, max=self.MAX)
+        for value in self.TOO_SMALL:
+            self.assertRaisesTooSmall(field, value)
+        for value in self.VALID:
+            field.validate(value)
+        for value in self.TOO_BIG:
+            self.assertRaisesTooBig(field, value)
+
+
+class LenTestsMixin(object):
+
+    def assertRaisesTooLong(self, field, value):
+        from zope.schema.interfaces import TooLong
+        with self.assertRaises(TooLong) as exc:
+            field.validate(value)
+
+        ex = exc.exception
+        self.assertEqual(value, ex.value)
+        self.assertEqual(field.max_length, ex.bound)
+        self.assertEqual(TooLong.TOO_LARGE, ex.violation_direction)
+
+    def assertRaisesTooShort(self, field, value):
+        from zope.schema.interfaces import TooShort
+        with self.assertRaises(TooShort) as exc:
+            field.validate(value)
+
+        ex = exc.exception
+        self.assertEqual(value, ex.value)
+        self.assertEqual(field.min_length, ex.bound)
+        self.assertEqual(TooShort.TOO_SMALL, ex.violation_direction)
+
+
 class WrongTypeTestsMixin(object):
 
     def assertRaisesWrongType(self, field_or_meth, expected_type, *args, **kwargs):
@@ -733,7 +808,8 @@ class OrderableTests(unittest.TestCase):
         self.assertRaises(TooBig, self._makeOne, max=10, default=11)
 
 
-class MinMaxLenTests(unittest.TestCase):
+class MinMaxLenTests(LenTestsMixin,
+                     unittest.TestCase):
 
     def _getTargetClass(self):
         from zope.schema._bootstrapfields import MinMaxLen
@@ -753,14 +829,12 @@ class MinMaxLenTests(unittest.TestCase):
         self.assertEqual(mml.max_length, None)
 
     def test_validate_too_short(self):
-        from zope.schema._bootstrapinterfaces import TooShort
         mml = self._makeOne(min_length=1)
-        self.assertRaises(TooShort, mml._validate, ())
+        self.assertRaisesTooShort(mml, ())
 
     def test_validate_too_long(self):
-        from zope.schema._bootstrapinterfaces import TooLong
         mml = self._makeOne(max_length=2)
-        self.assertRaises(TooLong, mml._validate, (0, 1, 2))
+        self.assertRaisesTooLong(mml, (0, 1, 2))
 
 
 class TextTests(EqualityTestsMixin,
@@ -988,6 +1062,7 @@ class BoolTests(EqualityTestsMixin,
 
 class NumberTests(EqualityTestsMixin,
                   OrderableMissingValueMixin,
+                  OrderableTestsMixin,
                   unittest.TestCase):
 
     def _getTargetClass(self):
@@ -1031,8 +1106,6 @@ class RealTests(WrongTypeTestsMixin,
         return IReal
 
     def test_ctor_real_min_max(self):
-        from zope.schema.interfaces import TooSmall
-        from zope.schema.interfaces import TooBig
         from fractions import Fraction
 
         self.assertRaisesWrongType(self._makeOne, self._getTargetClass()._type, min='')
@@ -1041,9 +1114,10 @@ class RealTests(WrongTypeTestsMixin,
         field = self._makeOne(min=Fraction(1, 2), max=2)
         field.validate(1.0)
         field.validate(2.0)
-        self.assertRaises(TooSmall, field.validate, 0)
-        self.assertRaises(TooSmall, field.validate, 0.4)
-        self.assertRaises(TooBig, field.validate, 2.1)
+        self.assertRaisesTooSmall(field, 0)
+        self.assertRaisesTooSmall(field, 0.4)
+        self.assertRaisesTooBig(field, 2.1)
+
 
 class RationalTests(NumberTests):
 
@@ -1081,34 +1155,7 @@ class IntegralTests(RationalTests):
         field.validate(-1)
         self.assertRaises(RequiredMissing, field.validate, None)
 
-    def test_validate_min(self):
-        from zope.schema.interfaces import TooSmall
-        field = self._makeOne(min=10)
-        field.validate(10)
-        field.validate(20)
-        self.assertRaises(TooSmall, field.validate, 9)
-        self.assertRaises(TooSmall, field.validate, -10)
-
-    def test_validate_max(self):
-        from zope.schema.interfaces import TooBig
-        field = self._makeOne(max=10)
-        field.validate(5)
-        field.validate(9)
-        field.validate(10)
-        self.assertRaises(TooBig, field.validate, 11)
-        self.assertRaises(TooBig, field.validate, 20)
 
-    def test_validate_min_and_max(self):
-        from zope.schema.interfaces import TooBig
-        from zope.schema.interfaces import TooSmall
-        field = self._makeOne(min=0, max=10)
-        field.validate(0)
-        field.validate(5)
-        field.validate(10)
-        self.assertRaises(TooSmall, field.validate, -10)
-        self.assertRaises(TooSmall, field.validate, -1)
-        self.assertRaises(TooBig, field.validate, 11)
-        self.assertRaises(TooBig, field.validate, 20)
 
     def test_fromUnicode_miss(self):
 
diff --git a/src/zope/schema/tests/test__field.py b/src/zope/schema/tests/test__field.py
index a7dd9d8..a5b2c7b 100644
--- a/src/zope/schema/tests/test__field.py
+++ b/src/zope/schema/tests/test__field.py
@@ -16,10 +16,13 @@ import decimal
 import doctest
 import unittest
 
-from zope.schema.tests.test__bootstrapfields import OrderableMissingValueMixin
 from zope.schema.tests.test__bootstrapfields import EqualityTestsMixin
+from zope.schema.tests.test__bootstrapfields import LenTestsMixin
+from zope.schema.tests.test__bootstrapfields import OrderableMissingValueMixin
+from zope.schema.tests.test__bootstrapfields import OrderableTestsMixin
 from zope.schema.tests.test__bootstrapfields import WrongTypeTestsMixin
 
+from zope.schema.tests.test__bootstrapfields import NumberTests
 
 # pylint:disable=protected-access
 # pylint:disable=too-many-lines
@@ -244,12 +247,18 @@ class ASCIILineTests(EqualityTestsMixin,
         self.assertEqual(field.constraint('abc\ndef'), False)
 
 
-class FloatTests(OrderableMissingValueMixin, EqualityTestsMixin,
-                 unittest.TestCase):
+class FloatTests(NumberTests):
 
     mvm_missing_value = -1.0
     mvm_default = 0.0
 
+    MIN = float(NumberTests.MIN)
+    MAX = float(NumberTests.MAX)
+    VALID = tuple(float(x) for x in NumberTests.VALID)
+    TOO_SMALL = tuple(float(x) for x in NumberTests.TOO_SMALL)
+    TOO_BIG = tuple(float(x) for x in NumberTests.TOO_BIG)
+
+
     def _getTargetClass(self):
         from zope.schema._field import Float
         return Float
@@ -273,34 +282,6 @@ class FloatTests(OrderableMissingValueMixin, EqualityTestsMixin,
         field.validate(1000.0003)
         self.assertRaises(RequiredMissing, field.validate, None)
 
-    def test_validate_min(self):
-        from zope.schema.interfaces import TooSmall
-        field = self._makeOne(min=10.5)
-        field.validate(10.6)
-        field.validate(20.2)
-        self.assertRaises(TooSmall, field.validate, -9.0)
-        self.assertRaises(TooSmall, field.validate, 10.4)
-
-    def test_validate_max(self):
-        from zope.schema.interfaces import TooBig
-        field = self._makeOne(max=10.5)
-        field.validate(5.3)
-        field.validate(-9.1)
-        self.assertRaises(TooBig, field.validate, 10.51)
-        self.assertRaises(TooBig, field.validate, 20.7)
-
-    def test_validate_min_and_max(self):
-        from zope.schema.interfaces import TooBig
-        from zope.schema.interfaces import TooSmall
-        field = self._makeOne(min=-0.6, max=10.1)
-        field.validate(0.0)
-        field.validate(-0.03)
-        field.validate(10.0001)
-        self.assertRaises(TooSmall, field.validate, -10.0)
-        self.assertRaises(TooSmall, field.validate, -1.6)
-        self.assertRaises(TooBig, field.validate, 11.45)
-        self.assertRaises(TooBig, field.validate, 20.02)
-
     def test_fromUnicode_miss(self):
 
         flt = self._makeOne()
@@ -316,12 +297,17 @@ class FloatTests(OrderableMissingValueMixin, EqualityTestsMixin,
         self.assertEqual(flt.fromUnicode(u'1.23e6'), 1230000.0)
 
 
-class DecimalTests(OrderableMissingValueMixin, EqualityTestsMixin,
-                   unittest.TestCase):
+class DecimalTests(NumberTests):
 
     mvm_missing_value = decimal.Decimal("-1")
     mvm_default = decimal.Decimal("0")
 
+    MIN = decimal.Decimal(NumberTests.MIN)
+    MAX = decimal.Decimal(NumberTests.MAX)
+    VALID = tuple(decimal.Decimal(x) for x in NumberTests.VALID)
+    TOO_SMALL = tuple(decimal.Decimal(x) for x in NumberTests.TOO_SMALL)
+    TOO_BIG = tuple(decimal.Decimal(x) for x in NumberTests.TOO_BIG)
+
     def _getTargetClass(self):
         from zope.schema._field import Decimal
         return Decimal
@@ -345,46 +331,6 @@ class DecimalTests(OrderableMissingValueMixin, EqualityTestsMixin,
         field.validate(decimal.Decimal("1000.0003"))
         self.assertRaises(RequiredMissing, field.validate, None)
 
-    def test_validate_min(self):
-        from zope.schema.interfaces import TooSmall
-        field = self._makeOne(min=decimal.Decimal("10.5"))
-        field.validate(decimal.Decimal("10.6"))
-        field.validate(decimal.Decimal("20.2"))
-        self.assertRaises(TooSmall, field.validate, decimal.Decimal("-9.0"))
-        self.assertRaises(TooSmall, field.validate, decimal.Decimal("10.4"))
-
-    def test_validate_max(self):
-        from zope.schema.interfaces import TooBig
-        field = self._makeOne(max=decimal.Decimal("10.5"))
-        field.validate(decimal.Decimal("5.3"))
-        field.validate(decimal.Decimal("-9.1"))
-        self.assertRaises(TooBig, field.validate, decimal.Decimal("10.51"))
-        self.assertRaises(TooBig, field.validate, decimal.Decimal("20.7"))
-
-    def test_validate_min_and_max(self):
-        from zope.schema.interfaces import TooBig
-        from zope.schema.interfaces import TooSmall
-        field = self._makeOne(min=decimal.Decimal("-0.6"),
-                              max=decimal.Decimal("10.1"))
-        field.validate(decimal.Decimal("0.0"))
-        field.validate(decimal.Decimal("-0.03"))
-        field.validate(decimal.Decimal("10.0001"))
-        self.assertRaises(TooSmall, field.validate, decimal.Decimal("-10.0"))
-        with self.assertRaises(TooSmall) as exc:
-            field.validate(decimal.Decimal("-1.6"))
-
-        too_small = exc.exception
-        self.assertIs(too_small.field, field)
-        self.assertEqual(too_small.value, decimal.Decimal("-1.6"))
-
-        self.assertRaises(TooBig, field.validate, decimal.Decimal("11.45"))
-        with self.assertRaises(TooBig) as exc:
-            field.validate(decimal.Decimal("20.02"))
-
-        too_big = exc.exception
-        self.assertIs(too_big.field, field)
-        self.assertEqual(too_big.value, decimal.Decimal("20.02"))
-
     def test_fromUnicode_miss(self):
         from zope.schema.interfaces import ValidationError
         flt = self._makeOne()
@@ -408,6 +354,7 @@ class DecimalTests(OrderableMissingValueMixin, EqualityTestsMixin,
 
 
 class DatetimeTests(OrderableMissingValueMixin,
+                    OrderableTestsMixin,
                     EqualityTestsMixin,
                     WrongTypeTestsMixin,
                     unittest.TestCase):
@@ -450,42 +397,15 @@ class DatetimeTests(OrderableMissingValueMixin,
         field = self._makeOne(required=True)
         self.assertRaises(RequiredMissing, field.validate, None)
 
-    def test_validate_w_min(self):
-        from zope.schema.interfaces import TooSmall
-        d1 = datetime.datetime(2000, 10, 1)
-        d2 = datetime.datetime(2000, 10, 2)
-        field = self._makeOne(min=d1)
-        field.validate(d1)  # doesn't raise
-        field.validate(d2)  # doesn't raise
-        self.assertRaises(TooSmall, field.validate, datetime.datetime(2000, 9, 30))
-
-    def test_validate_w_max(self):
-        from zope.schema.interfaces import TooBig
-        d1 = datetime.datetime(2000, 10, 1)
-        d2 = datetime.datetime(2000, 10, 2)
-        d3 = datetime.datetime(2000, 10, 3)
-        field = self._makeOne(max=d2)
-        field.validate(d1)  # doesn't raise
-        field.validate(d2)  # doesn't raise
-        self.assertRaises(TooBig, field.validate, d3)
-
-    def test_validate_w_min_and_max(self):
-        from zope.schema.interfaces import TooBig
-        from zope.schema.interfaces import TooSmall
-        d1 = datetime.datetime(2000, 10, 1)
-        d2 = datetime.datetime(2000, 10, 2)
-        d3 = datetime.datetime(2000, 10, 3)
-        d4 = datetime.datetime(2000, 10, 4)
-        d5 = datetime.datetime(2000, 10, 5)
-        field = self._makeOne(min=d2, max=d4)
-        field.validate(d2)  # doesn't raise
-        field.validate(d3)  # doesn't raise
-        field.validate(d4)  # doesn't raise
-        self.assertRaises(TooSmall, field.validate, d1)
-        self.assertRaises(TooBig, field.validate, d5)
+    MIN = datetime.datetime(2000, 10, 1)
+    MAX = datetime.datetime(2000, 10, 4)
+    TOO_BIG = tuple((datetime.datetime(2000, 10, x) for x in (5, 6)))
+    TOO_SMALL = tuple((datetime.datetime(2000, 9, x) for x in (5, 6)))
+    VALID = tuple((datetime.datetime(2000, 10, x) for x in (1, 2, 3, 4)))
 
 
 class DateTests(OrderableMissingValueMixin,
+                OrderableTestsMixin,
                 EqualityTestsMixin,
                 WrongTypeTestsMixin,
                 unittest.TestCase):
@@ -529,46 +449,16 @@ class DateTests(OrderableMissingValueMixin,
         field.validate(datetime.datetime.now().date())
         self.assertRaises(RequiredMissing, field.validate, None)
 
-    def test_validate_w_min(self):
-        from datetime import date
-        from zope.schema.interfaces import TooSmall
-        d1 = date(2000, 10, 1)
-        d2 = date(2000, 10, 2)
-        field = self._makeOne(min=d1)
-        field.validate(d1)
-        field.validate(d2)
-        field.validate(datetime.datetime.now().date())
-        self.assertRaises(TooSmall, field.validate, date(2000, 9, 30))
+    MIN = datetime.date(2000, 10, 1)
+    MAX = datetime.date(2000, 10, 4)
+    TOO_BIG = tuple((datetime.date(2000, 10, x) for x in (5, 6)))
+    TOO_SMALL = tuple((datetime.date(2000, 9, x) for x in (5, 6)))
+    VALID = tuple((datetime.date(2000, 10, x) for x in (1, 2, 3, 4)))
 
-    def test_validate_w_max(self):
-        from datetime import date
-        from zope.schema.interfaces import TooBig
-        d1 = date(2000, 10, 1)
-        d2 = date(2000, 10, 2)
-        d3 = date(2000, 10, 3)
-        field = self._makeOne(max=d2)
-        field.validate(d1)
-        field.validate(d2)
-        self.assertRaises(TooBig, field.validate, d3)
-
-    def test_validate_w_min_and_max(self):
-        from datetime import date
-        from zope.schema.interfaces import TooBig
-        from zope.schema.interfaces import TooSmall
-        d1 = date(2000, 10, 1)
-        d2 = date(2000, 10, 2)
-        d3 = date(2000, 10, 3)
-        d4 = date(2000, 10, 4)
-        d5 = date(2000, 10, 5)
-        field = self._makeOne(min=d2, max=d4)
-        field.validate(d2)
-        field.validate(d3)
-        field.validate(d4)
-        self.assertRaises(TooSmall, field.validate, d1)
-        self.assertRaises(TooBig, field.validate, d5)
-
-
-class TimedeltaTests(OrderableMissingValueMixin, EqualityTestsMixin,
+
+class TimedeltaTests(OrderableMissingValueMixin,
+                     OrderableTestsMixin,
+                     EqualityTestsMixin,
                      unittest.TestCase):
 
     mvm_missing_value = datetime.timedelta(minutes=15)
@@ -595,45 +485,16 @@ class TimedeltaTests(OrderableMissingValueMixin, EqualityTestsMixin,
         field.validate(timedelta(minutes=15))
         self.assertRaises(RequiredMissing, field.validate, None)
 
-    def test_validate_min(self):
-        from datetime import timedelta
-        from zope.schema.interfaces import TooSmall
-        t1 = timedelta(hours=2)
-        t2 = timedelta(hours=3)
-        field = self._makeOne(min=t1)
-        field.validate(t1)
-        field.validate(t2)
-        self.assertRaises(TooSmall, field.validate, timedelta(hours=1))
-
-    def test_validate_max(self):
-        from datetime import timedelta
-        from zope.schema.interfaces import TooBig
-        t1 = timedelta(minutes=1)
-        t2 = timedelta(minutes=2)
-        t3 = timedelta(minutes=3)
-        field = self._makeOne(max=t2)
-        field.validate(t1)
-        field.validate(t2)
-        self.assertRaises(TooBig, field.validate, t3)
-
-    def test_validate_min_and_max(self):
-        from datetime import timedelta
-        from zope.schema.interfaces import TooBig
-        from zope.schema.interfaces import TooSmall
-        t1 = timedelta(days=1)
-        t2 = timedelta(days=2)
-        t3 = timedelta(days=3)
-        t4 = timedelta(days=4)
-        t5 = timedelta(days=5)
-        field = self._makeOne(min=t2, max=t4)
-        field.validate(t2)
-        field.validate(t3)
-        field.validate(t4)
-        self.assertRaises(TooSmall, field.validate, t1)
-        self.assertRaises(TooBig, field.validate, t5)
-
-
-class TimeTests(OrderableMissingValueMixin, EqualityTestsMixin,
+    MIN = datetime.timedelta(minutes=NumberTests.MIN)
+    MAX = datetime.timedelta(minutes=NumberTests.MAX)
+    VALID = tuple(datetime.timedelta(minutes=x) for x in NumberTests.VALID)
+    TOO_SMALL = tuple(datetime.timedelta(minutes=x) for x in NumberTests.TOO_SMALL)
+    TOO_BIG = tuple(datetime.timedelta(x) for x in NumberTests.TOO_BIG)
+
+
+class TimeTests(OrderableMissingValueMixin,
+                OrderableTestsMixin,
+                EqualityTestsMixin,
                 unittest.TestCase):
 
     mvm_missing_value = datetime.time(12, 15, 37)
@@ -660,43 +521,11 @@ class TimeTests(OrderableMissingValueMixin, EqualityTestsMixin,
         field.validate(time(12, 15, 37))
         self.assertRaises(RequiredMissing, field.validate, None)
 
-    def test_validate_min(self):
-        from datetime import time
-        from zope.schema.interfaces import TooSmall
-        t1 = time(12, 15, 37)
-        t2 = time(12, 25, 18)
-        t3 = time(12, 42, 43)
-        field = self._makeOne(min=t2)
-        field.validate(t2)
-        field.validate(t3)
-        self.assertRaises(TooSmall, field.validate, t1)
-
-    def test_validate_max(self):
-        from datetime import time
-        from zope.schema.interfaces import TooBig
-        t1 = time(12, 15, 37)
-        t2 = time(12, 25, 18)
-        t3 = time(12, 42, 43)
-        field = self._makeOne(max=t2)
-        field.validate(t1)
-        field.validate(t2)
-        self.assertRaises(TooBig, field.validate, t3)
-
-    def test_validate_min_and_max(self):
-        from datetime import time
-        from zope.schema.interfaces import TooBig
-        from zope.schema.interfaces import TooSmall
-        t1 = time(12, 15, 37)
-        t2 = time(12, 25, 18)
-        t3 = time(12, 42, 43)
-        t4 = time(13, 7, 12)
-        t5 = time(14, 22, 9)
-        field = self._makeOne(min=t2, max=t4)
-        field.validate(t2)
-        field.validate(t3)
-        field.validate(t4)
-        self.assertRaises(TooSmall, field.validate, t1)
-        self.assertRaises(TooBig, field.validate, t5)
+    MIN = datetime.time(12, 10, 1)
+    MAX = datetime.time(12, 10, 4)
+    TOO_BIG = tuple((datetime.time(12, 10, x) for x in (5, 6)))
+    TOO_SMALL = tuple((datetime.time(12, 9, x) for x in (5, 6)))
+    VALID = tuple((datetime.time(12, 10, x) for x in (1, 2, 3, 4)))
 
 
 class ChoiceTests(EqualityTestsMixin,
@@ -1313,6 +1142,7 @@ class InterfaceFieldTests(EqualityTestsMixin,
 
 
 class CollectionTests(EqualityTestsMixin,
+                      LenTestsMixin,
                       unittest.TestCase):
 
     _DEFAULT_UNIQUE = False
@@ -1435,30 +1265,26 @@ class CollectionTests(EqualityTestsMixin,
                          [u'a', u'a'])
 
     def test_validate_min_length(self):
-        from zope.schema.interfaces import TooShort
         field = self._makeOne(min_length=2)
         field.validate(self._makeCollection((1, 2)))
         field.validate(self._makeCollection((1, 2, 3)))
-        self.assertRaises(TooShort, field.validate, self._makeCollection())
-        self.assertRaises(TooShort, field.validate, self._makeCollection((1,)))
+        self.assertRaisesTooShort(field, self._makeCollection())
+        self.assertRaisesTooShort(field, self._makeCollection((1,)))
 
     def test_validate_max_length(self):
-        from zope.schema.interfaces import TooLong
         field = self._makeOne(max_length=2)
         field.validate(self._makeCollection())
         field.validate(self._makeCollection((1,)))
         field.validate(self._makeCollection((1, 2)))
-        self.assertRaises(TooLong, field.validate, self._makeCollection((1, 2, 3, 4)))
-        self.assertRaises(TooLong, field.validate, self._makeCollection((1, 2, 3)))
+        self.assertRaisesTooLong(field, self._makeCollection((1, 2, 3, 4)))
+        self.assertRaisesTooLong(field, self._makeCollection((1, 2, 3)))
 
     def test_validate_min_length_and_max_length(self):
-        from zope.schema.interfaces import TooLong
-        from zope.schema.interfaces import TooShort
         field = self._makeOne(min_length=1, max_length=2)
         field.validate(self._makeCollection((1,)))
         field.validate(self._makeCollection((1, 2)))
-        self.assertRaises(TooShort, field.validate, self._makeCollection())
-        self.assertRaises(TooLong, field.validate, self._makeCollection((1, 2, 3)))
+        self.assertRaisesTooShort(field, self._makeCollection())
+        self.assertRaisesTooLong(field, self._makeCollection((1, 2, 3)))
 
     def test_validate_not_required(self):
         field = self._makeOne(required=False)
@@ -1666,6 +1492,7 @@ class FrozenSetTests(SetTests):
 
 class MappingTests(EqualityTestsMixin,
                    WrongTypeTestsMixin,
+                   LenTestsMixin,
                    unittest.TestCase):
 
     def _getTargetClass(self):
@@ -1754,28 +1581,24 @@ class MappingTests(EqualityTestsMixin,
 
 
     def test_validate_min_length(self):
-        from zope.schema.interfaces import TooShort
         field = self._makeOne(min_length=1)
         field.validate({1: 'a'})
         field.validate({1: 'a', 2: 'b'})
-        self.assertRaises(TooShort, field.validate, {})
+        self.assertRaisesTooShort(field, {})
 
     def test_validate_max_length(self):
-        from zope.schema.interfaces import TooLong
         field = self._makeOne(max_length=1)
         field.validate({})
         field.validate({1: 'a'})
-        self.assertRaises(TooLong, field.validate, {1: 'a', 2: 'b'})
-        self.assertRaises(TooLong, field.validate, {1: 'a', 2: 'b', 3: 'c'})
+        self.assertRaisesTooLong(field, {1: 'a', 2: 'b'})
+        self.assertRaisesTooLong(field, {1: 'a', 2: 'b', 3: 'c'})
 
     def test_validate_min_length_and_max_length(self):
-        from zope.schema.interfaces import TooLong
-        from zope.schema.interfaces import TooShort
         field = self._makeOne(min_length=1, max_length=2)
         field.validate({1: 'a'})
         field.validate({1: 'a', 2: 'b'})
-        self.assertRaises(TooShort, field.validate, {})
-        self.assertRaises(TooLong, field.validate, {1: 'a', 2: 'b', 3: 'c'})
+        self.assertRaisesTooShort(field, {})
+        self.assertRaisesTooLong(field, {1: 'a', 2: 'b', 3: 'c'})
 
     def test_bind_binds_key_and_value_types(self):
         from zope.schema import Int