diff --git a/.gitignore b/.gitignore
index b90c7ed..a063dff 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,6 +6,7 @@ eggs
 develop-eggs
 build
 docs/_build
+docs/.doctrees
 parts
 *.egg-info
 .tox
diff --git a/CHANGES.rst b/CHANGES.rst
index f7abd23..ed38933 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -2,11 +2,23 @@
  Changes
 =========
 
-4.6.3 (unreleased)
+4.7.0 (unreleased)
 ==================
 
-- Nothing changed yet.
+- Make ``WrongType`` have an ``expected_type`` field.
 
+- Add ``NotAnInterface``, an exception derived from ``WrongType`` and
+  ``SchemaNotProvided`` and raised by the constructor of ``Object``
+  and when validation fails for ``InterfaceField``.
+
+- Give ``SchemaNotProvided`` a ``schema`` field.
+
+- Give ``WrongContainedType`` an ``errors`` list.
+
+- Give ``TooShort``, ``TooLong``, ``TooBig`` and ``TooSmall`` a
+  ``bound`` field and the common superclasses ``LenOutOfBounds``,
+  ``OrderableOutOfBounds``, respectively, both of which inherit from
+  ``OutOfBounds``.
 
 4.6.2 (2018-09-10)
 ==================
diff --git a/docs/api.rst b/docs/api.rst
index 7877e76..c866ff7 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -123,11 +123,19 @@ Exceptions
 .. autoexception:: zope.schema.interfaces.ConstraintNotSatisfied
 .. autoexception:: zope.schema.interfaces.NotAContainer
 .. autoexception:: zope.schema.interfaces.NotAnIterator
+.. autoexception:: zope.schema.interfaces.NotAnInterface
 
+Bounds
+~~~~~~
+
+.. autoexception:: zope.schema.interfaces.OutOfBounds
+.. autoexception:: zope.schema.interfaces.OrderableOutOfBounds
+.. autoexception:: zope.schema.interfaces.LenOutOfBounds
 .. autoexception:: zope.schema.interfaces.TooSmall
 .. autoexception:: zope.schema.interfaces.TooBig
 .. autoexception:: zope.schema.interfaces.TooLong
 .. autoexception:: zope.schema.interfaces.TooShort
+
 .. autoexception:: zope.schema.interfaces.InvalidValue
 .. autoexception:: zope.schema.interfaces.WrongContainedType
 .. autoexception:: zope.schema.interfaces.NotUnique
@@ -146,7 +154,9 @@ Schema APIs
 .. autofunction:: zope.schema.getFieldNames
 .. autofunction:: zope.schema.getFieldNamesInOrder
 .. autofunction:: zope.schema.getValidationErrors
+   :noindex:
 .. autofunction:: zope.schema.getSchemaValidationErrors
+   :noindex:
 
 Fields
 ======
diff --git a/src/zope/schema/_bootstrapfields.py b/src/zope/schema/_bootstrapfields.py
index 622ef8e..12cc2ec 100644
--- a/src/zope/schema/_bootstrapfields.py
+++ b/src/zope/schema/_bootstrapfields.py
@@ -40,6 +40,7 @@ from zope.schema._bootstrapinterfaces import IFromUnicode
 from zope.schema._bootstrapinterfaces import IValidatable
 from zope.schema._bootstrapinterfaces import NotAContainer
 from zope.schema._bootstrapinterfaces import NotAnIterator
+from zope.schema._bootstrapinterfaces import NotAnInterface
 from zope.schema._bootstrapinterfaces import RequiredMissing
 from zope.schema._bootstrapinterfaces import SchemaNotCorrectlyImplemented
 from zope.schema._bootstrapinterfaces import SchemaNotFullyImplemented
@@ -918,7 +919,10 @@ class Object(Field):
             schema = self.schema
 
         if not IInterface.providedBy(schema):
-            raise WrongType
+            # Note that we don't provide 'self' as the 'field'
+            # by calling with_field_and_value(): We're not fully constructed,
+            # we don't want this instance to escape.
+            raise NotAnInterface(schema, self.__name__)
 
         self.schema = schema
         self.validate_invariants = kw.pop('validate_invariants', True)
@@ -947,10 +951,11 @@ class Object(Field):
             errors = list(schema_error_dict.values()) + invariant_errors
             exception = SchemaNotCorrectlyImplemented(
                 errors,
-                self.__name__
+                self.__name__,
+                schema_error_dict,
+                invariant_errors
             ).with_field_and_value(self, value)
-            exception.schema_errors = schema_error_dict
-            exception.invariant_errors = invariant_errors
+
             try:
                 raise exception
             finally:
diff --git a/src/zope/schema/_bootstrapinterfaces.py b/src/zope/schema/_bootstrapinterfaces.py
index eeb4f0e..110aa4f 100644
--- a/src/zope/schema/_bootstrapinterfaces.py
+++ b/src/zope/schema/_bootstrapinterfaces.py
@@ -17,9 +17,12 @@ from functools import total_ordering
 
 import zope.interface
 from zope.interface import Attribute
+from zope.interface.interfaces import IInterface
 
 from zope.schema._messageid import _
 
+# pylint:disable=inherit-non-class,keyword-arg-before-vararg,
+# pylint:disable=no-self-argument
 
 class StopValidation(Exception):
     """Raised if the validation is completed early.
@@ -76,22 +79,98 @@ class RequiredMissing(ValidationError):
 class WrongType(ValidationError):
     __doc__ = _("""Object is of wrong type.""")
 
+    #: The type or tuple of types that was expected.
+    #:
+    #: .. versionadded:: 4.7.0
+    expected_type = None
 
-class TooBig(ValidationError):
+    def __init__(self, value=None, expected_type=None, name=None, *args):
+        """
+        WrongType(value, expected_type, name)
+
+        .. versionchanged:: 4.7.0
+           Added named arguments to the constructor and the `expected_type`
+           field.
+        """
+        ValidationError.__init__(self, value, expected_type, name, *args)
+        self.expected_type = expected_type
+        self.value = value
+
+
+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 = type('TOO_LARGE', (), {'__slots__': ()})()
+
+    #: A constant for `violation_direction`.
+    TOO_SMALL = type('TOO_SMALL', (), {'__slots__': ()})()
+
+    #: 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 LenOutOfBounds(OutOfBounds):
+    """
+    The length of the value was out of bounds.
+
+    .. versionadded:: 4.7.0
+    """
+
 
-class TooLong(ValidationError):
+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""")
@@ -109,10 +188,25 @@ class NotAnIterator(ValidationError):
     __doc__ = _("""Not an iterator""")
 
 
-
 class WrongContainedType(ValidationError):
     __doc__ = _("""Wrong contained type""")
 
+    #: A collection of exceptions raised when validating
+    #: the *value*.
+    #:
+    #: .. versionadded:: 4.7.0
+    errors = ()
+
+    def __init__(self, errors=None, name=None, *args):
+        """
+        WrongContainedType(errors, name)
+
+        .. versionchanged:: 4.7.0
+           Added named arguments to the constructor, and the `errors` property.
+        """
+        super(WrongContainedType, self).__init__(errors, name, *args)
+        self.errors = errors
+
 
 class SchemaNotCorrectlyImplemented(WrongContainedType):
     __doc__ = _("""An object failed schema or invariant validation.""")
@@ -125,6 +219,17 @@ class SchemaNotCorrectlyImplemented(WrongContainedType):
     #: of the schema.
     invariant_errors = ()
 
+    def __init__(self, errors=None, name=None, schema_errors=None, invariant_errors=(), *args):
+        """
+        SchemaNotCorrectlyImplemented(errors, name, schema_errors, invariant_errors)
+
+        .. versionchanged:: 4.7.0
+           Added named arguments to the constructor.
+        """
+        super(SchemaNotCorrectlyImplemented, self).__init__(errors, name, *args)
+        self.schema_errors = schema_errors
+        self.invariant_errors = invariant_errors
+
 
 class SchemaNotFullyImplemented(ValidationError):
     __doc__ = _("""Schema not fully implemented""")
@@ -133,6 +238,41 @@ class SchemaNotFullyImplemented(ValidationError):
 class SchemaNotProvided(ValidationError):
     __doc__ = _("""Schema not provided""")
 
+    #: The interface that the *value* was supposed to provide,
+    #: but does not.
+    schema = None
+
+    def __init__(self, schema=None, value=None, *args):
+        """
+        SchemaNotProvided(schema, value)
+
+        .. versionchanged:: 4.7.0
+           Added named arguments to the constructor and the `schema` property.
+        """
+        super(SchemaNotProvided, self).__init__(schema, value, *args)
+        self.schema = schema
+        self.value = value
+
+
+class NotAnInterface(WrongType, SchemaNotProvided):
+    """
+    Object is not an interface.
+
+    This is a `WrongType` exception for backwards compatibility with
+    existing ``except`` clauses, but it is raised when
+    ``IInterface.providedBy`` is not true, so it's also a
+    `SchemaNotProvided`. The ``expected_type`` field is filled in as
+    ``IInterface``; this is not actually a `type`, and
+    ``isinstance(thing, IInterface)`` is always false.
+
+    .. versionadded:: 4.7.0
+    """
+
+    expected_type = IInterface
+
+    def __init__(self, value, name):
+        super(NotAnInterface, self).__init__(value, IInterface, name)
+
 
 class IFromUnicode(zope.interface.Interface):
     """Parse a unicode string to a value
@@ -188,8 +328,10 @@ class IValidatable(zope.interface.Interface):
         with the additional constraint.
         """
 
+
 class NO_VALUE(object):
     def __repr__(self): # pragma: no cover
         return '<NO_VALUE>'
 
+
 NO_VALUE = NO_VALUE()
diff --git a/src/zope/schema/_field.py b/src/zope/schema/_field.py
index f659877..17e270a 100644
--- a/src/zope/schema/_field.py
+++ b/src/zope/schema/_field.py
@@ -85,6 +85,7 @@ from zope.schema.interfaces import InvalidValue
 from zope.schema.interfaces import WrongType
 from zope.schema.interfaces import WrongContainedType
 from zope.schema.interfaces import NotUnique
+from zope.schema.interfaces import NotAnInterface
 from zope.schema.interfaces import InvalidURI
 from zope.schema.interfaces import InvalidId
 from zope.schema.interfaces import InvalidDottedName
@@ -552,8 +553,7 @@ class InterfaceField(Field):
     def _validate(self, value):
         super(InterfaceField, self)._validate(value)
         if not IInterface.providedBy(value):
-            raise WrongType(
-                "An interface is required",
+            raise NotAnInterface(
                 value,
                 self.__name__
             ).with_field_and_value(self, value)
diff --git a/src/zope/schema/interfaces.py b/src/zope/schema/interfaces.py
index 26ddf5a..434b2ca 100644
--- a/src/zope/schema/interfaces.py
+++ b/src/zope/schema/interfaces.py
@@ -41,8 +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
@@ -67,9 +71,13 @@ __all__ = [
     'InvalidId',
     'InvalidURI',
     'InvalidValue',
+    'LenOutOfBounds',
     'NotAContainer',
+    'NotAnInterface',
     'NotAnIterator',
     'NotUnique',
+    'OrderableOutOfBounds',
+    'OutOfBounds',
     'RequiredMissing',
     'SchemaNotCorrectlyImplemented',
     'SchemaNotFullyImplemented',
@@ -84,6 +92,7 @@ __all__ = [
     'WrongContainedType',
     'WrongType',
 
+
     # Interfaces
     'IASCII',
     'IASCIILine',

Exceptions could use some named attributes
In our validation code using zope.schema fields, we have lots of things that look like this:

```python
try:
    field.validate(value)
except WrongContainedType as e:
    if e.args and all(isinstance(SchemaNotProvided, v) for v in e.args[0]):
        # try to adapt
except WrongType as e:
    if len(e.args) == 3:
         expected_type = e.args[1]
          # try to adapt
except TooLong as e:
    if len(e.args) == 2:
        max_size = e.args[1]
        # Produce a pretty error message
```

All this argument parsing feels fragile. 

With named attributes, we could document what exceptions are expected to have. We could use keyword arguments (with defaults) in the constructors to maintain compatibility with code that raises bare exceptions or uses different arguments.
diff --git a/src/zope/schema/tests/test__bootstrapfields.py b/src/zope/schema/tests/test__bootstrapfields.py
index 2e89563..11ed308 100644
--- a/src/zope/schema/tests/test__bootstrapfields.py
+++ b/src/zope/schema/tests/test__bootstrapfields.py
@@ -138,6 +138,111 @@ 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):
+        from zope.schema.interfaces import WrongType
+        field = None
+        with self.assertRaises(WrongType) as exc:
+            if hasattr(field_or_meth, 'validate'):
+                field = field_or_meth
+                field.validate(*args, **kwargs)
+            else:
+                field_or_meth(*args, **kwargs)
+
+        ex = exc.exception
+        self.assertIs(ex.expected_type, expected_type)
+        if field is not None:
+            self.assertIs(ex.field, field)
+        if len(args) == 1 and not kwargs:
+            # Just a value
+            self.assertIs(ex.value, args[0])
+        if not args and len(kwargs) == 1:
+            # A single keyword argument
+            self.assertIs(ex.value, kwargs.popitem()[1])
+
+
+    def assertAllRaiseWrongType(self, field, expected_type, *values):
+        for value in values:
+            __traceback_info__ = value
+            self.assertRaisesWrongType(field, expected_type, value)
+
+
 class ValidatedPropertyTests(unittest.TestCase):
 
     def _getTargetClass(self):
@@ -267,6 +372,7 @@ class DefaultPropertyTests(unittest.TestCase):
 
 
 class FieldTests(EqualityTestsMixin,
+                 WrongTypeTestsMixin,
                  unittest.TestCase):
 
     def _getTargetClass(self):
@@ -505,11 +611,10 @@ class FieldTests(EqualityTestsMixin,
         self.assertRaises(RequiredMissing, field.validate, missing)
 
     def test_validate_wrong_type(self):
-        from zope.schema._bootstrapinterfaces import WrongType
 
         field = self._makeOne(required=True, constraint=lambda x: False)
         field._type = str
-        self.assertRaises(WrongType, field.validate, 1)
+        self.assertRaisesWrongType(field, str, 1)
 
     def test_validate_constraint_fails(self):
         from zope.schema._bootstrapinterfaces import ConstraintNotSatisfied
@@ -703,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
@@ -723,17 +829,16 @@ 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,
+                WrongTypeTestsMixin,
                 unittest.TestCase):
 
     def _getTargetClass(self):
@@ -750,18 +855,19 @@ class TextTests(EqualityTestsMixin,
         self.assertEqual(txt._type, text_type)
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
-
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, b'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            b'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_w_invalid_default(self):
 
@@ -786,11 +892,9 @@ class TextTests(EqualityTestsMixin,
         self.assertRaises(RequiredMissing, field.validate, None)
 
     def test_fromUnicode_miss(self):
-        from zope.schema._bootstrapinterfaces import WrongType
-
         deadbeef = b'DEADBEEF'
         txt = self._makeOne()
-        self.assertRaises(WrongType, txt.fromUnicode, deadbeef)
+        self.assertRaisesWrongType(txt.fromUnicode, txt._type, deadbeef)
 
     def test_fromUnicode_hit(self):
 
@@ -800,6 +904,7 @@ class TextTests(EqualityTestsMixin,
 
 
 class TextLineTests(EqualityTestsMixin,
+                    WrongTypeTestsMixin,
                     unittest.TestCase):
 
     def _getTargetClass(self):
@@ -811,18 +916,19 @@ class TextLineTests(EqualityTestsMixin,
         return ITextLine
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
-
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, b'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            b'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_not_required(self):
 
@@ -848,6 +954,7 @@ class TextLineTests(EqualityTestsMixin,
 
 
 class PasswordTests(EqualityTestsMixin,
+                    WrongTypeTestsMixin,
                     unittest.TestCase):
 
     def _getTargetClass(self):
@@ -889,12 +996,10 @@ class PasswordTests(EqualityTestsMixin,
         self.assertRaises(RequiredMissing, field.validate, None)
 
     def test_validate_unchanged_not_already_set(self):
-        from zope.schema._bootstrapinterfaces import WrongType
         klass = self._getTargetClass()
         inst = DummyInst()
         pw = self._makeOne(__name__='password').bind(inst)
-        self.assertRaises(WrongType,
-                          pw.validate, klass.UNCHANGED_PASSWORD)
+        self.assertRaisesWrongType(pw, pw._type, klass.UNCHANGED_PASSWORD)
 
     def test_validate_unchanged_already_set(self):
         klass = self._getTargetClass()
@@ -957,6 +1062,7 @@ class BoolTests(EqualityTestsMixin,
 
 class NumberTests(EqualityTestsMixin,
                   OrderableMissingValueMixin,
+                  OrderableTestsMixin,
                   unittest.TestCase):
 
     def _getTargetClass(self):
@@ -988,7 +1094,8 @@ class ComplexTests(NumberTests):
         from zope.schema.interfaces import IComplex
         return IComplex
 
-class RealTests(NumberTests):
+class RealTests(WrongTypeTestsMixin,
+                NumberTests):
 
     def _getTargetClass(self):
         from zope.schema._bootstrapfields import Real
@@ -999,22 +1106,18 @@ class RealTests(NumberTests):
         return IReal
 
     def test_ctor_real_min_max(self):
-        from zope.schema.interfaces import WrongType
-        from zope.schema.interfaces import TooSmall
-        from zope.schema.interfaces import TooBig
         from fractions import Fraction
 
-        with self.assertRaises(WrongType):
-            self._makeOne(min='')
-        with self.assertRaises(WrongType):
-            self._makeOne(max='')
+        self.assertRaisesWrongType(self._makeOne, self._getTargetClass()._type, min='')
+        self.assertRaisesWrongType(self._makeOne, self._getTargetClass()._type, max='')
 
         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):
 
@@ -1052,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):
 
@@ -1113,6 +1189,7 @@ class IntTests(IntegralTests):
 
 
 class ObjectTests(EqualityTestsMixin,
+                  WrongTypeTestsMixin,
                   unittest.TestCase):
 
     def setUp(self):
@@ -1142,10 +1219,10 @@ class ObjectTests(EqualityTestsMixin,
         return InterfaceClass('ISchema', (Interface,), kw)
 
     def _getErrors(self, f, *args, **kw):
-        from zope.schema.interfaces import WrongContainedType
-        with self.assertRaises(WrongContainedType) as e:
+        from zope.schema.interfaces import SchemaNotCorrectlyImplemented
+        with self.assertRaises(SchemaNotCorrectlyImplemented) as e:
             f(*args, **kw)
-        return e.exception.args[0]
+        return e.exception.errors
 
     def _makeCycles(self):
         from zope.interface import Interface
@@ -1205,8 +1282,8 @@ class ObjectTests(EqualityTestsMixin,
         verifyObject(IObject, self._makeOne())
 
     def test_ctor_w_bad_schema(self):
-        from zope.schema.interfaces import WrongType
-        self.assertRaises(WrongType, self._makeOne, object())
+        from zope.interface.interfaces import IInterface
+        self.assertRaisesWrongType(self._makeOne, IInterface, object())
 
     def test_validate_not_required(self):
         schema = self._makeSchema()
@@ -1355,19 +1432,39 @@ class ObjectTests(EqualityTestsMixin,
         field.validate(unit)  # doesn't raise
 
     def test_validate_w_cycles_object_not_valid(self):
-        from zope.schema.interfaces import WrongContainedType
+        from zope.schema.interfaces import SchemaNotCorrectlyImplemented
+        from zope.schema.interfaces import SchemaNotProvided
         IUnit, Person, Unit = self._makeCycles()
         field = self._makeOne(schema=IUnit)
         person1 = Person(None)
         person2 = Person(None)
-        person3 = Person(object())
-        unit = Unit(person3, [person1, person2])
+        boss_unit = object()
+        boss = Person(boss_unit)
+        unit = Unit(boss, [person1, person2])
         person1.unit = unit
         person2.unit = unit
-        self.assertRaises(WrongContainedType, field.validate, unit)
+        with self.assertRaises(SchemaNotCorrectlyImplemented) as exc:
+            field.validate(unit)
+
+        ex = exc.exception
+        self.assertEqual(1, len(ex.schema_errors))
+        self.assertEqual(1, len(ex.errors))
+        self.assertEqual(0, len(ex.invariant_errors))
+
+        boss_error = ex.schema_errors['boss']
+        self.assertIsInstance(boss_error, SchemaNotCorrectlyImplemented)
+
+        self.assertEqual(1, len(boss_error.schema_errors))
+        self.assertEqual(1, len(boss_error.errors))
+        self.assertEqual(0, len(boss_error.invariant_errors))
+
+        unit_error = boss_error.schema_errors['unit']
+        self.assertIsInstance(unit_error, SchemaNotProvided)
+        self.assertIs(IUnit, unit_error.schema)
+        self.assertIs(boss_unit, unit_error.value)
 
     def test_validate_w_cycles_collection_not_valid(self):
-        from zope.schema.interfaces import WrongContainedType
+        from zope.schema.interfaces import SchemaNotCorrectlyImplemented
         IUnit, Person, Unit = self._makeCycles()
         field = self._makeOne(schema=IUnit)
         person1 = Person(None)
@@ -1376,7 +1473,7 @@ class ObjectTests(EqualityTestsMixin,
         unit = Unit(person1, [person2, person3])
         person1.unit = unit
         person2.unit = unit
-        self.assertRaises(WrongContainedType, field.validate, unit)
+        self.assertRaises(SchemaNotCorrectlyImplemented, field.validate, unit)
 
     def test_set_emits_IBOAE(self):
         from zope.event import subscribers
@@ -1517,7 +1614,10 @@ class ObjectTests(EqualityTestsMixin,
         self.assertIs(field.schema, IValueType)
 
         # Non implementation is bad
-        self.assertRaises(SchemaNotProvided, field.validate, object())
+        with self.assertRaises(SchemaNotProvided) as exc:
+            field.validate(object())
+
+        self.assertIs(IValueType, exc.exception.schema)
 
         # Actual implementation works
         @interface.implementer(IValueType)
@@ -1536,6 +1636,7 @@ class ObjectTests(EqualityTestsMixin,
         from zope.schema.fieldproperty import FieldProperty
         from zope.schema.interfaces import IContextSourceBinder
         from zope.schema.interfaces import WrongContainedType
+        from zope.schema.interfaces import ConstraintNotSatisfied
         from zope.schema.interfaces import SchemaNotCorrectlyImplemented
         from zope.schema.vocabulary import SimpleVocabulary
 
@@ -1577,12 +1678,28 @@ class ObjectTests(EqualityTestsMixin,
 
         # Ranges outside the context fail
         bad_choices = Choices({1, 8})
-        with self.assertRaises(WrongContainedType) as exc:
+        with self.assertRaises(SchemaNotCorrectlyImplemented) as exc:
             IFavorites['fav'].validate(bad_choices)
 
         e = exc.exception
         self.assertEqual(IFavorites['fav'], e.field)
         self.assertEqual(bad_choices, e.value)
+        self.assertEqual(1, len(e.schema_errors))
+        self.assertEqual(0, len(e.invariant_errors))
+        self.assertEqual(1, len(e.errors))
+
+        fav_error = e.schema_errors['choices']
+        self.assertIs(fav_error, e.errors[0])
+        self.assertIsInstance(fav_error, WrongContainedType)
+        self.assertNotIsInstance(fav_error, SchemaNotCorrectlyImplemented)
+        # The field is not actually equal to the one in the interface
+        # anymore because its bound.
+        self.assertEqual('choices', fav_error.field.__name__)
+        self.assertEqual(bad_choices, fav_error.field.context)
+        self.assertEqual({1, 8}, fav_error.value)
+        self.assertEqual(1, len(fav_error.errors))
+
+        self.assertIsInstance(fav_error.errors[0], ConstraintNotSatisfied)
 
         # Validation through field property
         favorites = Favorites()
diff --git a/src/zope/schema/tests/test__bootstrapinterfaces.py b/src/zope/schema/tests/test__bootstrapinterfaces.py
index 73e4dd1..77815c0 100644
--- a/src/zope/schema/tests/test__bootstrapinterfaces.py
+++ b/src/zope/schema/tests/test__bootstrapinterfaces.py
@@ -48,11 +48,26 @@ class ValidationErrorTests(unittest.TestCase):
 
     def test___eq___no_args(self):
         ve = self._makeOne()
-        self.assertEqual(ve == object(), False)
+        self.assertNotEqual(ve, object())
+        self.assertNotEqual(object(), ve)
 
     def test___eq___w_args(self):
         left = self._makeOne('abc')
         right = self._makeOne('def')
-        self.assertEqual(left == right, False)
-        self.assertEqual(left == left, True)
-        self.assertEqual(right == right, True)
+        self.assertNotEqual(left, right)
+        self.assertNotEqual(right, left)
+        self.assertEqual(left, left)
+        self.assertEqual(right, right)
+
+
+class TestOutOfBounds(unittest.TestCase):
+
+    def _getTargetClass(self):
+        from zope.schema._bootstrapinterfaces import OutOfBounds
+        return OutOfBounds
+
+    def test_TOO_LARGE_repr(self):
+        self.assertIn('TOO_LARGE', repr(self._getTargetClass().TOO_LARGE))
+
+    def test_TOO_SMALL_repr(self):
+        self.assertIn('TOO_SMALL', repr(self._getTargetClass().TOO_SMALL))
diff --git a/src/zope/schema/tests/test__field.py b/src/zope/schema/tests/test__field.py
index c176326..a5b2c7b 100644
--- a/src/zope/schema/tests/test__field.py
+++ b/src/zope/schema/tests/test__field.py
@@ -16,9 +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
@@ -26,7 +30,9 @@ from zope.schema.tests.test__bootstrapfields import EqualityTestsMixin
 # pylint:disable=no-member
 # pylint:disable=blacklisted-name
 
-class BytesTests(EqualityTestsMixin, unittest.TestCase):
+class BytesTests(EqualityTestsMixin,
+                 WrongTypeTestsMixin,
+                 unittest.TestCase):
 
     def _getTargetClass(self):
         from zope.schema._field import Bytes
@@ -37,18 +43,19 @@ class BytesTests(EqualityTestsMixin, unittest.TestCase):
         return IBytes
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
-
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_w_invalid_default(self):
 
@@ -84,6 +91,7 @@ class BytesTests(EqualityTestsMixin, unittest.TestCase):
 
 
 class ASCIITests(EqualityTestsMixin,
+                 WrongTypeTestsMixin,
                  unittest.TestCase):
 
     def _getTargetClass(self):
@@ -95,18 +103,20 @@ class ASCIITests(EqualityTestsMixin,
         return IASCII
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
         from zope.schema._compat import non_native_string
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, non_native_string(''))
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            non_native_string(''),
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test__validate_empty(self):
         asc = self._makeOne()
@@ -129,6 +139,7 @@ class ASCIITests(EqualityTestsMixin,
 
 
 class BytesLineTests(EqualityTestsMixin,
+                     WrongTypeTestsMixin,
                      unittest.TestCase):
 
     def _getTargetClass(self):
@@ -140,18 +151,19 @@ class BytesLineTests(EqualityTestsMixin,
         return IBytesLine
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
-
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_not_required(self):
 
@@ -181,6 +193,7 @@ class BytesLineTests(EqualityTestsMixin,
 
 
 class ASCIILineTests(EqualityTestsMixin,
+                     WrongTypeTestsMixin,
                      unittest.TestCase):
 
     def _getTargetClass(self):
@@ -192,18 +205,20 @@ class ASCIILineTests(EqualityTestsMixin,
         return IASCIILine
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
         from zope.schema._compat import non_native_string
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, non_native_string(''))
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            non_native_string(''),
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_not_required(self):
         from zope.schema.interfaces import InvalidValue
@@ -232,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
@@ -261,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()
@@ -304,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
@@ -333,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()
@@ -395,7 +353,10 @@ class DecimalTests(OrderableMissingValueMixin, EqualityTestsMixin,
         self.assertEqual(flt.fromUnicode(u'12345.6'), Decimal('12345.6'))
 
 
-class DatetimeTests(OrderableMissingValueMixin, EqualityTestsMixin,
+class DatetimeTests(OrderableMissingValueMixin,
+                    OrderableTestsMixin,
+                    EqualityTestsMixin,
+                    WrongTypeTestsMixin,
                     unittest.TestCase):
 
     mvm_missing_value = datetime.datetime.now()
@@ -411,21 +372,20 @@ class DatetimeTests(OrderableMissingValueMixin, EqualityTestsMixin,
 
     def test_validate_wrong_types(self):
         from datetime import date
-        from zope.schema.interfaces import WrongType
-
-
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
-        self.assertRaises(WrongType, field.validate, date.today())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object(),
+            date.today())
 
     def test_validate_not_required(self):
         field = self._makeOne(required=False)
@@ -437,42 +397,17 @@ class DatetimeTests(OrderableMissingValueMixin, EqualityTestsMixin,
         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)
-
-
-class DateTests(OrderableMissingValueMixin, EqualityTestsMixin,
+    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):
 
     mvm_missing_value = datetime.date.today()
@@ -487,26 +422,20 @@ class DateTests(OrderableMissingValueMixin, EqualityTestsMixin,
         return IDate
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
-
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
-        now = datetime.datetime.now()
-        with self.assertRaises(WrongType) as exc:
-            field.validate(now)
-
-        wrong_type = exc.exception
-        self.assertIs(wrong_type.field, field)
-        self.assertIs(wrong_type.value, now)
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object(),
+            datetime.datetime.now())
 
     def test_validate_not_required(self):
         from datetime import date
@@ -520,46 +449,16 @@ class DateTests(OrderableMissingValueMixin, EqualityTestsMixin,
         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)
@@ -586,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)
@@ -651,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,
@@ -983,6 +821,7 @@ class ChoiceTests(EqualityTestsMixin,
 
 
 class URITests(EqualityTestsMixin,
+               WrongTypeTestsMixin,
                unittest.TestCase):
 
     def _getTargetClass(self):
@@ -997,15 +836,18 @@ class URITests(EqualityTestsMixin,
         from zope.schema.interfaces import WrongType
         from zope.schema._compat import non_native_string
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, non_native_string(''))
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            non_native_string(''),
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_not_required(self):
         field = self._makeOne(required=False)
@@ -1052,6 +894,7 @@ class URITests(EqualityTestsMixin,
 
 
 class DottedNameTests(EqualityTestsMixin,
+                      WrongTypeTestsMixin,
                       unittest.TestCase):
 
     def _getTargetClass(self):
@@ -1082,18 +925,20 @@ class DottedNameTests(EqualityTestsMixin,
         self.assertEqual(dotted.max_dots, 2)
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
         from zope.schema._compat import non_native_string
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, non_native_string(''))
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            non_native_string(''),
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_not_required(self):
         field = self._makeOne(required=False)
@@ -1162,6 +1007,7 @@ class DottedNameTests(EqualityTestsMixin,
 
 
 class IdTests(EqualityTestsMixin,
+              WrongTypeTestsMixin,
               unittest.TestCase):
 
     def _getTargetClass(self):
@@ -1176,21 +1022,18 @@ class IdTests(EqualityTestsMixin,
         from zope.schema.interfaces import WrongType
         from zope.schema._compat import non_native_string
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, non_native_string(''))
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        bad_value = object()
-        with self.assertRaises(WrongType) as exc:
-            field.validate(bad_value)
-
-        wrong = exc.exception
-        self.assertIs(wrong.field, field)
-        self.assertEqual(wrong.value, bad_value)
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            non_native_string(''),
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_not_required(self):
         field = self._makeOne(required=False)
@@ -1245,6 +1088,7 @@ class IdTests(EqualityTestsMixin,
 
 
 class InterfaceFieldTests(EqualityTestsMixin,
+                          WrongTypeTestsMixin,
                           unittest.TestCase):
 
     def _getTargetClass(self):
@@ -1256,28 +1100,24 @@ class InterfaceFieldTests(EqualityTestsMixin,
         return IInterfaceField
 
     def test_validate_wrong_types(self):
+        from zope.interface.interfaces import IInterface
         from datetime import date
-        from zope.schema.interfaces import WrongType
-
 
         field = self._makeOne()
-        with self.assertRaises(WrongType) as exc:
-            field.validate(u'')
-
-        wrong = exc.exception
-        self.assertIs(wrong.field, field)
-        self.assertEqual(wrong.value, u'')
-
-        self.assertRaises(WrongType, field.validate, b'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
-        self.assertRaises(WrongType, field.validate, date.today())
+        self.assertAllRaiseWrongType(
+            field,
+            IInterface,
+            u'',
+            b'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            set(),
+            frozenset(),
+            object(),
+            date.today())
 
     def test_validate_not_required(self):
         from zope.interface import Interface
@@ -1302,6 +1142,7 @@ class InterfaceFieldTests(EqualityTestsMixin,
 
 
 class CollectionTests(EqualityTestsMixin,
+                      LenTestsMixin,
                       unittest.TestCase):
 
     _DEFAULT_UNIQUE = False
@@ -1320,6 +1161,7 @@ class CollectionTests(EqualityTestsMixin,
     def test_schema_defined_by_subclass(self):
         from zope import interface
         from zope.schema import Object
+        from zope.schema.interfaces import SchemaNotProvided
         from zope.schema.interfaces import WrongContainedType
 
         class IValueType(interface.Interface):
@@ -1337,7 +1179,14 @@ class CollectionTests(EqualityTestsMixin,
         field.validate(self._makeCollection([]))
 
         # Collection with a non-implemented object is bad
-        self.assertRaises(WrongContainedType, field.validate, self._makeCollection([object()]))
+        with self.assertRaises(WrongContainedType) as exc:
+            field.validate(self._makeCollection([object()]))
+
+        ex = exc.exception
+        self.assertIs(ex.__class__, WrongContainedType)
+        self.assertEqual(1, len(ex.errors))
+        self.assertIsInstance(ex.errors[0], SchemaNotProvided)
+        self.assertIs(ex.errors[0].schema, IValueType)
 
         # Actual implementation works
         @interface.implementer(IValueType)
@@ -1385,6 +1234,7 @@ class CollectionTests(EqualityTestsMixin,
 
     def test__validate_wrong_contained_type(self):
         from zope.schema.interfaces import WrongContainedType
+        from zope.schema.interfaces import WrongType
         from zope.schema._bootstrapfields import Text
         text = Text()
         absc = self._makeOne(text)
@@ -1394,6 +1244,10 @@ class CollectionTests(EqualityTestsMixin,
         wct = exc.exception
         self.assertIs(wct.field, absc)
         self.assertEqual(wct.value, self._makeCollection([1]))
+        self.assertIs(wct.__class__, WrongContainedType)
+        self.assertEqual(1, len(wct.errors))
+        self.assertIsInstance(wct.errors[0], WrongType)
+        self.assertIs(wct.errors[0].expected_type, text._type)
 
     def test__validate_miss_uniqueness(self):
         from zope.schema.interfaces import NotUnique
@@ -1411,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)
@@ -1455,7 +1305,8 @@ class CollectionTests(EqualityTestsMixin,
         self.assertRaises(RequiredMissing, field.validate, None)
 
 
-class SequenceTests(CollectionTests):
+class SequenceTests(WrongTypeTestsMixin,
+                    CollectionTests):
 
     def _getTargetClass(self):
         from zope.schema._field import Sequence
@@ -1466,15 +1317,16 @@ class SequenceTests(CollectionTests):
         return ISequence
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
-
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            1,
+            1.0,
+            {},
+            set(),
+            frozenset(),
+            object())
 
     def test_sequence(self):
         from zope.schema._field import abc
@@ -1534,11 +1386,13 @@ class TupleTests(SequenceTests):
             super(TupleTests, self).test_sequence()
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, b'')
-        self.assertRaises(WrongType, field.validate, [])
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            b'',
+            [])
         super(TupleTests, self).test_validate_wrong_types()
 
 
@@ -1553,11 +1407,13 @@ class MutableSequenceTests(SequenceTests):
         return IMutableSequence
 
     def test_validate_wrong_types(self):
-        from zope.schema.interfaces import WrongType
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, b'')
-        self.assertRaises(WrongType, field.validate, ())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            b'',
+            ())
         super(MutableSequenceTests, self).test_validate_wrong_types()
 
     def test_sequence(self):
@@ -1582,7 +1438,8 @@ class ListTests(MutableSequenceTests):
             super(ListTests, self).test_mutable_sequence()
 
 
-class SetTests(CollectionTests):
+class SetTests(WrongTypeTestsMixin,
+               CollectionTests):
 
     _DEFAULT_UNIQUE = True
     _makeCollection = set
@@ -1605,15 +1462,18 @@ class SetTests(CollectionTests):
         from zope.schema.interfaces import WrongType
 
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, b'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, {})
-        self.assertRaises(WrongType, field.validate, self._makeWrongSet())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            b'',
+            1,
+            1.0,
+            (),
+            [],
+            {},
+            self._makeWrongSet(),
+            object())
 
 
 class FrozenSetTests(SetTests):
@@ -1631,6 +1491,8 @@ class FrozenSetTests(SetTests):
 
 
 class MappingTests(EqualityTestsMixin,
+                   WrongTypeTestsMixin,
+                   LenTestsMixin,
                    unittest.TestCase):
 
     def _getTargetClass(self):
@@ -1651,15 +1513,18 @@ class MappingTests(EqualityTestsMixin,
         from zope.schema.interfaces import WrongType
 
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, u'')
-        self.assertRaises(WrongType, field.validate, 1)
-        self.assertRaises(WrongType, field.validate, 1.0)
-        self.assertRaises(WrongType, field.validate, ())
-        self.assertRaises(WrongType, field.validate, [])
-        self.assertRaises(WrongType, field.validate, set())
-        self.assertRaises(WrongType, field.validate, frozenset())
-        self.assertRaises(WrongType, field.validate, object())
+        self.assertAllRaiseWrongType(
+            field,
+            field._type,
+            u'',
+            b'',
+            1,
+            1.0,
+            (),
+            [],
+            set(),
+            frozenset(),
+            object())
 
     def test_validate_not_required(self):
         field = self._makeOne(required=False)
@@ -1678,6 +1543,7 @@ class MappingTests(EqualityTestsMixin,
 
     def test_validate_invalid_key_type(self):
         from zope.schema.interfaces import WrongContainedType
+        from zope.schema.interfaces import WrongType
         from zope.schema._bootstrapfields import Int
         field = self._makeOne(key_type=Int())
         field.validate({})
@@ -1689,9 +1555,14 @@ class MappingTests(EqualityTestsMixin,
         wct = exc.exception
         self.assertIs(wct.field, field)
         self.assertEqual(wct.value, {'a': 1})
+        self.assertIs(wct.__class__, WrongContainedType)
+        self.assertEqual(1, len(wct.errors))
+        self.assertIsInstance(wct.errors[0], WrongType)
+        self.assertIs(field.key_type._type, wct.errors[0].expected_type)
 
     def test_validate_invalid_value_type(self):
         from zope.schema.interfaces import WrongContainedType
+        from zope.schema.interfaces import WrongType
         from zope.schema._bootstrapfields import Int
         field = self._makeOne(value_type=Int())
         field.validate({})
@@ -1703,30 +1574,31 @@ class MappingTests(EqualityTestsMixin,
         wct = exc.exception
         self.assertIs(wct.field, field)
         self.assertEqual(wct.value, {1: 'a'})
+        self.assertIs(wct.__class__, WrongContainedType)
+        self.assertEqual(1, len(wct.errors))
+        self.assertIsInstance(wct.errors[0], WrongType)
+        self.assertIs(field.value_type._type, wct.errors[0].expected_type)
+
 
     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

pip install -e .[test]
parse_log_pytest
requirements.txt
pytest coverage sphinx
apt-get update apt-get install -y gcc
3.9
requirements/base.txt
pytest --no-header -rA --tb=line --color=no -p no:cacheprovider -W ignore::DeprecationWarning
alabaster==0.7.16
babel==2.17.0
certifi==2025.1.31
charset-normalizer==3.4.1
coverage==7.8.0
docutils==0.21.2
exceptiongroup==1.2.2
idna==3.10
imagesize==1.4.1
importlib_metadata==8.6.1
iniconfig==2.1.0
Jinja2==3.1.6
MarkupSafe==3.0.2
packaging==24.2
pluggy==1.5.0
Pygments==2.19.1
pytest==8.3.5
requests==2.32.3
snowballstemmer==2.2.0
Sphinx==7.4.7
sphinxcontrib-applehelp==2.0.0
sphinxcontrib-devhelp==2.0.0
sphinxcontrib-htmlhelp==2.1.0
sphinxcontrib-jsmath==1.0.1
sphinxcontrib-qthelp==2.0.0
sphinxcontrib-serializinghtml==2.0.0
tomli==2.2.1
urllib3==2.3.0
zipp==3.21.0
zope.event==5.0
zope.exceptions==5.2
zope.i18nmessageid==7.0
zope.interface==7.2
-e git+https://github.com/zopefoundation/zope.schema.git@b6cc7d2cff904129c36e867f369c577d85c1ba2e#egg=zope.schema
zope.testing==5.1
zope.testrunner==7.2

name: zope.schema
channels:
  - defaults
  - https://repo.anaconda.com/pkgs/main
  - https://repo.anaconda.com/pkgs/r
  - conda-forge
dependencies:
  - _libgcc_mutex=0.1=main
  - _openmp_mutex=5.1=1_gnu
  - ca-certificates=2025.2.25=h06a4308_0
  - ld_impl_linux-64=2.40=h12ee557_0
  - libffi=3.4.4=h6a678d5_1
  - libgcc-ng=11.2.0=h1234567_1
  - libgomp=11.2.0=h1234567_1
  - libstdcxx-ng=11.2.0=h1234567_1
  - ncurses=6.4=h6a678d5_0
  - openssl=3.0.16=h5eee18b_0
  - pip=25.0=py39h06a4308_0
  - python=3.9.21=he870216_1
  - readline=8.2=h5eee18b_0
  - setuptools=75.8.0=py39h06a4308_0
  - sqlite=3.45.3=h5eee18b_0
  - tk=8.6.14=h39e8969_0
  - tzdata=2025a=h04d1e81_0
  - wheel=0.45.1=py39h06a4308_0
  - xz=5.6.4=h5eee18b_1
  - zlib=1.2.13=h5eee18b_1
  - pip:
      - alabaster==0.7.16
      - babel==2.17.0
      - certifi==2025.1.31
      - charset-normalizer==3.4.1
      - coverage==7.8.0
      - docutils==0.21.2
      - exceptiongroup==1.2.2
      - idna==3.10
      - imagesize==1.4.1
      - importlib-metadata==8.6.1
      - iniconfig==2.1.0
      - jinja2==3.1.6
      - markupsafe==3.0.2
      - packaging==24.2
      - pluggy==1.5.0
      - pygments==2.19.1
      - pytest==8.3.5
      - requests==2.32.3
      - snowballstemmer==2.2.0
      - sphinx==7.4.7
      - sphinxcontrib-applehelp==2.0.0
      - sphinxcontrib-devhelp==2.0.0
      - sphinxcontrib-htmlhelp==2.1.0
      - sphinxcontrib-jsmath==1.0.1
      - sphinxcontrib-qthelp==2.0.0
      - sphinxcontrib-serializinghtml==2.0.0
      - tomli==2.2.1
      - urllib3==2.3.0
      - zipp==3.21.0
      - zope-event==5.0
      - zope-exceptions==5.2
      - zope-i18nmessageid==7.0
      - zope-interface==7.2
      - zope-testing==5.1
      - zope-testrunner==7.2
prefix: /opt/conda/envs/zope.schema

src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_validate_wrong_type src/zope/schema/tests/test__bootstrapfields.py::MinMaxLenTests::test_validate_too_long src/zope/schema/tests/test__bootstrapfields.py::MinMaxLenTests::test_validate_too_short src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_fromUnicode_miss src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_validate_wrong_types src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_validate_wrong_types src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_validate_unchanged_not_already_set src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_validate_max src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_validate_min src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_validate_min_and_max src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_validate_max src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_validate_min src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_validate_min_and_max src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_ctor_real_min_max src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_validate_max src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_validate_min src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_validate_min_and_max src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_validate_max src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_validate_min src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_validate_min_and_max src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_validate_max src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_validate_min src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_validate_min_and_max src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_validate_max src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_validate_min src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_validate_min_and_max src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test__validate_w_value_providing_schema_but_invalid_fields src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test__validate_w_value_providing_schema_but_missing_fields src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_bound_field_of_collection_with_choice src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_ctor_w_bad_schema src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_schema_defined_by_subclass src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_validate_w_cycles_object_not_valid src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_validates_invariants_by_default src/zope/schema/tests/test__bootstrapinterfaces.py::TestOutOfBounds::test_TOO_LARGE_repr src/zope/schema/tests/test__bootstrapinterfaces.py::TestOutOfBounds::test_TOO_SMALL_repr src/zope/schema/tests/test__field.py::NumberTests::test_validate_max src/zope/schema/tests/test__field.py::NumberTests::test_validate_min src/zope/schema/tests/test__field.py::NumberTests::test_validate_min_and_max src/zope/schema/tests/test__field.py::BytesTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::ASCIITests::test_validate_wrong_types src/zope/schema/tests/test__field.py::BytesLineTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::ASCIILineTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::FloatTests::test_validate_max src/zope/schema/tests/test__field.py::FloatTests::test_validate_min src/zope/schema/tests/test__field.py::FloatTests::test_validate_min_and_max src/zope/schema/tests/test__field.py::DecimalTests::test_validate_max src/zope/schema/tests/test__field.py::DecimalTests::test_validate_min src/zope/schema/tests/test__field.py::DecimalTests::test_validate_min_and_max src/zope/schema/tests/test__field.py::DatetimeTests::test_validate_max src/zope/schema/tests/test__field.py::DatetimeTests::test_validate_min src/zope/schema/tests/test__field.py::DatetimeTests::test_validate_min_and_max src/zope/schema/tests/test__field.py::DatetimeTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::DateTests::test_validate_max src/zope/schema/tests/test__field.py::DateTests::test_validate_min src/zope/schema/tests/test__field.py::DateTests::test_validate_min_and_max src/zope/schema/tests/test__field.py::DateTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::TimedeltaTests::test_validate_max src/zope/schema/tests/test__field.py::TimedeltaTests::test_validate_min src/zope/schema/tests/test__field.py::TimedeltaTests::test_validate_min_and_max src/zope/schema/tests/test__field.py::TimeTests::test_validate_max src/zope/schema/tests/test__field.py::TimeTests::test_validate_min src/zope/schema/tests/test__field.py::TimeTests::test_validate_min_and_max src/zope/schema/tests/test__field.py::URITests::test_validate_wrong_types src/zope/schema/tests/test__field.py::DottedNameTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::IdTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::CollectionTests::test__validate_wrong_contained_type src/zope/schema/tests/test__field.py::CollectionTests::test_schema_defined_by_subclass src/zope/schema/tests/test__field.py::CollectionTests::test_validate_max_length src/zope/schema/tests/test__field.py::CollectionTests::test_validate_min_length src/zope/schema/tests/test__field.py::CollectionTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::SequenceTests::test__validate_wrong_contained_type src/zope/schema/tests/test__field.py::SequenceTests::test_schema_defined_by_subclass src/zope/schema/tests/test__field.py::SequenceTests::test_validate_max_length src/zope/schema/tests/test__field.py::SequenceTests::test_validate_min_length src/zope/schema/tests/test__field.py::SequenceTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::SequenceTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::TupleTests::test__validate_wrong_contained_type src/zope/schema/tests/test__field.py::TupleTests::test_schema_defined_by_subclass src/zope/schema/tests/test__field.py::TupleTests::test_validate_max_length src/zope/schema/tests/test__field.py::TupleTests::test_validate_min_length src/zope/schema/tests/test__field.py::TupleTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::TupleTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::MutableSequenceTests::test__validate_wrong_contained_type src/zope/schema/tests/test__field.py::MutableSequenceTests::test_schema_defined_by_subclass src/zope/schema/tests/test__field.py::MutableSequenceTests::test_validate_max_length src/zope/schema/tests/test__field.py::MutableSequenceTests::test_validate_min_length src/zope/schema/tests/test__field.py::MutableSequenceTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::MutableSequenceTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::ListTests::test__validate_wrong_contained_type src/zope/schema/tests/test__field.py::ListTests::test_schema_defined_by_subclass src/zope/schema/tests/test__field.py::ListTests::test_validate_max_length src/zope/schema/tests/test__field.py::ListTests::test_validate_min_length src/zope/schema/tests/test__field.py::ListTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::ListTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::SetTests::test__validate_wrong_contained_type src/zope/schema/tests/test__field.py::SetTests::test_schema_defined_by_subclass src/zope/schema/tests/test__field.py::SetTests::test_validate_max_length src/zope/schema/tests/test__field.py::SetTests::test_validate_min_length src/zope/schema/tests/test__field.py::SetTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::SetTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::FrozenSetTests::test__validate_wrong_contained_type src/zope/schema/tests/test__field.py::FrozenSetTests::test_schema_defined_by_subclass src/zope/schema/tests/test__field.py::FrozenSetTests::test_validate_max_length src/zope/schema/tests/test__field.py::FrozenSetTests::test_validate_min_length src/zope/schema/tests/test__field.py::FrozenSetTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::FrozenSetTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::MappingTests::test_validate_invalid_key_type src/zope/schema/tests/test__field.py::MappingTests::test_validate_invalid_value_type src/zope/schema/tests/test__field.py::MappingTests::test_validate_max_length src/zope/schema/tests/test__field.py::MappingTests::test_validate_min_length src/zope/schema/tests/test__field.py::MappingTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::MappingTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_invalid_key_type src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_invalid_value_type src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_max_length src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_min_length src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_wrong_types src/zope/schema/tests/test__field.py::DictTests::test_validate_invalid_key_type src/zope/schema/tests/test__field.py::DictTests::test_validate_invalid_value_type src/zope/schema/tests/test__field.py::DictTests::test_validate_max_length src/zope/schema/tests/test__field.py::DictTests::test_validate_min_length src/zope/schema/tests/test__field.py::DictTests::test_validate_min_length_and_max_length src/zope/schema/tests/test__field.py::DictTests::test_validate_wrong_types
src/zope/schema/tests/test__bootstrapfields.py::test_suite
src/zope/schema/tests/test__bootstrapfields.py::ValidatedPropertyTests::test___get__ src/zope/schema/tests/test__bootstrapfields.py::ValidatedPropertyTests::test___set___not_missing_w_check src/zope/schema/tests/test__bootstrapfields.py::ValidatedPropertyTests::test___set___not_missing_wo_check src/zope/schema/tests/test__bootstrapfields.py::ValidatedPropertyTests::test___set___w_missing_wo_check src/zope/schema/tests/test__bootstrapfields.py::DefaultPropertyTests::test___get___w_defaultFactory_not_ICAF_no_check src/zope/schema/tests/test__bootstrapfields.py::DefaultPropertyTests::test___get___w_defaultFactory_w_ICAF_w_check src/zope/schema/tests/test__bootstrapfields.py::DefaultPropertyTests::test___get___wo_defaultFactory_hit src/zope/schema/tests/test__bootstrapfields.py::DefaultPropertyTests::test___get___wo_defaultFactory_miss src/zope/schema/tests/test__bootstrapfields.py::DefaultPropertyTests::test__get___wo_defaultFactory_in_dict src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_bind src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_ctor_defaults src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_ctor_description_preserved src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_ctor_order_madness src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_ctor_w_both_title_and_description src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_ctor_w_title_wo_description src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_ctor_wo_title_w_description src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_explicit_constraint_default src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_explicit_defaultFactory src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_explicit_defaultFactory_returning_missing_value src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_explicit_required_readonly_missingValue src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_getDoc src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_get_hit src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_get_miss src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_query_hit src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_query_miss_no_default src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_query_miss_w_default src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_set_hit src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_set_readonly src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_validate_constraint_fails src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_validate_constraint_raises_StopValidation src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_validate_constraint_raises_custom_exception src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_validate_constraint_raises_custom_exception_no_overwrite src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_validate_missing_and_required src/zope/schema/tests/test__bootstrapfields.py::FieldTests::test_validate_missing_not_required src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test__validate_collection_but_not_iterable src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test__validate_not_collection_but_iterable src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test__validate_not_collection_not_iterable src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test__validate_w_collections src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::ContainerTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test__validate_collection_but_not_iterable src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test__validate_not_collection_but_iterable src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test__validate_not_collection_not_iterable src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test__validate_w_collections src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::IterableTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::OrderableTests::test_ctor_default_too_large src/zope/schema/tests/test__bootstrapfields.py::OrderableTests::test_ctor_default_too_small src/zope/schema/tests/test__bootstrapfields.py::OrderableTests::test_ctor_defaults src/zope/schema/tests/test__bootstrapfields.py::MinMaxLenTests::test_ctor_defaults src/zope/schema/tests/test__bootstrapfields.py::TextTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::TextTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::TextTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_ctor_defaults src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_fromUnicode_hit src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::TextTests::test_validate_w_invalid_default src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_constraint src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::TextLineTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_constraint src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_set_normal src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_set_unchanged src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::PasswordTests::test_validate_unchanged_already_set src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test__validate_w_int src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_ctor_defaults src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_fromUnicode_hit src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_fromUnicode_miss src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::BoolTests::test_set_w_int src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::NumberTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::ComplexTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__bootstrapfields.py::RealTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::RealTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::RealTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::RealTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::RationalTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_fromUnicode_hit src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_fromUnicode_miss src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::IntegralTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::IntTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::IntTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::IntTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_ctor_defaults src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_fromUnicode_hit src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_fromUnicode_miss src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::IntTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test___eq___different_type src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test__validate_w_empty_schema src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test__validate_w_value_not_providing_schema src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test__validate_w_value_providing_schema src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_class_conforms_to_IObject src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_class_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_getDoc src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_hash_across_unequal_instances src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_instance_conforms_to_IObject src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_instance_conforms_to_iface src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_is_hashable src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_set_allows_IBOAE_subscr_to_replace_value src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_set_emits_IBOAE src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_validate_not_required src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_validate_required src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_validate_w_cycles src/zope/schema/tests/test__bootstrapfields.py::ObjectTests::test_validate_w_cycles_collection_not_valid src/zope/schema/tests/test__bootstrapinterfaces.py::ValidationErrorTests::test___cmp___hit src/zope/schema/tests/test__bootstrapinterfaces.py::ValidationErrorTests::test___cmp___no_args src/zope/schema/tests/test__bootstrapinterfaces.py::ValidationErrorTests::test___eq___no_args src/zope/schema/tests/test__bootstrapinterfaces.py::ValidationErrorTests::test___eq___w_args src/zope/schema/tests/test__bootstrapinterfaces.py::ValidationErrorTests::test_doc src/zope/schema/tests/test__field.py::NumberTests::test___eq___different_type src/zope/schema/tests/test__field.py::NumberTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::NumberTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::NumberTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::NumberTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::NumberTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::NumberTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::NumberTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::NumberTests::test_is_hashable src/zope/schema/tests/test__field.py::NumberTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__field.py::BytesTests::test___eq___different_type src/zope/schema/tests/test__field.py::BytesTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::BytesTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::BytesTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::BytesTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::BytesTests::test_fromUnicode_hit src/zope/schema/tests/test__field.py::BytesTests::test_fromUnicode_miss src/zope/schema/tests/test__field.py::BytesTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::BytesTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::BytesTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::BytesTests::test_is_hashable src/zope/schema/tests/test__field.py::BytesTests::test_validate_not_required src/zope/schema/tests/test__field.py::BytesTests::test_validate_required src/zope/schema/tests/test__field.py::BytesTests::test_validate_w_invalid_default src/zope/schema/tests/test__field.py::ASCIITests::test___eq___different_type src/zope/schema/tests/test__field.py::ASCIITests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::ASCIITests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::ASCIITests::test__validate_empty src/zope/schema/tests/test__field.py::ASCIITests::test__validate_non_empty_hit src/zope/schema/tests/test__field.py::ASCIITests::test__validate_non_empty_miss src/zope/schema/tests/test__field.py::ASCIITests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::ASCIITests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::ASCIITests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::ASCIITests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::ASCIITests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::ASCIITests::test_is_hashable src/zope/schema/tests/test__field.py::BytesLineTests::test___eq___different_type src/zope/schema/tests/test__field.py::BytesLineTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::BytesLineTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::BytesLineTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::BytesLineTests::test_constraint src/zope/schema/tests/test__field.py::BytesLineTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::BytesLineTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::BytesLineTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::BytesLineTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::BytesLineTests::test_is_hashable src/zope/schema/tests/test__field.py::BytesLineTests::test_validate_not_required src/zope/schema/tests/test__field.py::BytesLineTests::test_validate_required src/zope/schema/tests/test__field.py::ASCIILineTests::test___eq___different_type src/zope/schema/tests/test__field.py::ASCIILineTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::ASCIILineTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::ASCIILineTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::ASCIILineTests::test_constraint src/zope/schema/tests/test__field.py::ASCIILineTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::ASCIILineTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::ASCIILineTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::ASCIILineTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::ASCIILineTests::test_is_hashable src/zope/schema/tests/test__field.py::ASCIILineTests::test_validate_not_required src/zope/schema/tests/test__field.py::ASCIILineTests::test_validate_required src/zope/schema/tests/test__field.py::FloatTests::test___eq___different_type src/zope/schema/tests/test__field.py::FloatTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::FloatTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::FloatTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::FloatTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::FloatTests::test_fromUnicode_hit src/zope/schema/tests/test__field.py::FloatTests::test_fromUnicode_miss src/zope/schema/tests/test__field.py::FloatTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::FloatTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::FloatTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::FloatTests::test_is_hashable src/zope/schema/tests/test__field.py::FloatTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__field.py::FloatTests::test_validate_not_required src/zope/schema/tests/test__field.py::FloatTests::test_validate_required src/zope/schema/tests/test__field.py::DecimalTests::test___eq___different_type src/zope/schema/tests/test__field.py::DecimalTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::DecimalTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::DecimalTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::DecimalTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::DecimalTests::test_fromUnicode_hit src/zope/schema/tests/test__field.py::DecimalTests::test_fromUnicode_miss src/zope/schema/tests/test__field.py::DecimalTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::DecimalTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::DecimalTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::DecimalTests::test_is_hashable src/zope/schema/tests/test__field.py::DecimalTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__field.py::DecimalTests::test_validate_not_required src/zope/schema/tests/test__field.py::DecimalTests::test_validate_required src/zope/schema/tests/test__field.py::DatetimeTests::test___eq___different_type src/zope/schema/tests/test__field.py::DatetimeTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::DatetimeTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::DatetimeTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::DatetimeTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::DatetimeTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::DatetimeTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::DatetimeTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::DatetimeTests::test_is_hashable src/zope/schema/tests/test__field.py::DatetimeTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__field.py::DatetimeTests::test_validate_not_required src/zope/schema/tests/test__field.py::DatetimeTests::test_validate_required src/zope/schema/tests/test__field.py::DateTests::test___eq___different_type src/zope/schema/tests/test__field.py::DateTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::DateTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::DateTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::DateTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::DateTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::DateTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::DateTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::DateTests::test_is_hashable src/zope/schema/tests/test__field.py::DateTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__field.py::DateTests::test_validate_not_required src/zope/schema/tests/test__field.py::DateTests::test_validate_required src/zope/schema/tests/test__field.py::TimedeltaTests::test___eq___different_type src/zope/schema/tests/test__field.py::TimedeltaTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::TimedeltaTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::TimedeltaTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::TimedeltaTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::TimedeltaTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::TimedeltaTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::TimedeltaTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::TimedeltaTests::test_is_hashable src/zope/schema/tests/test__field.py::TimedeltaTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__field.py::TimedeltaTests::test_validate_not_required src/zope/schema/tests/test__field.py::TimedeltaTests::test_validate_required src/zope/schema/tests/test__field.py::TimeTests::test___eq___different_type src/zope/schema/tests/test__field.py::TimeTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::TimeTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::TimeTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::TimeTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::TimeTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::TimeTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::TimeTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::TimeTests::test_is_hashable src/zope/schema/tests/test__field.py::TimeTests::test_missing_value_no_min_or_max src/zope/schema/tests/test__field.py::TimeTests::test_validate_not_required src/zope/schema/tests/test__field.py::TimeTests::test_validate_required src/zope/schema/tests/test__field.py::ChoiceTests::test___eq___different_type src/zope/schema/tests/test__field.py::ChoiceTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::ChoiceTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_int src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_mixed src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_source_is_ICSB_bound src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_source_is_ICSB_unbound src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_string src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_tuple src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_w_named_vocabulary src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_w_named_vocabulary_invalid src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_w_named_vocabulary_passes_context src/zope/schema/tests/test__field.py::ChoiceTests::test__validate_w_named_vocabulary_raises_LookupError src/zope/schema/tests/test__field.py::ChoiceTests::test_bind_w_preconstructed_vocabulary src/zope/schema/tests/test__field.py::ChoiceTests::test_bind_w_voc_is_ICSB src/zope/schema/tests/test__field.py::ChoiceTests::test_bind_w_voc_is_ICSB_but_not_ISource src/zope/schema/tests/test__field.py::ChoiceTests::test_bind_w_voc_not_ICSB src/zope/schema/tests/test__field.py::ChoiceTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_both_vocabulary_and_source src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_both_vocabulary_and_values src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_invalid_source src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_invalid_vocabulary src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_w_named_vocabulary src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_w_preconstructed_vocabulary src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_w_unicode_non_ascii_values src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_w_values src/zope/schema/tests/test__field.py::ChoiceTests::test_ctor_wo_values_vocabulary_or_source src/zope/schema/tests/test__field.py::ChoiceTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::ChoiceTests::test_fromUnicode_hit src/zope/schema/tests/test__field.py::ChoiceTests::test_fromUnicode_miss src/zope/schema/tests/test__field.py::ChoiceTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::ChoiceTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::ChoiceTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::ChoiceTests::test_is_hashable src/zope/schema/tests/test__field.py::URITests::test___eq___different_type src/zope/schema/tests/test__field.py::URITests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::URITests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::URITests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::URITests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::URITests::test_fromUnicode_invalid src/zope/schema/tests/test__field.py::URITests::test_fromUnicode_ok src/zope/schema/tests/test__field.py::URITests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::URITests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::URITests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::URITests::test_is_hashable src/zope/schema/tests/test__field.py::URITests::test_validate_not_a_uri src/zope/schema/tests/test__field.py::URITests::test_validate_not_required src/zope/schema/tests/test__field.py::URITests::test_validate_required src/zope/schema/tests/test__field.py::DottedNameTests::test___eq___different_type src/zope/schema/tests/test__field.py::DottedNameTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::DottedNameTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::DottedNameTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::DottedNameTests::test_ctor_defaults src/zope/schema/tests/test__field.py::DottedNameTests::test_ctor_max_dots_invalid src/zope/schema/tests/test__field.py::DottedNameTests::test_ctor_max_dots_valid src/zope/schema/tests/test__field.py::DottedNameTests::test_ctor_min_dots_invalid src/zope/schema/tests/test__field.py::DottedNameTests::test_ctor_min_dots_valid src/zope/schema/tests/test__field.py::DottedNameTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::DottedNameTests::test_fromUnicode_dotted_name_ok src/zope/schema/tests/test__field.py::DottedNameTests::test_fromUnicode_invalid src/zope/schema/tests/test__field.py::DottedNameTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::DottedNameTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::DottedNameTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::DottedNameTests::test_is_hashable src/zope/schema/tests/test__field.py::DottedNameTests::test_validate_not_a_dotted_name src/zope/schema/tests/test__field.py::DottedNameTests::test_validate_not_required src/zope/schema/tests/test__field.py::DottedNameTests::test_validate_required src/zope/schema/tests/test__field.py::DottedNameTests::test_validate_w_max_dots src/zope/schema/tests/test__field.py::DottedNameTests::test_validate_w_min_dots src/zope/schema/tests/test__field.py::IdTests::test___eq___different_type src/zope/schema/tests/test__field.py::IdTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::IdTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::IdTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::IdTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::IdTests::test_fromUnicode_dotted_name_ok src/zope/schema/tests/test__field.py::IdTests::test_fromUnicode_invalid src/zope/schema/tests/test__field.py::IdTests::test_fromUnicode_url_ok src/zope/schema/tests/test__field.py::IdTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::IdTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::IdTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::IdTests::test_is_hashable src/zope/schema/tests/test__field.py::IdTests::test_validate_not_a_uri src/zope/schema/tests/test__field.py::IdTests::test_validate_not_required src/zope/schema/tests/test__field.py::IdTests::test_validate_required src/zope/schema/tests/test__field.py::InterfaceFieldTests::test___eq___different_type src/zope/schema/tests/test__field.py::InterfaceFieldTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::InterfaceFieldTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_is_hashable src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_validate_not_required src/zope/schema/tests/test__field.py::InterfaceFieldTests::test_validate_required src/zope/schema/tests/test__field.py::CollectionTests::test___eq___different_type src/zope/schema/tests/test__field.py::CollectionTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::CollectionTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::CollectionTests::test__validate_miss_uniqueness src/zope/schema/tests/test__field.py::CollectionTests::test_bind_w_value_Type src/zope/schema/tests/test__field.py::CollectionTests::test_bind_wo_value_Type src/zope/schema/tests/test__field.py::CollectionTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::CollectionTests::test_ctor_defaults src/zope/schema/tests/test__field.py::CollectionTests::test_ctor_explicit src/zope/schema/tests/test__field.py::CollectionTests::test_ctor_w_non_field_value_type src/zope/schema/tests/test__field.py::CollectionTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::CollectionTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::CollectionTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::CollectionTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::CollectionTests::test_is_hashable src/zope/schema/tests/test__field.py::CollectionTests::test_validate_not_required src/zope/schema/tests/test__field.py::CollectionTests::test_validate_required src/zope/schema/tests/test__field.py::SequenceTests::test___eq___different_type src/zope/schema/tests/test__field.py::SequenceTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::SequenceTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::SequenceTests::test__validate_miss_uniqueness src/zope/schema/tests/test__field.py::SequenceTests::test_bind_w_value_Type src/zope/schema/tests/test__field.py::SequenceTests::test_bind_wo_value_Type src/zope/schema/tests/test__field.py::SequenceTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::SequenceTests::test_ctor_defaults src/zope/schema/tests/test__field.py::SequenceTests::test_ctor_explicit src/zope/schema/tests/test__field.py::SequenceTests::test_ctor_w_non_field_value_type src/zope/schema/tests/test__field.py::SequenceTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::SequenceTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::SequenceTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::SequenceTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::SequenceTests::test_is_hashable src/zope/schema/tests/test__field.py::SequenceTests::test_mutable_sequence src/zope/schema/tests/test__field.py::SequenceTests::test_sequence src/zope/schema/tests/test__field.py::SequenceTests::test_validate_not_required src/zope/schema/tests/test__field.py::SequenceTests::test_validate_required src/zope/schema/tests/test__field.py::TupleTests::test___eq___different_type src/zope/schema/tests/test__field.py::TupleTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::TupleTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::TupleTests::test__validate_miss_uniqueness src/zope/schema/tests/test__field.py::TupleTests::test_bind_w_value_Type src/zope/schema/tests/test__field.py::TupleTests::test_bind_wo_value_Type src/zope/schema/tests/test__field.py::TupleTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::TupleTests::test_ctor_defaults src/zope/schema/tests/test__field.py::TupleTests::test_ctor_explicit src/zope/schema/tests/test__field.py::TupleTests::test_ctor_w_non_field_value_type src/zope/schema/tests/test__field.py::TupleTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::TupleTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::TupleTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::TupleTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::TupleTests::test_is_hashable src/zope/schema/tests/test__field.py::TupleTests::test_mutable_sequence src/zope/schema/tests/test__field.py::TupleTests::test_sequence src/zope/schema/tests/test__field.py::TupleTests::test_validate_not_required src/zope/schema/tests/test__field.py::TupleTests::test_validate_required src/zope/schema/tests/test__field.py::MutableSequenceTests::test___eq___different_type src/zope/schema/tests/test__field.py::MutableSequenceTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::MutableSequenceTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::MutableSequenceTests::test__validate_miss_uniqueness src/zope/schema/tests/test__field.py::MutableSequenceTests::test_bind_w_value_Type src/zope/schema/tests/test__field.py::MutableSequenceTests::test_bind_wo_value_Type src/zope/schema/tests/test__field.py::MutableSequenceTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::MutableSequenceTests::test_ctor_defaults src/zope/schema/tests/test__field.py::MutableSequenceTests::test_ctor_explicit src/zope/schema/tests/test__field.py::MutableSequenceTests::test_ctor_w_non_field_value_type src/zope/schema/tests/test__field.py::MutableSequenceTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::MutableSequenceTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::MutableSequenceTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::MutableSequenceTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::MutableSequenceTests::test_is_hashable src/zope/schema/tests/test__field.py::MutableSequenceTests::test_mutable_sequence src/zope/schema/tests/test__field.py::MutableSequenceTests::test_sequence src/zope/schema/tests/test__field.py::MutableSequenceTests::test_validate_not_required src/zope/schema/tests/test__field.py::MutableSequenceTests::test_validate_required src/zope/schema/tests/test__field.py::ListTests::test___eq___different_type src/zope/schema/tests/test__field.py::ListTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::ListTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::ListTests::test__validate_miss_uniqueness src/zope/schema/tests/test__field.py::ListTests::test_bind_w_value_Type src/zope/schema/tests/test__field.py::ListTests::test_bind_wo_value_Type src/zope/schema/tests/test__field.py::ListTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::ListTests::test_ctor_defaults src/zope/schema/tests/test__field.py::ListTests::test_ctor_explicit src/zope/schema/tests/test__field.py::ListTests::test_ctor_w_non_field_value_type src/zope/schema/tests/test__field.py::ListTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::ListTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::ListTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::ListTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::ListTests::test_is_hashable src/zope/schema/tests/test__field.py::ListTests::test_mutable_sequence src/zope/schema/tests/test__field.py::ListTests::test_sequence src/zope/schema/tests/test__field.py::ListTests::test_validate_not_required src/zope/schema/tests/test__field.py::ListTests::test_validate_required src/zope/schema/tests/test__field.py::SetTests::test___eq___different_type src/zope/schema/tests/test__field.py::SetTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::SetTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::SetTests::test__validate_miss_uniqueness src/zope/schema/tests/test__field.py::SetTests::test_bind_w_value_Type src/zope/schema/tests/test__field.py::SetTests::test_bind_wo_value_Type src/zope/schema/tests/test__field.py::SetTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::SetTests::test_ctor_defaults src/zope/schema/tests/test__field.py::SetTests::test_ctor_disallows_unique src/zope/schema/tests/test__field.py::SetTests::test_ctor_explicit src/zope/schema/tests/test__field.py::SetTests::test_ctor_w_non_field_value_type src/zope/schema/tests/test__field.py::SetTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::SetTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::SetTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::SetTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::SetTests::test_is_hashable src/zope/schema/tests/test__field.py::SetTests::test_validate_not_required src/zope/schema/tests/test__field.py::SetTests::test_validate_required src/zope/schema/tests/test__field.py::FrozenSetTests::test___eq___different_type src/zope/schema/tests/test__field.py::FrozenSetTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::FrozenSetTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::FrozenSetTests::test__validate_miss_uniqueness src/zope/schema/tests/test__field.py::FrozenSetTests::test_bind_w_value_Type src/zope/schema/tests/test__field.py::FrozenSetTests::test_bind_wo_value_Type src/zope/schema/tests/test__field.py::FrozenSetTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::FrozenSetTests::test_ctor_defaults src/zope/schema/tests/test__field.py::FrozenSetTests::test_ctor_disallows_unique src/zope/schema/tests/test__field.py::FrozenSetTests::test_ctor_explicit src/zope/schema/tests/test__field.py::FrozenSetTests::test_ctor_w_non_field_value_type src/zope/schema/tests/test__field.py::FrozenSetTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::FrozenSetTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::FrozenSetTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::FrozenSetTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::FrozenSetTests::test_is_hashable src/zope/schema/tests/test__field.py::FrozenSetTests::test_validate_not_required src/zope/schema/tests/test__field.py::FrozenSetTests::test_validate_required src/zope/schema/tests/test__field.py::MappingTests::test___eq___different_type src/zope/schema/tests/test__field.py::MappingTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::MappingTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::MappingTests::test_bind_binds_key_and_value_types src/zope/schema/tests/test__field.py::MappingTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::MappingTests::test_ctor_key_type_not_IField src/zope/schema/tests/test__field.py::MappingTests::test_ctor_value_type_not_IField src/zope/schema/tests/test__field.py::MappingTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::MappingTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::MappingTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::MappingTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::MappingTests::test_is_hashable src/zope/schema/tests/test__field.py::MappingTests::test_mapping src/zope/schema/tests/test__field.py::MappingTests::test_mutable_mapping src/zope/schema/tests/test__field.py::MappingTests::test_validate_not_required src/zope/schema/tests/test__field.py::MappingTests::test_validate_required src/zope/schema/tests/test__field.py::MutableMappingTests::test___eq___different_type src/zope/schema/tests/test__field.py::MutableMappingTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::MutableMappingTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::MutableMappingTests::test_bind_binds_key_and_value_types src/zope/schema/tests/test__field.py::MutableMappingTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::MutableMappingTests::test_ctor_key_type_not_IField src/zope/schema/tests/test__field.py::MutableMappingTests::test_ctor_value_type_not_IField src/zope/schema/tests/test__field.py::MutableMappingTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::MutableMappingTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::MutableMappingTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::MutableMappingTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::MutableMappingTests::test_is_hashable src/zope/schema/tests/test__field.py::MutableMappingTests::test_mapping src/zope/schema/tests/test__field.py::MutableMappingTests::test_mutable_mapping src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_not_required src/zope/schema/tests/test__field.py::MutableMappingTests::test_validate_required src/zope/schema/tests/test__field.py::DictTests::test___eq___different_type src/zope/schema/tests/test__field.py::DictTests::test___eq___same_type_different_attrs src/zope/schema/tests/test__field.py::DictTests::test___eq___same_type_same_attrs src/zope/schema/tests/test__field.py::DictTests::test_bind_binds_key_and_value_types src/zope/schema/tests/test__field.py::DictTests::test_class_conforms_to_iface src/zope/schema/tests/test__field.py::DictTests::test_ctor_key_type_not_IField src/zope/schema/tests/test__field.py::DictTests::test_ctor_value_type_not_IField src/zope/schema/tests/test__field.py::DictTests::test_equal_instances_have_same_hash src/zope/schema/tests/test__field.py::DictTests::test_hash_across_unequal_instances src/zope/schema/tests/test__field.py::DictTests::test_instance_conforms_to_iface src/zope/schema/tests/test__field.py::DictTests::test_instances_in_different_interfaces_not_equal src/zope/schema/tests/test__field.py::DictTests::test_is_hashable src/zope/schema/tests/test__field.py::DictTests::test_mapping src/zope/schema/tests/test__field.py::DictTests::test_mutable_mapping src/zope/schema/tests/test__field.py::DictTests::test_validate_not_required src/zope/schema/tests/test__field.py::DictTests::test_validate_required src/zope/schema/tests/test__field.py::test_suite
src/zope/schema/_field.py src/zope/schema/_bootstrapfields.py src/zope/schema/_bootstrapinterfaces.py .gitignore CHANGES.rst docs/api.rst src/zope/schema/interfaces.py
src/zope/schema/_field.py src/zope/schema/_bootstrapfields.py src/zope/schema/_bootstrapinterfaces.py .gitignore CHANGES.rst docs/api.rst src/zope/schema/interfaces.py