Remove the u/b BWC functions.remove-u

9 files changed, 361 insertions, 368 deletions

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