Remove the u/b BWC functions.remove-u

15 files changed, 396 insertions, 424 deletions

diff --git a/docs/fields.rst b/docs/fields.rst
index 2048b2d..118d8c4 100644
--- a/docs/fields.rst
+++ b/docs/fields.rst
@@ -28,13 +28,11 @@ Conversion from Unicode:
 
 .. doctest::
 
-   >>> from zope.schema._compat import b
-   >>> from zope.schema._compat import u
    >>> from zope.schema import Bytes
-   >>> obj = Bytes(constraint=lambda v: b('x') in v)
-   >>> obj.fromUnicode(u(" foo x.y.z bat"))
+   >>> obj = Bytes(constraint=lambda v: b'x' in v)
+   >>> obj.fromUnicode(u" foo x.y.z bat")
    ' foo x.y.z bat'
-   >>> obj.fromUnicode(u(" foo y.z bat"))
+   >>> obj.fromUnicode(u" foo y.z bat")
    Traceback (most recent call last):
    ...
    ConstraintNotSatisfied:  foo y.z bat
@@ -162,14 +160,14 @@ Conversion from Unicode enforces the constraint:
    >>> from zope.schema.vocabulary import SimpleVocabulary
    >>> from zope.schema import Choice
    >>> t = Choice(
-   ...     vocabulary=SimpleVocabulary.fromValues([u('foo'),u('bar')]))
+   ...     vocabulary=SimpleVocabulary.fromValues([u'foo',u'bar']))
    >>> IFromUnicode.providedBy(t)
    True
-   >>> t.fromUnicode(u("baz"))
+   >>> t.fromUnicode(u"baz")
    Traceback (most recent call last):
    ...
    ConstraintNotSatisfied: baz
-   >>> t.fromUnicode(u("foo"))
+   >>> t.fromUnicode(u"foo")
    u'foo'
 
 By default, ValueErrors are thrown if duplicate values or tokens
@@ -191,9 +189,9 @@ Validation ensures that the pattern is matched:
 
    >>> from zope.schema import URI
    >>> uri = URI(__name__='test')
-   >>> uri.validate(b("http://www.python.org/foo/bar"))
-   >>> uri.validate(b("DAV:"))
-   >>> uri.validate(b("www.python.org/foo/bar"))
+   >>> uri.validate(b"http://www.python.org/foo/bar")
+   >>> uri.validate(b"DAV:")
+   >>> uri.validate(b"www.python.org/foo/bar")
    Traceback (most recent call last):
    ...
    InvalidURI: www.python.org/foo/bar
@@ -334,7 +332,7 @@ Conversion from Unicode:
    >>> id = Id(__name__='test')
    >>> id.fromUnicode("http://www.python.org/foo/bar")
    'http://www.python.org/foo/bar'
-   >>> id.fromUnicode(u(" http://www.python.org/foo/bar "))
+   >>> id.fromUnicode(u" http://www.python.org/foo/bar ")
    'http://www.python.org/foo/bar'
    >>> id.fromUnicode("http://www.python.org/ foo/bar")
    Traceback (most recent call last):
@@ -359,12 +357,11 @@ uniqueness. In a schema, this might be written as follows:
 
    >>> from zope.interface import Interface
    >>> from zope.schema import List, Float
-   >>> from zope.schema._compat import u
    >>> class IInventoryItem(Interface):
    ...     pricePoints = List(
-   ...         title=u("Price Points"),
+   ...         title=u"Price Points",
    ...         unique=True,
-   ...         value_type=Float(title=u("Price"), min=0.0)
+   ...         value_type=Float(title=u"Price", min=0.0)
    ...     )
 
 This indicates several things.
diff --git a/docs/narr.rst b/docs/narr.rst
index 63ac1d4..7a7125b 100644
--- a/docs/narr.rst
+++ b/docs/narr.rst
@@ -36,17 +36,16 @@ instances, we now use schema fields:
 
    >>> import zope.interface
    >>> import zope.schema
-   >>> from zope.schema._compat import u, b
 
    >>> class IBookmark(zope.interface.Interface):
    ...     title = zope.schema.TextLine(
-   ...         title=u('Title'),
-   ...         description=u('The title of the bookmark'),
+   ...         title=u'Title',
+   ...         description=u'The title of the bookmark',
    ...         required=True)
    ...
    ...     url = zope.schema.URI(
-   ...         title=u('Bookmark URL'),
-   ...         description=u('URL of the Bookmark'),
+   ...         title=u'Bookmark URL',
+   ...         description=u'URL of the Bookmark',
    ...         required=True)
    ...
 
@@ -69,8 +68,8 @@ is to define some data:
 
 .. doctest::
 
-   >>> title = u('Zope 3 Website')
-   >>> url = b('http://dev.zope.org/Zope3')
+   >>> title = u'Zope 3 Website'
+   >>> url = b'http://dev.zope.org/Zope3'
 
 Now we, get the fields from the interface:
 
@@ -147,16 +146,16 @@ down example from the programmer's tutorial:
    >>> class IContact(zope.interface.Interface):
    ...     """Provides access to basic contact information."""
    ...
-   ...     first = zope.schema.TextLine(title=u("First name"))
+   ...     first = zope.schema.TextLine(title=u"First name")
    ...
-   ...     last = zope.schema.TextLine(title=u("Last name"))
+   ...     last = zope.schema.TextLine(title=u"Last name")
    ...
-   ...     email = zope.schema.TextLine(title=u("Electronic mail address"))
+   ...     email = zope.schema.TextLine(title=u"Electronic mail address")
    ...
-   ...     address = zope.schema.Text(title=u("Postal address"))
+   ...     address = zope.schema.Text(title=u"Postal address")
    ...
    ...     postalCode = zope.schema.TextLine(
-   ...         title=u("Postal code"),
+   ...         title=u"Postal code",
    ...         constraint=re.compile("\d{5,5}(-\d{4,4})?$").match)
 
 ``TextLine`` is a field and expresses that an attribute is a single line
@@ -184,8 +183,8 @@ schema:
 
 .. doctest::
 
-   >>> someone = Contact(u('Tim'), u('Roberts'), u('tim@roberts'), u(''),
-   ...                   u('12032-3492'))
+   >>> someone = Contact(u'Tim', u'Roberts', u'tim@roberts', u'',
+   ...                   u'12032-3492')
 
    >>> for field in zope.schema.getFields(IContact).values():
    ...     bound = field.bind(someone)
diff --git a/src/zope/schema/_bootstrapfields.py b/src/zope/schema/_bootstrapfields.py
index 5de0e21..b099739 100644
--- a/src/zope/schema/_bootstrapfields.py
+++ b/src/zope/schema/_bootstrapfields.py
@@ -31,7 +31,7 @@ from zope.schema._bootstrapinterfaces import TooLong
 from zope.schema._bootstrapinterfaces import TooShort
 from zope.schema._bootstrapinterfaces import TooSmall
 from zope.schema._bootstrapinterfaces import WrongType
-from zope.schema._compat import u
+
 from zope.schema._compat import text_type
 from zope.schema._compat import integer_types
 
@@ -110,7 +110,7 @@ class Field(Attribute):
     interface = None
     _Element__tagged_values = None
 
-    def __init__(self, title=u(''), description=u(''), __name__='',
+    def __init__(self, title=u'', description=u'', __name__='',
                  required=True, readonly=False, constraint=None, default=None,
                  defaultFactory=None, missing_value=__missing_value_marker):
         """Pass in field values as keyword parameters.
diff --git a/src/zope/schema/_compat.py b/src/zope/schema/_compat.py
index dc45ca9..8a52bfb 100644
--- a/src/zope/schema/_compat.py
+++ b/src/zope/schema/_compat.py
@@ -2,10 +2,7 @@ import sys
 
 PY3 = sys.version_info[0] >= 3
 
-try:
-    from collections import OrderedDict
-except ImportError:  # pragma: no cover
-    from ordereddict import OrderedDict
+from collections import OrderedDict
 
 # pep 8 friendlyness
 OrderedDict
@@ -13,12 +10,6 @@ OrderedDict
 
 if PY3:  # pragma: no cover
 
-    def b(s):
-        return s.encode("latin-1")
-
-    def u(s):
-        return s
-
     string_types = str,
     text_type = str
     binary_type = bytes
@@ -36,12 +27,6 @@ if PY3:  # pragma: no cover
 
 else:  # pragma: no cover
 
-    def b(s):
-        return s
-
-    def u(s):
-        return unicode(s, "unicode_escape")
-
     string_types = basestring,
     text_type = unicode
     binary_type = str
diff --git a/src/zope/schema/_field.py b/src/zope/schema/_field.py
index 75c8d43..b4e6db7 100644
--- a/src/zope/schema/_field.py
+++ b/src/zope/schema/_field.py
@@ -92,7 +92,7 @@ from zope.schema.vocabulary import getVocabularyRegistry
 from zope.schema.vocabulary import VocabularyRegistryError
 from zope.schema.vocabulary import SimpleVocabulary
 
-from zope.schema._compat import b
+
 from zope.schema._compat import text_type
 from zope.schema._compat import string_types
 from zope.schema._compat import binary_type
@@ -165,7 +165,7 @@ class BytesLine(Bytes):
 
     def constraint(self, value):
         # TODO: we should probably use a more general definition of newlines
-        return b('\n') not in value
+        return b'\n' not in value
 
 # for things which are of the str type on both Python 2 and 3
 if PY3:  # pragma: no cover
@@ -459,13 +459,11 @@ def _validate_sequence(value_type, value, errors=None):
 
     To illustrate, we'll use a text value type. All values must be unicode.
 
-       >>> from zope.schema._compat import u
-       >>> from zope.schema._compat import b
        >>> field = TextLine(required=True)
 
     To validate a sequence of various values:
 
-       >>> errors = _validate_sequence(field, (b('foo'), u('bar'), 1))
+       >>> errors = _validate_sequence(field, (b'foo', u'bar', 1))
        >>> errors # XXX assumes Python2 reprs
        [WrongType('foo', <type 'unicode'>, ''), WrongType(1, <type 'unicode'>, '')]
 
@@ -475,7 +473,7 @@ def _validate_sequence(value_type, value, errors=None):
     We can use the optional errors argument to collect additional errors
     for a new sequence:
 
-       >>> errors = _validate_sequence(field, (2, u('baz')), errors)
+       >>> errors = _validate_sequence(field, (2, u'baz'), errors)
        >>> errors # XXX assumes Python2 reprs
        [WrongType('foo', <type 'unicode'>, ''), WrongType(1, <type 'unicode'>, ''), WrongType(2, <type 'unicode'>, '')]
 
diff --git a/src/zope/schema/interfaces.py b/src/zope/schema/interfaces.py
index 2831229..f2b033f 100644
--- a/src/zope/schema/interfaces.py
+++ b/src/zope/schema/interfaces.py
@@ -42,7 +42,7 @@ from zope.schema._bootstrapinterfaces import InvalidValue
 from zope.schema._bootstrapinterfaces import IContextAwareDefaultFactory
 
 from zope.schema._compat import PY3
-from zope.schema._compat import u
+
 from zope.schema._messageid import _
 
 
@@ -125,14 +125,14 @@ class IField(Interface):
     title = TextLine(
         title=_("Title"),
         description=_("A short summary or label"),
-        default=u(""),
+        default=u"",
         required=False,
         )
 
     description = Text(
         title=_("Description"),
         description=_("A description of the field"),
-        default=u(""),
+        default=u"",
         required=False,
         )
 
diff --git a/src/zope/schema/tests/states.py b/src/zope/schema/tests/states.py
index 9c0c459..e3a6e8a 100644
--- a/src/zope/schema/tests/states.py
+++ b/src/zope/schema/tests/states.py
@@ -13,7 +13,7 @@
 ##############################################################################
 """Sample vocabulary supporting state abbreviations.
 """
-from zope.schema._compat import u
+
 from zope.interface import implementer
 from zope.schema import interfaces
 from zope.schema import Choice
@@ -21,66 +21,66 @@ from zope.schema import Choice
 # This table is based on information from the United States Postal Service:
 # http://www.usps.com/ncsc/lookups/abbreviations.html#states
 _states = {
-    'AL': u('Alabama'),
-    'AK': u('Alaska'),
-    'AS': u('American Samoa'),
-    'AZ': u('Arizona'),
-    'AR': u('Arkansas'),
-    'CA': u('California'),
-    'CO': u('Colorado'),
-    'CT': u('Connecticut'),
-    'DE': u('Delaware'),
-    'DC': u('District of Columbia'),
-    'FM': u('Federated States of Micronesia'),
-    'FL': u('Florida'),
-    'GA': u('Georgia'),
-    'GU': u('Guam'),
-    'HI': u('Hawaii'),
-    'ID': u('Idaho'),
-    'IL': u('Illinois'),
-    'IN': u('Indiana'),
-    'IA': u('Iowa'),
-    'KS': u('Kansas'),
-    'KY': u('Kentucky'),
-    'LA': u('Louisiana'),
-    'ME': u('Maine'),
-    'MH': u('Marshall Islands'),
-    'MD': u('Maryland'),
-    'MA': u('Massachusetts'),
-    'MI': u('Michigan'),
-    'MN': u('Minnesota'),
-    'MS': u('Mississippi'),
-    'MO': u('Missouri'),
-    'MT': u('Montana'),
-    'NE': u('Nebraska'),
-    'NV': u('Nevada'),
-    'NH': u('New Hampshire'),
-    'NJ': u('New Jersey'),
-    'NM': u('New Mexico'),
-    'NY': u('New York'),
-    'NC': u('North Carolina'),
-    'ND': u('North Dakota'),
-    'MP': u('Northern Mariana Islands'),
-    'OH': u('Ohio'),
-    'OK': u('Oklahoma'),
-    'OR': u('Oregon'),
-    'PW': u('Palau'),
-    'PA': u('Pennsylvania'),
-    'PR': u('Puerto Rico'),
-    'RI': u('Rhode Island'),
-    'SC': u('South Carolina'),
-    'SD': u('South Dakota'),
-    'TN': u('Tennessee'),
-    'TX': u('Texas'),
-    'UT': u('Utah'),
-    'VT': u('Vermont'),
-    'VI': u('Virgin Islands'),
-    'VA': u('Virginia'),
-    'WA': u('Washington'),
-    'WV': u('West Virginia'),
-    'WI': u('Wisconsin'),
-    'WY': u('Wyoming'),
-    }
+    'AL': u'Alabama',
+    'AK': u'Alaska',
+    'AS': u'American Samoa',
+    'AZ': u'Arizona',
+    'AR': u'Arkansas',
+    'CA': u'California',
+    'CO': u'Colorado',
+    'CT': u'Connecticut',
+    'DE': u'Delaware',
+    'DC': u'District of Columbia',
+    'FM': u'Federated States of Micronesia',
+    'FL': u'Florida',
+    'GA': u'Georgia',
+    'GU': u'Guam',
+    'HI': u'Hawaii',
+    'ID': u'Idaho',
+    'IL': u'Illinois',
+    'IN': u'Indiana',
+    'IA': u'Iowa',
+    'KS': u'Kansas',
+    'KY': u'Kentucky',
+    'LA': u'Louisiana',
+    'ME': u'Maine',
+    'MH': u'Marshall Islands',
+    'MD': u'Maryland',
+    'MA': u'Massachusetts',
+    'MI': u'Michigan',
+    'MN': u'Minnesota',
+    'MS': u'Mississippi',
+    'MO': u'Missouri',
+    'MT': u'Montana',
+    'NE': u'Nebraska',
+    'NV': u'Nevada',
+    'NH': u'New Hampshire',
+    'NJ': u'New Jersey',
+    'NM': u'New Mexico',
+    'NY': u'New York',
+    'NC': u'North Carolina',
+    'ND': u'North Dakota',
+    'MP': u'Northern Mariana Islands',
+    'OH': u'Ohio',
+    'OK': u'Oklahoma',
+    'OR': u'Oregon',
+    'PW': u'Palau',
+    'PA': u'Pennsylvania',
+    'PR': u'Puerto Rico',
+    'RI': u'Rhode Island',
+    'SC': u'South Carolina',
+    'SD': u'South Dakota',
+    'TN': u'Tennessee',
+    'TX': u'Texas',
+    'UT': u'Utah',
+    'VT': u'Vermont',
+    'VI': u'Virgin Islands',
+    'VA': u'Virginia',
+    'WA': u'Washington',
+    'WV': u'West Virginia',
+    'WI': u'Wisconsin',
+    'WY': u'Wyoming',
+}
 
 
 @implementer(interfaces.ITerm)
diff --git a/src/zope/schema/tests/test__bootstrapfields.py b/src/zope/schema/tests/test__bootstrapfields.py
index 61c7646..42addbe 100644
--- a/src/zope/schema/tests/test__bootstrapfields.py
+++ b/src/zope/schema/tests/test__bootstrapfields.py
@@ -152,12 +152,12 @@ class FieldTests(unittest.TestCase):
         return self._getTargetClass()(*args, **kw)
 
     def test_ctor_defaults(self):
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertEqual(field.__name__, u(''))
-        self.assertEqual(field.__doc__, u(''))
-        self.assertEqual(field.title, u(''))
-        self.assertEqual(field.description, u(''))
+        self.assertEqual(field.__name__, u'')
+        self.assertEqual(field.__doc__, u'')
+        self.assertEqual(field.title, u'')
+        self.assertEqual(field.description, u'')
         self.assertEqual(field.required, True)
         self.assertEqual(field.readonly, False)
         self.assertEqual(field.constraint(object()), True)
@@ -167,28 +167,28 @@ class FieldTests(unittest.TestCase):
         self.assertEqual(field.context, None)
 
     def test_ctor_w_title_wo_description(self):
-        from zope.schema._compat import u
-        field = self._makeOne(u('TITLE'))
-        self.assertEqual(field.__name__, u(''))
-        self.assertEqual(field.__doc__, u('TITLE'))
-        self.assertEqual(field.title, u('TITLE'))
-        self.assertEqual(field.description, u(''))
+
+        field = self._makeOne(u'TITLE')
+        self.assertEqual(field.__name__, u'')
+        self.assertEqual(field.__doc__, u'TITLE')
+        self.assertEqual(field.title, u'TITLE')
+        self.assertEqual(field.description, u'')
 
     def test_ctor_wo_title_w_description(self):
-        from zope.schema._compat import u
-        field = self._makeOne(description=u('DESC'))
-        self.assertEqual(field.__name__, u(''))
-        self.assertEqual(field.__doc__, u('DESC'))
-        self.assertEqual(field.title, u(''))
-        self.assertEqual(field.description, u('DESC'))
+
+        field = self._makeOne(description=u'DESC')
+        self.assertEqual(field.__name__, u'')
+        self.assertEqual(field.__doc__, u'DESC')
+        self.assertEqual(field.title, u'')
+        self.assertEqual(field.description, u'DESC')
 
     def test_ctor_w_both_title_and_description(self):
-        from zope.schema._compat import u
-        field = self._makeOne(u('TITLE'), u('DESC'), u('NAME'))
-        self.assertEqual(field.__name__, u('NAME'))
-        self.assertEqual(field.__doc__, u('TITLE\n\nDESC'))
-        self.assertEqual(field.title, u('TITLE'))
-        self.assertEqual(field.description, u('DESC'))
+
+        field = self._makeOne(u'TITLE', u'DESC', u'NAME')
+        self.assertEqual(field.__name__, u'NAME')
+        self.assertEqual(field.__doc__, u'TITLE\n\nDESC')
+        self.assertEqual(field.title, u'TITLE')
+        self.assertEqual(field.description, u'DESC')
 
     def test_ctor_order_madness(self):
         klass = self._getTargetClass()
@@ -513,9 +513,9 @@ class TextTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import b
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, b(''))
+        self.assertRaises(WrongType, field.validate, b'')
         self.assertRaises(WrongType, field.validate, 1)
         self.assertRaises(WrongType, field.validate, 1.0)
         self.assertRaises(WrongType, field.validate, ())
@@ -526,37 +526,37 @@ class TextTests(unittest.TestCase):
         self.assertRaises(WrongType, field.validate, object())
 
     def test_validate_w_invalid_default(self):
-        from zope.schema._compat import b
+
         from zope.schema.interfaces import ValidationError
-        self.assertRaises(ValidationError, self._makeOne, default=b(''))
+        self.assertRaises(ValidationError, self._makeOne, default=b'')
 
     def test_validate_not_required(self):
-        from zope.schema._compat import u
+
         field = self._makeOne(required=False)
-        field.validate(u(''))
-        field.validate(u('abc'))
-        field.validate(u('abc\ndef'))
+        field.validate(u'')
+        field.validate(u'abc')
+        field.validate(u'abc\ndef')
         field.validate(None)
 
     def test_validate_required(self):
         from zope.schema.interfaces import RequiredMissing
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        field.validate(u(''))
-        field.validate(u('abc'))
-        field.validate(u('abc\ndef'))
+        field.validate(u'')
+        field.validate(u'abc')
+        field.validate(u'abc\ndef')
         self.assertRaises(RequiredMissing, field.validate, None)
 
     def test_fromUnicode_miss(self):
         from zope.schema._bootstrapinterfaces import WrongType
-        from zope.schema._compat import b
-        deadbeef = b('DEADBEEF')
+
+        deadbeef = b'DEADBEEF'
         txt = self._makeOne()
         self.assertRaises(WrongType, txt.fromUnicode, deadbeef)
 
     def test_fromUnicode_hit(self):
-        from zope.schema._compat import u
-        deadbeef = u('DEADBEEF')
+
+        deadbeef = u'DEADBEEF'
         txt = self._makeOne()
         self.assertEqual(txt.fromUnicode(deadbeef), deadbeef)
 
@@ -582,9 +582,9 @@ class TextLineTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import b
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, b(''))
+        self.assertRaises(WrongType, field.validate, b'')
         self.assertRaises(WrongType, field.validate, 1)
         self.assertRaises(WrongType, field.validate, 1.0)
         self.assertRaises(WrongType, field.validate, ())
@@ -595,26 +595,26 @@ class TextLineTests(unittest.TestCase):
         self.assertRaises(WrongType, field.validate, object())
 
     def test_validate_not_required(self):
-        from zope.schema._compat import u
+
         field = self._makeOne(required=False)
-        field.validate(u(''))
-        field.validate(u('abc'))
+        field.validate(u'')
+        field.validate(u'abc')
         field.validate(None)
 
     def test_validate_required(self):
         from zope.schema.interfaces import RequiredMissing
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        field.validate(u(''))
-        field.validate(u('abc'))
+        field.validate(u'')
+        field.validate(u'abc')
         self.assertRaises(RequiredMissing, field.validate, None)
 
     def test_constraint(self):
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertEqual(field.constraint(u('')), True)
-        self.assertEqual(field.constraint(u('abc')), True)
-        self.assertEqual(field.constraint(u('abc\ndef')), False)
+        self.assertEqual(field.constraint(u''), True)
+        self.assertEqual(field.constraint(u'abc'), True)
+        self.assertEqual(field.constraint(u'abc\ndef'), False)
 
 
 class PasswordTests(unittest.TestCase):
@@ -642,18 +642,18 @@ class PasswordTests(unittest.TestCase):
         self.assertEqual(inst.password, 'PASSWORD')
 
     def test_validate_not_required(self):
-        from zope.schema._compat import u
+
         field = self._makeOne(required=False)
-        field.validate(u(''))
-        field.validate(u('abc'))
+        field.validate(u'')
+        field.validate(u'abc')
         field.validate(None)
 
     def test_validate_required(self):
         from zope.schema.interfaces import RequiredMissing
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        field.validate(u(''))
-        field.validate(u('abc'))
+        field.validate(u'')
+        field.validate(u'abc')
         self.assertRaises(RequiredMissing, field.validate, None)
 
     def test_validate_unchanged_not_already_set(self):
@@ -672,11 +672,11 @@ class PasswordTests(unittest.TestCase):
         pw.validate(klass.UNCHANGED_PASSWORD)  # doesn't raise
 
     def test_constraint(self):
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertEqual(field.constraint(u('')), True)
-        self.assertEqual(field.constraint(u('abc')), True)
-        self.assertEqual(field.constraint(u('abc\ndef')), False)
+        self.assertEqual(field.constraint(u''), True)
+        self.assertEqual(field.constraint(u'abc'), True)
+        self.assertEqual(field.constraint(u'abc\ndef'), False)
 
 
 class BoolTests(unittest.TestCase):
@@ -706,19 +706,19 @@ class BoolTests(unittest.TestCase):
         self.assertEqual(inst.boo, True)
 
     def test_fromUnicode_miss(self):
-        from zope.schema._compat import u
+
         txt = self._makeOne()
-        self.assertEqual(txt.fromUnicode(u('')), False)
-        self.assertEqual(txt.fromUnicode(u('0')), False)
-        self.assertEqual(txt.fromUnicode(u('1')), False)
-        self.assertEqual(txt.fromUnicode(u('False')), False)
-        self.assertEqual(txt.fromUnicode(u('false')), False)
+        self.assertEqual(txt.fromUnicode(u''), False)
+        self.assertEqual(txt.fromUnicode(u'0'), False)
+        self.assertEqual(txt.fromUnicode(u'1'), False)
+        self.assertEqual(txt.fromUnicode(u'False'), False)
+        self.assertEqual(txt.fromUnicode(u'false'), False)
 
     def test_fromUnicode_hit(self):
-        from zope.schema._compat import u
+
         txt = self._makeOne()
-        self.assertEqual(txt.fromUnicode(u('True')), True)
-        self.assertEqual(txt.fromUnicode(u('true')), True)
+        self.assertEqual(txt.fromUnicode(u'True'), True)
+        self.assertEqual(txt.fromUnicode(u'true'), True)
 
 
 class IntTests(unittest.TestCase):
@@ -780,18 +780,18 @@ class IntTests(unittest.TestCase):
         self.assertRaises(TooBig, field.validate, 20)
 
     def test_fromUnicode_miss(self):
-        from zope.schema._compat import u
+
         txt = self._makeOne()
-        self.assertRaises(ValueError, txt.fromUnicode, u(''))
-        self.assertRaises(ValueError, txt.fromUnicode, u('False'))
-        self.assertRaises(ValueError, txt.fromUnicode, u('True'))
+        self.assertRaises(ValueError, txt.fromUnicode, u'')
+        self.assertRaises(ValueError, txt.fromUnicode, u'False')
+        self.assertRaises(ValueError, txt.fromUnicode, u'True')
 
     def test_fromUnicode_hit(self):
-        from zope.schema._compat import u
+
         txt = self._makeOne()
-        self.assertEqual(txt.fromUnicode(u('0')), 0)
-        self.assertEqual(txt.fromUnicode(u('1')), 1)
-        self.assertEqual(txt.fromUnicode(u('-1')), -1)
+        self.assertEqual(txt.fromUnicode(u'0'), 0)
+        self.assertEqual(txt.fromUnicode(u'1'), 1)
+        self.assertEqual(txt.fromUnicode(u'-1'), -1)
 
 
 class DummyInst(object):
diff --git a/src/zope/schema/tests/test__field.py b/src/zope/schema/tests/test__field.py
index 5a0ccdd..8c89583 100644
--- a/src/zope/schema/tests/test__field.py
+++ b/src/zope/schema/tests/test__field.py
@@ -35,9 +35,9 @@ class BytesTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
+
         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, ())
@@ -48,38 +48,40 @@ class BytesTests(unittest.TestCase):
         self.assertRaises(WrongType, field.validate, object())
 
     def test_validate_w_invalid_default(self):
-        from zope.schema._compat import u
+
         from zope.schema.interfaces import ValidationError
-        self.assertRaises(ValidationError, self._makeOne, default=u(''))
+        self.assertRaises(ValidationError, self._makeOne, default=u'')
 
     def test_validate_not_required(self):
-        from zope.schema._compat import b
+
         field = self._makeOne(required=False)
-        field.validate(b(''))
-        field.validate(b('abc'))
-        field.validate(b('abc\ndef'))
+        field.validate(b'')
+        field.validate(b'abc')
+        field.validate(b'abc\ndef')
         field.validate(None)
 
     def test_validate_required(self):
         from zope.schema.interfaces import RequiredMissing
-        from zope.schema._compat import b
+
         field = self._makeOne()
-        field.validate(b(''))
-        field.validate(b('abc'))
-        field.validate(b('abc\ndef'))
+        field.validate(b'')
+        field.validate(b'abc')
+        field.validate(b'abc\ndef')
         self.assertRaises(RequiredMissing, field.validate, None)
 
     def test_fromUnicode_miss(self):
-        from zope.schema._compat import u
+        from zope.schema._compat import text_type
         byt = self._makeOne()
-        self.assertRaises(UnicodeEncodeError, byt.fromUnicode, u(chr(129)))
+        u = chr(129)
+        if not isinstance(u, text_type):
+            u = text_type(u, 'unicode_escape') # PY2
+        self.assertRaises(UnicodeEncodeError, byt.fromUnicode, u)
 
     def test_fromUnicode_hit(self):
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
         byt = self._makeOne()
-        self.assertEqual(byt.fromUnicode(u('')), b(''))
-        self.assertEqual(byt.fromUnicode(u('DEADBEEF')), b('DEADBEEF'))
+        self.assertEqual(byt.fromUnicode(u''), b'')
+        self.assertEqual(byt.fromUnicode(u'DEADBEEF'), b'DEADBEEF')
 
 
 class ASCIITests(unittest.TestCase):
@@ -151,9 +153,9 @@ class BytesLineTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
+
         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, ())
@@ -164,30 +166,30 @@ class BytesLineTests(unittest.TestCase):
         self.assertRaises(WrongType, field.validate, object())
 
     def test_validate_not_required(self):
-        from zope.schema._compat import b
+
         field = self._makeOne(required=False)
         field.validate(None)
-        field.validate(b(''))
-        field.validate(b('abc'))
-        field.validate(b('\xab\xde'))
+        field.validate(b'')
+        field.validate(b'abc')
+        field.validate(b'\xab\xde')
 
     def test_validate_required(self):
         from zope.schema.interfaces import RequiredMissing
-        from zope.schema._compat import b
+
         field = self._makeOne()
-        field.validate(b(''))
-        field.validate(b('abc'))
-        field.validate(b('\xab\xde'))
+        field.validate(b'')
+        field.validate(b'abc')
+        field.validate(b'\xab\xde')
         self.assertRaises(RequiredMissing, field.validate, None)
 
     def test_constraint(self):
-        from zope.schema._compat import b
+
         field = self._makeOne()
-        self.assertEqual(field.constraint(b('')), True)
-        self.assertEqual(field.constraint(b('abc')), True)
-        self.assertEqual(field.constraint(b('abc')), True)
-        self.assertEqual(field.constraint(b('\xab\xde')), True)
-        self.assertEqual(field.constraint(b('abc\ndef')), False)
+        self.assertEqual(field.constraint(b''), True)
+        self.assertEqual(field.constraint(b'abc'), True)
+        self.assertEqual(field.constraint(b'abc'), True)
+        self.assertEqual(field.constraint(b'\xab\xde'), True)
+        self.assertEqual(field.constraint(b'abc\ndef'), False)
 
 
 class ASCIILineTests(unittest.TestCase):
@@ -313,18 +315,18 @@ class FloatTests(unittest.TestCase):
         self.assertRaises(TooBig, field.validate, 20.02)
 
     def test_fromUnicode_miss(self):
-        from zope.schema._compat import u
+
         flt = self._makeOne()
-        self.assertRaises(ValueError, flt.fromUnicode, u(''))
-        self.assertRaises(ValueError, flt.fromUnicode, u('abc'))
-        self.assertRaises(ValueError, flt.fromUnicode, u('14.G'))
+        self.assertRaises(ValueError, flt.fromUnicode, u'')
+        self.assertRaises(ValueError, flt.fromUnicode, u'abc')
+        self.assertRaises(ValueError, flt.fromUnicode, u'14.G')
 
     def test_fromUnicode_hit(self):
-        from zope.schema._compat import u
+
         flt = self._makeOne()
-        self.assertEqual(flt.fromUnicode(u('0')), 0.0)
-        self.assertEqual(flt.fromUnicode(u('1.23')), 1.23)
-        self.assertEqual(flt.fromUnicode(u('1.23e6')), 1230000.0)
+        self.assertEqual(flt.fromUnicode(u'0'), 0.0)
+        self.assertEqual(flt.fromUnicode(u'1.23'), 1.23)
+        self.assertEqual(flt.fromUnicode(u'1.23e6'), 1230000.0)
 
 
 class DecimalTests(unittest.TestCase):
@@ -396,19 +398,19 @@ class DecimalTests(unittest.TestCase):
         self.assertRaises(TooBig, field.validate, decimal.Decimal("20.02"))
 
     def test_fromUnicode_miss(self):
-        from zope.schema._compat import u
+
         flt = self._makeOne()
-        self.assertRaises(ValueError, flt.fromUnicode, u(''))
-        self.assertRaises(ValueError, flt.fromUnicode, u('abc'))
-        self.assertRaises(ValueError, flt.fromUnicode, u('1.4G'))
+        self.assertRaises(ValueError, flt.fromUnicode, u'')
+        self.assertRaises(ValueError, flt.fromUnicode, u'abc')
+        self.assertRaises(ValueError, flt.fromUnicode, u'1.4G')
 
     def test_fromUnicode_hit(self):
         from decimal import Decimal
-        from zope.schema._compat import u
+
         flt = self._makeOne()
-        self.assertEqual(flt.fromUnicode(u('0')), Decimal('0.0'))
-        self.assertEqual(flt.fromUnicode(u('1.23')), Decimal('1.23'))
-        self.assertEqual(flt.fromUnicode(u('12345.6')), Decimal('12345.6'))
+        self.assertEqual(flt.fromUnicode(u'0'), Decimal('0.0'))
+        self.assertEqual(flt.fromUnicode(u'1.23'), Decimal('1.23'))
+        self.assertEqual(flt.fromUnicode(u'12345.6'), Decimal('12345.6'))
 
 
 class DatetimeTests(unittest.TestCase):
@@ -433,11 +435,11 @@ class DatetimeTests(unittest.TestCase):
     def test_validate_wrong_types(self):
         from datetime import date
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, ())
@@ -519,11 +521,11 @@ class DateTests(unittest.TestCase):
     def test_validate_wrong_types(self):
         from datetime import datetime
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, ())
@@ -867,18 +869,18 @@ class ChoiceTests(unittest.TestCase):
 
     def test_fromUnicode_miss(self):
         from zope.schema.interfaces import ConstraintNotSatisfied
-        from zope.schema._compat import u
-        flt = self._makeOne(values=(u('foo'), u('bar'), u('baz')))
-        self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u(''))
-        self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u('abc'))
-        self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u('1.4G'))
+
+        flt = self._makeOne(values=(u'foo', u'bar', u'baz'))
+        self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u'')
+        self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u'abc')
+        self.assertRaises(ConstraintNotSatisfied, flt.fromUnicode, u'1.4G')
 
     def test_fromUnicode_hit(self):
-        from zope.schema._compat import u
-        flt = self._makeOne(values=(u('foo'), u('bar'), u('baz')))
-        self.assertEqual(flt.fromUnicode(u('foo')), u('foo'))
-        self.assertEqual(flt.fromUnicode(u('bar')), u('bar'))
-        self.assertEqual(flt.fromUnicode(u('baz')), u('baz'))
+
+        flt = self._makeOne(values=(u'foo', u'bar', u'baz'))
+        self.assertEqual(flt.fromUnicode(u'foo'), u'foo')
+        self.assertEqual(flt.fromUnicode(u'bar'), u'bar')
+        self.assertEqual(flt.fromUnicode(u'baz'), u'baz')
 
     def test__validate_int(self):
         from zope.schema.interfaces import ConstraintNotSatisfied
@@ -888,12 +890,12 @@ class ChoiceTests(unittest.TestCase):
         self.assertRaises(ConstraintNotSatisfied, choice._validate, 4)
 
     def test__validate_string(self):
-        from zope.schema._compat import u
+
         from zope.schema.interfaces import ConstraintNotSatisfied
         choice = self._makeOne(values=['a', 'c'])
         choice._validate('a')  # doesn't raise
         choice._validate('c')  # doesn't raise
-        choice._validate(u('c'))  # doesn't raise
+        choice._validate(u'c')  # doesn't raise
         self.assertRaises(ConstraintNotSatisfied, choice._validate, 'd')
 
     def test__validate_tuple(self):
@@ -1016,20 +1018,20 @@ class URITests(unittest.TestCase):
                           field.validate, 'http://example.com/\nDAV:')
 
     def test_fromUnicode_ok(self):
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertEqual(field.fromUnicode(u('http://example.com/')),
+        self.assertEqual(field.fromUnicode(u'http://example.com/'),
                          'http://example.com/')
 
     def test_fromUnicode_invalid(self):
         from zope.schema.interfaces import ConstraintNotSatisfied
         from zope.schema.interfaces import InvalidURI
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertRaises(InvalidURI, field.fromUnicode, u(''))
-        self.assertRaises(InvalidURI, field.fromUnicode, u('abc'))
+        self.assertRaises(InvalidURI, field.fromUnicode, u'')
+        self.assertRaises(InvalidURI, field.fromUnicode, u'abc')
         self.assertRaises(ConstraintNotSatisfied,
-                          field.fromUnicode, u('http://example.com/\nDAV:'))
+                          field.fromUnicode, u'http://example.com/\nDAV:')
 
 
 class DottedNameTests(unittest.TestCase):
@@ -1122,18 +1124,18 @@ class DottedNameTests(unittest.TestCase):
                           field.validate, 'http://example.com/\nDAV:')
 
     def test_fromUnicode_dotted_name_ok(self):
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertEqual(field.fromUnicode(u('dotted.name')), 'dotted.name')
+        self.assertEqual(field.fromUnicode(u'dotted.name'), 'dotted.name')
 
     def test_fromUnicode_invalid(self):
         from zope.schema.interfaces import ConstraintNotSatisfied
         from zope.schema.interfaces import InvalidDottedName
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertRaises(InvalidDottedName, field.fromUnicode, u(''))
+        self.assertRaises(InvalidDottedName, field.fromUnicode, u'')
         self.assertRaises(ConstraintNotSatisfied,
-                          field.fromUnicode, u('http://example.com/\nDAV:'))
+                          field.fromUnicode, u'http://example.com/\nDAV:')
 
 
 class IdTests(unittest.TestCase):
@@ -1193,25 +1195,25 @@ class IdTests(unittest.TestCase):
                           field.validate, 'http://example.com/\nDAV:')
 
     def test_fromUnicode_url_ok(self):
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertEqual(field.fromUnicode(u('http://example.com/')),
+        self.assertEqual(field.fromUnicode(u'http://example.com/'),
                          'http://example.com/')
 
     def test_fromUnicode_dotted_name_ok(self):
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertEqual(field.fromUnicode(u('dotted.name')), 'dotted.name')
+        self.assertEqual(field.fromUnicode(u'dotted.name'), 'dotted.name')
 
     def test_fromUnicode_invalid(self):
         from zope.schema.interfaces import ConstraintNotSatisfied
         from zope.schema.interfaces import InvalidId
-        from zope.schema._compat import u
+
         field = self._makeOne()
-        self.assertRaises(InvalidId, field.fromUnicode, u(''))
-        self.assertRaises(InvalidId, field.fromUnicode, u('abc'))
+        self.assertRaises(InvalidId, field.fromUnicode, u'')
+        self.assertRaises(InvalidId, field.fromUnicode, u'abc')
         self.assertRaises(ConstraintNotSatisfied,
-                          field.fromUnicode, u('http://example.com/\nDAV:'))
+                          field.fromUnicode, u'http://example.com/\nDAV:')
 
 
 class InterfaceFieldTests(unittest.TestCase):
@@ -1236,11 +1238,11 @@ class InterfaceFieldTests(unittest.TestCase):
     def test_validate_wrong_types(self):
         from datetime import date
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, ())
@@ -1328,10 +1330,10 @@ class AbstractCollectionTests(unittest.TestCase):
     def test__validate_miss_uniqueness(self):
         from zope.schema.interfaces import NotUnique
         from zope.schema._bootstrapfields import Text
-        from zope.schema._compat import u
+
         text = Text()
         absc = self._makeOne(text, True)
-        self.assertRaises(NotUnique, absc.validate, [u('a'), u('a')])
+        self.assertRaises(NotUnique, absc.validate, [u'a', u'a'])
 
 
 class TupleTests(unittest.TestCase):
@@ -1355,11 +1357,11 @@ class TupleTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, [])
@@ -1430,11 +1432,11 @@ class ListTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, ())
@@ -1511,11 +1513,11 @@ class SetTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, ())
@@ -1595,11 +1597,11 @@ class FrozenSetTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, ())
@@ -1826,7 +1828,7 @@ class ObjectTests(unittest.TestCase):
         from zope.interface import implementer
         from zope.schema._bootstrapfields import Text
         from zope.schema._field import Choice
-        from zope.schema._compat import u
+
         schema = self._makeSchema(
             foo=Text(),
             bar=Text(),
@@ -1835,8 +1837,8 @@ class ObjectTests(unittest.TestCase):
 
         @implementer(schema)
         class OK(object):
-            foo = u('Foo')
-            bar = u('Bar')
+            foo = u'Foo'
+            bar = u'Bar'
             baz = 2
         objf = self._makeOne(schema)
         objf.validate(OK())  # doesn't raise
@@ -1881,7 +1883,7 @@ class ObjectTests(unittest.TestCase):
         from zope.schema.interfaces import IBeforeObjectAssignedEvent
         from zope.schema._bootstrapfields import Text
         from zope.schema._field import Choice
-        from zope.schema._compat import u
+
         schema = self._makeSchema(
             foo=Text(),
             bar=Text(),
@@ -1890,8 +1892,8 @@ class ObjectTests(unittest.TestCase):
 
         @implementer(schema)
         class OK(object):
-            foo = u('Foo')
-            bar = u('Bar')
+            foo = u'Foo'
+            bar = u'Bar'
             baz = 2
         log = []
         subscribers.append(log.append)
@@ -1911,7 +1913,7 @@ class ObjectTests(unittest.TestCase):
         from zope.interface import implementer
         from zope.schema._bootstrapfields import Text
         from zope.schema._field import Choice
-        from zope.schema._compat import u
+
         schema = self._makeSchema(
             foo=Text(),
             bar=Text(),
@@ -1920,12 +1922,12 @@ class ObjectTests(unittest.TestCase):
 
         @implementer(schema)
         class OK(object):
-            def __init__(self, foo=u('Foo'), bar=u('Bar'), baz=2):
+            def __init__(self, foo=u'Foo', bar=u'Bar', baz=2):
                 self.foo = foo
                 self.bar = bar
                 self.baz = baz
         ok1 = OK()
-        ok2 = OK(u('Foo2'), u('Bar2'), 3)
+        ok2 = OK(u'Foo2', u'Bar2', 3)
         log = []
         subscribers.append(log.append)
 
@@ -1970,11 +1972,11 @@ class DictTests(unittest.TestCase):
 
     def test_validate_wrong_types(self):
         from zope.schema.interfaces import WrongType
-        from zope.schema._compat import u
-        from zope.schema._compat import b
+
+
         field = self._makeOne()
-        self.assertRaises(WrongType, field.validate, u(''))
-        self.assertRaises(WrongType, field.validate, b(''))
+        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, ())
diff --git a/src/zope/schema/tests/test_accessors.py b/src/zope/schema/tests/test_accessors.py
index bfd72a1..baac70a 100644
--- a/src/zope/schema/tests/test_accessors.py
+++ b/src/zope/schema/tests/test_accessors.py
@@ -30,8 +30,8 @@ class FieldReadAccessorTests(unittest.TestCase):
 
     def test_ctor_not_created_inside_interface(self):
         from zope.schema import Text
-        from zope.schema._compat import u
-        field = Text(title=u('Hmm'))
+
+        field = Text(title=u'Hmm')
         wrapped = self._makeOne(field)
         self.assertTrue(wrapped.field is field)
         self.assertEqual(wrapped.__name__, '')  # __name__ set when in iface
@@ -40,8 +40,8 @@ class FieldReadAccessorTests(unittest.TestCase):
     def test_ctor_created_inside_interface(self):
         from zope.interface import Interface
         from zope.schema import Text
-        from zope.schema._compat import u
-        field = Text(title=u('Hmm'))
+
+        field = Text(title=u'Hmm')
 
         class IFoo(Interface):
             getter = self._makeOne(field)
@@ -218,8 +218,8 @@ class FieldWriteAccessorTests(unittest.TestCase):
 
     def test_ctor_not_created_inside_interface(self):
         from zope.schema import Text
-        from zope.schema._compat import u
-        field = Text(title=u('Hmm'))
+
+        field = Text(title=u'Hmm')
         wrapped = self._makeOne(field)
         self.assertTrue(wrapped.field is field)
         self.assertEqual(wrapped.__name__, '')  # __name__ set when in iface
@@ -228,8 +228,8 @@ class FieldWriteAccessorTests(unittest.TestCase):
     def test_ctor_created_inside_interface(self):
         from zope.interface import Interface
         from zope.schema import Text
-        from zope.schema._compat import u
-        field = Text(title=u('Hmm'))
+
+        field = Text(title=u'Hmm')
 
         class IFoo(Interface):
             setter = self._makeOne(field)
@@ -261,8 +261,8 @@ class Test_accessors(unittest.TestCase):
     def test_w_only_read_accessor(self):
         from zope.interface import Interface
         from zope.schema import Text
-        from zope.schema._compat import u
-        field = Text(title=u('Hmm'), readonly=True)
+
+        field = Text(title=u'Hmm', readonly=True)
 
         class IFoo(Interface):
             getter, = self._callFUT(field)
@@ -281,8 +281,8 @@ class Test_accessors(unittest.TestCase):
     def test_w_read_and_write_accessors(self):
         from zope.interface import Interface
         from zope.schema import Text
-        from zope.schema._compat import u
-        field = Text(title=u('Hmm'))
+
+        field = Text(title=u'Hmm')
 
         class IFoo(Interface):
             getter, setter = self._callFUT(field)
diff --git a/src/zope/schema/tests/test_equality.py b/src/zope/schema/tests/test_equality.py
index 23663e8..0fc14d5 100644
--- a/src/zope/schema/tests/test_equality.py
+++ b/src/zope/schema/tests/test_equality.py
@@ -20,19 +20,14 @@ class FieldEqualityTests(unittest.TestCase):
 
     def test_equality(self):
 
-        from zope.schema._compat import u
         from zope.schema import Int
         from zope.schema import Text
 
-        # pep 8 friendlyness
-        u, Int, Text
+        def _makeOne(cls):
+            return cls(title=u"Foo", description=u"Bar")
 
-        equality = [
-            'Text(title=u("Foo"), description=u("Bar"))',
-            'Int(title=u("Foo"), description=u("Bar"))',
-        ]
-        for text in equality:
-            self.assertEqual(eval(text), eval(text))
+        for cls in Int,Text:
+            self.assertEqual(_makeOne(cls), _makeOne(cls))
 
 
 def test_suite():
diff --git a/src/zope/schema/tests/test_fieldproperty.py b/src/zope/schema/tests/test_fieldproperty.py
index 2b8ab21..513d3f3 100644
--- a/src/zope/schema/tests/test_fieldproperty.py
+++ b/src/zope/schema/tests/test_fieldproperty.py
@@ -42,28 +42,27 @@ class _Integration(object):
         return _Implementer()
 
     def test_basic(self):
-        from zope.schema._compat import b
-        from zope.schema._compat import u
+
         from zope.schema.interfaces import ValidationError
         c = self._makeImplementer()
-        self.assertEqual(c.title, u('say something'))
+        self.assertEqual(c.title, u'say something')
         self.assertEqual(c.weight, None)
-        self.assertEqual(c.code, b('xxxxxx'))
-        self.assertRaises(ValidationError, setattr, c, 'title', b('foo'))
-        self.assertRaises(ValidationError, setattr, c, 'weight', b('foo'))
+        self.assertEqual(c.code, b'xxxxxx')
+        self.assertRaises(ValidationError, setattr, c, 'title', b'foo')
+        self.assertRaises(ValidationError, setattr, c, 'weight', b'foo')
         self.assertRaises(ValidationError, setattr, c, 'weight', -1.0)
         self.assertRaises(ValidationError, setattr, c, 'weight', 2)
         self.assertRaises(ValidationError, setattr, c, 'code', -1)
-        self.assertRaises(ValidationError, setattr, c, 'code', b('xxxx'))
-        self.assertRaises(ValidationError, setattr, c, 'code', u('xxxxxx'))
+        self.assertRaises(ValidationError, setattr, c, 'code', b'xxxx')
+        self.assertRaises(ValidationError, setattr, c, 'code', u'xxxxxx')
 
-        c.title = u('c is good')
+        c.title = u'c is good'
         c.weight = 10.0
-        c.code = b('abcdef')
+        c.code = b'abcdef'
 
-        self.assertEqual(c.title, u('c is good'))
+        self.assertEqual(c.title, u'c is good')
         self.assertEqual(c.weight, 10)
-        self.assertEqual(c.code, b('abcdef'))
+        self.assertEqual(c.code, b'abcdef')
 
     def test_readonly(self):
         c = self._makeImplementer()
@@ -94,11 +93,11 @@ class FieldPropertyTests(_Base, _Integration):
 
     def test_ctor_explicit(self):
         from zope.schema import Text
-        from zope.schema._compat import u
+
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
-            default=u('DEFAULT'),
+            description=u'DESCRIPTION',
+            default=u'DEFAULT',
             readonly=True,
             required=True,
         )
@@ -113,11 +112,11 @@ class FieldPropertyTests(_Base, _Integration):
 
     def test_query_value_with_default(self):
         from zope.schema import Text
-        from zope.schema._compat import u
+
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
-            default=u('DEFAULT'),
+            description=u'DESCRIPTION',
+            default=u'DEFAULT',
             readonly=True,
             required=True,
         )
@@ -127,16 +126,16 @@ class FieldPropertyTests(_Base, _Integration):
         class Foo(object):
             testing = prop
         foo = Foo()
-        self.assertEqual(prop.queryValue(foo, 'test'), u('DEFAULT'))
-        foo.testing = u('NO')
-        self.assertEqual(prop.queryValue(foo, 'test'), u('NO'))
+        self.assertEqual(prop.queryValue(foo, 'test'), u'DEFAULT')
+        foo.testing = u'NO'
+        self.assertEqual(prop.queryValue(foo, 'test'), u'NO')
 
     def test_query_value_without_default(self):
         from zope.schema import Text
-        from zope.schema._compat import u
+
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
+            description=u'DESCRIPTION',
             readonly=True,
             required=True,
         )
@@ -268,7 +267,7 @@ class FieldPropertyTests(_Base, _Integration):
 
     def test_field_event(self):
         from zope.schema import Text
-        from zope.schema._compat import u
+
         from zope.event import subscribers
         from zope.schema.fieldproperty import FieldUpdatedEvent
         log = []
@@ -276,8 +275,8 @@ class FieldPropertyTests(_Base, _Integration):
         self.assertEqual(log, [])
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
-            default=u('DEFAULT'),
+            description=u'DESCRIPTION',
+            default=u'DEFAULT',
             readonly=True,
             required=True,
         )
@@ -293,13 +292,13 @@ class FieldPropertyTests(_Base, _Integration):
 
     def test_field_event_update(self):
         from zope.schema import Text
-        from zope.schema._compat import u
+
         from zope.event import subscribers
         from zope.schema.fieldproperty import FieldUpdatedEvent
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
-            default=u('DEFAULT'),
+            description=u'DESCRIPTION',
+            default=u'DEFAULT',
             required=True,
         )
         prop = self._makeOne(field=field)
@@ -310,15 +309,15 @@ class FieldPropertyTests(_Base, _Integration):
 
         log = []
         subscribers.append(log.append)
-        foo.testing = u('Bar')
-        foo.testing = u('Foo')
+        foo.testing = u'Bar'
+        foo.testing = u'Foo'
         self.assertEqual(len(log), 2)
         event = log[1]
         self.assertTrue(isinstance(event, FieldUpdatedEvent))
         self.assertEqual(event.inst, foo)
         self.assertEqual(event.field, field)
-        self.assertEqual(event.old_value, u('Bar'))
-        self.assertEqual(event.new_value, u('Foo'))
+        self.assertEqual(event.old_value, u'Bar')
+        self.assertEqual(event.new_value, u'Foo')
 
 
 class FieldPropertyStoredThroughFieldTests(_Base, _Integration):
@@ -344,11 +343,11 @@ class FieldPropertyStoredThroughFieldTests(_Base, _Integration):
 
     def test_ctor_explicit(self):
         from zope.schema import Text
-        from zope.schema._compat import u
+
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
-            default=u('DEFAULT'),
+            description=u'DESCRIPTION',
+            default=u'DEFAULT',
             readonly=True,
             required=True,
         )
@@ -561,13 +560,13 @@ class FieldPropertyStoredThroughFieldTests(_Base, _Integration):
 
     def test_field_event_update(self):
         from zope.schema import Text
-        from zope.schema._compat import u
+
         from zope.event import subscribers
         from zope.schema.fieldproperty import FieldUpdatedEvent
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
-            default=u('DEFAULT'),
+            description=u'DESCRIPTION',
+            default=u'DEFAULT',
             required=True,
         )
         prop = self._makeOne(field=field)
@@ -578,21 +577,21 @@ class FieldPropertyStoredThroughFieldTests(_Base, _Integration):
 
         log = []
         subscribers.append(log.append)
-        foo.testing = u('Bar')
-        foo.testing = u('Foo')
+        foo.testing = u'Bar'
+        foo.testing = u'Foo'
         self.assertEqual(len(log), 2)
         event = log[1]
         self.assertTrue(isinstance(event, FieldUpdatedEvent))
         self.assertEqual(event.inst, foo)
         self.assertEqual(event.field, field)
-        self.assertEqual(event.old_value, u('Bar'))
-        self.assertEqual(event.new_value, u('Foo'))
+        self.assertEqual(event.old_value, u'Bar')
+        self.assertEqual(event.new_value, u'Foo')
 
     def test_field_event(self):
         # fieldproperties are everywhere including in field themselfs
         # so event are triggered
         from zope.schema import Text
-        from zope.schema._compat import u
+
         from zope.event import subscribers
         from zope.schema.fieldproperty import FieldUpdatedEvent
         log = []
@@ -600,8 +599,8 @@ class FieldPropertyStoredThroughFieldTests(_Base, _Integration):
         self.assertEqual(log, [])
         field = Text(
             __name__='testing',
-            description=u('DESCRIPTION'),
-            default=u('DEFAULT'),
+            description=u'DESCRIPTION',
+            default=u'DEFAULT',
             readonly=True,
             required=True,
         )
@@ -622,15 +621,15 @@ def _getSchema():
     from zope.schema import Bytes
     from zope.schema import Float
     from zope.schema import Text
-    from zope.schema._compat import b
-    from zope.schema._compat import u
+
+
 
     class Schema(Interface):
-        title = Text(description=u("Short summary"),
-                     default=u('say something'))
+        title = Text(description=u"Short summary",
+                     default=u'say something')
         weight = Float(min=0.0)
-        code = Bytes(min_length=6, max_length=6, default=b('xxxxxx'))
-        date = Float(title=u('Date'), readonly=True)
+        code = Bytes(min_length=6, max_length=6, default=b'xxxxxx')
+        date = Float(title=u'Date', readonly=True)
 
     return Schema
 
diff --git a/src/zope/schema/tests/test_interfaces.py b/src/zope/schema/tests/test_interfaces.py
index dc3e7f6..e77c873 100644
--- a/src/zope/schema/tests/test_interfaces.py
+++ b/src/zope/schema/tests/test_interfaces.py
@@ -8,14 +8,12 @@ class Test__is_field(unittest.TestCase):
         return _is_field(value)
 
     def test_non_fields(self):
-        from zope.schema._compat import b
-        from zope.schema._compat import u
         self.assertEqual(self._callFUT(None), False)
         self.assertEqual(self._callFUT(0), False)
         self.assertEqual(self._callFUT(0.0), False)
         self.assertEqual(self._callFUT(True), False)
-        self.assertEqual(self._callFUT(b('')), False)
-        self.assertEqual(self._callFUT(u('')), False)
+        self.assertEqual(self._callFUT(u''), False)
+        self.assertEqual(self._callFUT(u''), False)
         self.assertEqual(self._callFUT(()), False)
         self.assertEqual(self._callFUT([]), False)
         self.assertEqual(self._callFUT({}), False)
diff --git a/src/zope/schema/tests/test_schema.py b/src/zope/schema/tests/test_schema.py
index 01ba5e7..3a54e11 100644
--- a/src/zope/schema/tests/test_schema.py
+++ b/src/zope/schema/tests/test_schema.py
@@ -17,42 +17,41 @@ import unittest
 
 
 def _makeSchema():
-    from zope.schema._compat import b
-    from zope.schema._compat import u
+
     from zope.interface import Interface
     from zope.schema import Bytes
 
     class ISchemaTest(Interface):
         title = Bytes(
-            title=u("Title"),
-            description=u("Title"),
-            default=b(""),
+            title=u"Title",
+            description=u"Title",
+            default=b"",
             required=True)
         description = Bytes(
-            title=u("Description"),
-            description=u("Description"),
-            default=b(""),
+            title=u"Description",
+            description=u"Description",
+            default=b"",
             required=True)
         spam = Bytes(
-            title=u("Spam"),
-            description=u("Spam"),
-            default=b(""),
+            title=u"Spam",
+            description=u"Spam",
+            default=b"",
             required=True)
     return ISchemaTest
 
 
 def _makeDerivedSchema(base=None):
-    from zope.schema._compat import b
-    from zope.schema._compat import u
+
+
     from zope.schema import Bytes
     if base is None:
         base = _makeSchema()
 
     class ISchemaTestSubclass(base):
         foo = Bytes(
-            title=u('Foo'),
-            description=u('Fooness'),
-            default=b(""),
+            title=u'Foo',
+            description=u'Fooness',
+            default=b"",
             required=False)
     return ISchemaTestSubclass
 
@@ -222,15 +221,15 @@ class Test_getSchemaValidationErrors(unittest.TestCase):
     def test_schema_with_fields_ok(self):
         from zope.interface import Interface
         from zope.schema import Text
-        from zope.schema._compat import u
+
 
         class IWithFields(Interface):
             foo = Text()
             bar = Text()
 
         class Obj(object):
-            foo = u('Foo')
-            bar = u('Bar')
+            foo = u'Foo'
+            bar = u'Bar'
 
         errors = self._callFUT(IWithFields, Obj())
         self.assertEqual(len(errors), 0)
diff --git a/src/zope/schema/tests/test_states.py b/src/zope/schema/tests/test_states.py
index 0bdbc85..2bfd3d0 100644
--- a/src/zope/schema/tests/test_states.py
+++ b/src/zope/schema/tests/test_states.py
@@ -31,32 +31,32 @@ class StateSelectionTest(unittest.TestCase):
         _clear()
 
     def _makeSchema(self):
-        from zope.schema._compat import u
+
         from zope.interface import Interface
         from zope.schema import Choice
         from zope.schema.tests.states import StateVocabulary
 
         class IBirthInfo(Interface):
             state1 = Choice(
-                title=u('State of Birth'),
-                description=u('The state in which you were born.'),
+                title=u'State of Birth',
+                description=u'The state in which you were born.',
                 vocabulary="states",
                 default="AL",
                 )
             state2 = Choice(
-                title=u('State of Birth'),
-                description=u('The state in which you were born.'),
+                title=u'State of Birth',
+                description=u'The state in which you were born.',
                 vocabulary="states",
                 default="AL",
                 )
             state3 = Choice(
-                title=u('Favorite State'),
-                description=u('The state you like the most.'),
+                title=u'Favorite State',
+                description=u'The state you like the most.',
                 vocabulary=StateVocabulary(),
                 )
             state4 = Choice(
-                title=u("Name"),
-                description=u("The name of your new state"),
+                title=u"Name",
+                description=u"The name of your new state",
                 vocabulary="states",
                 )
         return IBirthInfo