Clean up most py3k compat

Change-Id: I8172fdcc3103ff92aa049827728484c8779af6b7

65 files changed, 381 insertions, 569 deletions

diff --git a/test/aaa_profiling/test_resultset.py b/test/aaa_profiling/test_resultset.py
index 1f777e42e..12921a7dc 100644
--- a/test/aaa_profiling/test_resultset.py
+++ b/test/aaa_profiling/test_resultset.py
@@ -12,7 +12,6 @@ from sqlalchemy.testing import AssertsExecutionResults
 from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import profiling
-from sqlalchemy.util import u
 
 
 NUM_FIELDS = 10
@@ -49,7 +48,7 @@ class ResultSetTest(fixtures.TablesTest, AssertsExecutionResults):
             t.insert(),
             [
                 dict(
-                    ("field%d" % fnum, u("value%d" % fnum))
+                    ("field%d" % fnum, "value%d" % fnum)
                     for fnum in range(NUM_FIELDS)
                 )
                 for r_num in range(NUM_RECORDS)
@@ -59,7 +58,7 @@ class ResultSetTest(fixtures.TablesTest, AssertsExecutionResults):
             t2.insert(),
             [
                 dict(
-                    ("field%d" % fnum, u("value%d" % fnum))
+                    ("field%d" % fnum, "value%d" % fnum)
                     for fnum in range(NUM_FIELDS)
                 )
                 for r_num in range(NUM_RECORDS)
diff --git a/test/base/test_events.py b/test/base/test_events.py
index c94de7dd5..2b785ba0b 100644
--- a/test/base/test_events.py
+++ b/test/base/test_events.py
@@ -1,5 +1,8 @@
 """Test event registration and listening."""
 
+from unittest.mock import call
+from unittest.mock import Mock
+
 from sqlalchemy import event
 from sqlalchemy import exc
 from sqlalchemy import testing
@@ -10,8 +13,6 @@ from sqlalchemy.testing import expect_deprecated
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
 from sqlalchemy.testing import is_not
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.util import gc_collect
 
 
diff --git a/test/base/test_except.py b/test/base/test_except.py
index 767fd233c..6e9a3c5df 100644
--- a/test/base/test_except.py
+++ b/test/base/test_except.py
@@ -10,8 +10,6 @@ from sqlalchemy.engine import default
 from sqlalchemy.testing import combinations_list
 from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
-from sqlalchemy.util import compat
-from sqlalchemy.util import u
 
 
 class Error(Exception):
@@ -157,16 +155,13 @@ class WrapTest(fixtures.TestBase):
     def test_wrap_unicode_arg(self):
         # this is not supported by the API but oslo_db is doing it
         orig = sa_exceptions.DBAPIError(False, False, False)
-        orig.args = [u("méil")]
+        orig.args = ["méil"]
         eq_(
-            compat.text_type(orig),
-            compat.u(
-                "méil\n(Background on this error at: "
-                "https://sqlalche.me/e/%s/dbapi)"
-                % sa_exceptions._version_token
-            ),
+            str(orig),
+            "méil\n(Background on this error at: "
+            "https://sqlalche.me/e/%s/dbapi)" % sa_exceptions._version_token,
         )
-        eq_(orig.args, (u("méil"),))
+        eq_(orig.args, ("méil",))
 
     def test_tostring_large_dict(self):
         try:
diff --git a/test/base/test_misc_py3k.py b/test/base/test_misc_py3k.py
index 11e7b9edd..d0cc5eed9 100644
--- a/test/base/test_misc_py3k.py
+++ b/test/base/test_misc_py3k.py
@@ -1,10 +1,8 @@
 from sqlalchemy import Column
 from sqlalchemy.testing import fixtures
-from sqlalchemy.testing import requires
 
 
 class TestGenerics(fixtures.TestBase):
-    @requires.generic_classes
     def test_traversible_is_generic(self):
         col = Column[int]
         assert col is Column
diff --git a/test/base/test_tutorials.py b/test/base/test_tutorials.py
index c8c51b0b5..bf4503fe6 100644
--- a/test/base/test_tutorials.py
+++ b/test/base/test_tutorials.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import doctest
 import logging
 import os
@@ -69,7 +67,7 @@ class DocTest(fixtures.TestBase):
             checker=_get_unicode_checker(),
         )
         parser = doctest.DocTestParser()
-        globs = {"print_function": print_function}
+        globs = {"print_function": print}
 
         for fname in fnames:
             path = os.path.join(sqla_base, "doc/build", fname)
diff --git a/test/base/test_utils.py b/test/base/test_utils.py
index 8674f4779..3bbcbe3fb 100644
--- a/test/base/test_utils.py
+++ b/test/base/test_utils.py
@@ -1,8 +1,8 @@
 #! coding: utf-8
 
 import copy
-import datetime
 import inspect
+import pickle
 import sys
 
 from sqlalchemy import exc
@@ -28,7 +28,6 @@ from sqlalchemy.util import classproperty
 from sqlalchemy.util import compat
 from sqlalchemy.util import get_callable_argspec
 from sqlalchemy.util import langhelpers
-from sqlalchemy.util import timezone
 from sqlalchemy.util import WeakSequence
 
 
@@ -1741,14 +1740,9 @@ class IdentitySetTest(fixtures.TestBase):
         return super_, sub_, twin1, twin2, unique1, unique2
 
     def _assert_unorderable_types(self, callable_):
-        if util.py3k:
-            assert_raises_message(
-                TypeError, "not supported between instances of", callable_
-            )
-        else:
-            assert_raises_message(
-                TypeError, "cannot compare sets using cmp()", callable_
-            )
+        assert_raises_message(
+            TypeError, "not supported between instances of", callable_
+        )
 
     def test_basic_sanity(self):
         IdentitySet = util.IdentitySet
@@ -2241,13 +2235,13 @@ class SymbolTest(fixtures.TestBase):
         assert sym1 is sym2
 
         # default
-        s = util.pickle.dumps(sym1)
-        util.pickle.loads(s)
+        s = pickle.dumps(sym1)
+        pickle.loads(s)
 
         for protocol in 0, 1, 2:
             print(protocol)
-            serial = util.pickle.dumps(sym1)
-            rt = util.pickle.loads(serial)
+            serial = pickle.dumps(sym1)
+            rt = pickle.loads(serial)
             assert rt is sym1
             assert rt is sym2
 
@@ -2336,34 +2330,16 @@ class SymbolTest(fixtures.TestBase):
 
 
 class _Py3KFixtures:
-    def _kw_only_fixture(self):
+    def _kw_only_fixture(self, a, *, b, c):
         pass
 
-    def _kw_plus_posn_fixture(self):
+    def _kw_plus_posn_fixture(self, a, *args, b, c):
         pass
 
-    def _kw_opt_fixture(self):
+    def _kw_opt_fixture(self, a, *, b, c="c"):
         pass
 
 
-if util.py3k:
-    _locals = {}
-    exec(
-        """
-def _kw_only_fixture(self, a, *, b, c):
-    pass
-
-def _kw_plus_posn_fixture(self, a, *args, b, c):
-    pass
-
-def _kw_opt_fixture(self, a, *, b, c="c"):
-    pass
-""",
-        _locals,
-    )
-    for k in _locals:
-        setattr(_Py3KFixtures, k, _locals[k])
-
 py3k_fixtures = _Py3KFixtures()
 
 
@@ -3138,100 +3114,43 @@ class BackslashReplaceTest(fixtures.TestBase):
     def test_ascii_to_utf8(self):
         eq_(
             compat.decode_backslashreplace(util.b("hello world"), "utf-8"),
-            util.u("hello world"),
+            "hello world",
         )
 
     def test_utf8_to_utf8(self):
         eq_(
             compat.decode_backslashreplace(
-                util.u("some message méil").encode("utf-8"), "utf-8"
+                "some message méil".encode("utf-8"), "utf-8"
             ),
-            util.u("some message méil"),
+            "some message méil",
         )
 
     def test_latin1_to_utf8(self):
         eq_(
             compat.decode_backslashreplace(
-                util.u("some message méil").encode("latin-1"), "utf-8"
+                "some message méil".encode("latin-1"), "utf-8"
             ),
-            util.u("some message m\\xe9il"),
+            "some message m\\xe9il",
         )
 
         eq_(
             compat.decode_backslashreplace(
-                util.u("some message méil").encode("latin-1"), "latin-1"
+                "some message méil".encode("latin-1"), "latin-1"
             ),
-            util.u("some message méil"),
+            "some message méil",
         )
 
     def test_cp1251_to_utf8(self):
-        message = util.u("some message П").encode("cp1251")
+        message = "some message П".encode("cp1251")
         eq_(message, b"some message \xcf")
         eq_(
             compat.decode_backslashreplace(message, "utf-8"),
-            util.u("some message \\xcf"),
+            "some message \\xcf",
         )
 
         eq_(
             compat.decode_backslashreplace(message, "cp1251"),
-            util.u("some message П"),
-        )
-
-
-class TimezoneTest(fixtures.TestBase):
-    """test the python 2 backport of the "timezone" class.
-
-    Note under python 3, these tests work against the builtin timezone,
-    thereby providing confirmation that the tests are correct.
-
-    """
-
-    @testing.combinations(
-        (datetime.timedelta(0), "UTC"),
-        (datetime.timedelta(hours=5), "UTC+05:00"),
-        (datetime.timedelta(hours=5, minutes=10), "UTC+05:10"),
-        (
-            datetime.timedelta(hours=5, minutes=10, seconds=27),
-            "UTC+05:10:27",
-            testing.requires.granular_timezone,
-        ),
-        (datetime.timedelta(hours=-3, minutes=10), "UTC-02:50"),
-        (
-            datetime.timedelta(
-                hours=5, minutes=10, seconds=27, microseconds=550
-            ),
-            "UTC+05:10:27.000550",
-            testing.requires.granular_timezone,
-        ),
-    )
-    def test_tzname(self, td, expected):
-        eq_(timezone(td).tzname(None), expected)
-
-    def test_utcoffset(self):
-        eq_(
-            timezone(datetime.timedelta(hours=5)).utcoffset(None),
-            datetime.timedelta(hours=5),
-        )
-
-    def test_fromutc(self):
-        tzinfo = timezone(datetime.timedelta(hours=5))
-        dt = datetime.datetime(2017, 10, 5, 12, 55, 38, tzinfo=tzinfo)
-        eq_(
-            dt.astimezone(timezone.utc),
-            datetime.datetime(2017, 10, 5, 7, 55, 38, tzinfo=timezone.utc),
-        )
-
-        # this is the same as hours=-3
-        del_ = datetime.timedelta(days=-1, seconds=75600)
-        eq_(
-            dt.astimezone(timezone(datetime.timedelta(hours=-3))),
-            datetime.datetime(2017, 10, 5, 4, 55, 38, tzinfo=timezone(del_)),
-        )
-
-    def test_repr(self):
-        eq_(
-            repr(timezone(datetime.timedelta(hours=5))),
-            "datetime.timezone(%r)" % (datetime.timedelta(hours=5)),
+            "some message П",
         )
 
 
diff --git a/test/conftest.py b/test/conftest.py
index 0db4486a9..6f08a7c0d 100755
--- a/test/conftest.py
+++ b/test/conftest.py
@@ -16,11 +16,6 @@ os.environ["SQLALCHEMY_WARN_20"] = "true"
 
 collect_ignore_glob = []
 
-# minimum version for a py3k only test is at
-# 3.6 because these are asyncio tests anyway
-if sys.version_info[0:2] < (3, 6):
-    collect_ignore_glob.append("*_py3k.py")
-
 pytest.register_assert_rewrite("sqlalchemy.testing.assertions")
 
 
diff --git a/test/dialect/mssql/test_deprecations.py b/test/dialect/mssql/test_deprecations.py
index 24625d65c..972ce413b 100644
--- a/test/dialect/mssql/test_deprecations.py
+++ b/test/dialect/mssql/test_deprecations.py
@@ -1,4 +1,6 @@
 # -*- encoding: utf-8
+from unittest.mock import Mock
+
 from sqlalchemy import Column
 from sqlalchemy import engine_from_config
 from sqlalchemy import Integer
@@ -17,7 +19,6 @@ from sqlalchemy.testing import engines
 from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
-from sqlalchemy.testing.mock import Mock
 
 
 def _legacy_schema_aliasing_warning():
diff --git a/test/dialect/mssql/test_engine.py b/test/dialect/mssql/test_engine.py
index e14fd164a..b40981a99 100644
--- a/test/dialect/mssql/test_engine.py
+++ b/test/dialect/mssql/test_engine.py
@@ -1,6 +1,7 @@
 # -*- encoding: utf-8
 
 from decimal import Decimal
+from unittest.mock import Mock
 
 from sqlalchemy import Column
 from sqlalchemy import event
@@ -26,7 +27,6 @@ from sqlalchemy.testing import expect_raises
 from sqlalchemy.testing import expect_warnings
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import mock
-from sqlalchemy.testing.mock import Mock
 
 
 class ParseConnectTest(fixtures.TestBase):
diff --git a/test/dialect/mssql/test_reflection.py b/test/dialect/mssql/test_reflection.py
index 1789166ee..f877d2c5c 100644
--- a/test/dialect/mssql/test_reflection.py
+++ b/test/dialect/mssql/test_reflection.py
@@ -19,7 +19,6 @@ from sqlalchemy import Table
 from sqlalchemy import testing
 from sqlalchemy import types
 from sqlalchemy import types as sqltypes
-from sqlalchemy import util
 from sqlalchemy.dialects import mssql
 from sqlalchemy.dialects.mssql import base
 from sqlalchemy.dialects.mssql.information_schema import tables
@@ -782,8 +781,8 @@ class IdentityReflectionTest(fixtures.TablesTest):
                 eq_(type(col["identity"]["increment"]), int)
             elif col["name"] == "id3":
                 eq_(col["identity"], {"start": 1, "increment": 1})
-                eq_(type(col["identity"]["start"]), util.compat.long_type)
-                eq_(type(col["identity"]["increment"]), util.compat.long_type)
+                eq_(type(col["identity"]["start"]), int)
+                eq_(type(col["identity"]["increment"]), int)
             elif col["name"] == "id4":
                 eq_(col["identity"], {"start": 1, "increment": 1})
                 eq_(type(col["identity"]["start"]), int)
diff --git a/test/dialect/mssql/test_types.py b/test/dialect/mssql/test_types.py
index 57a1f1284..63c6cf26d 100644
--- a/test/dialect/mssql/test_types.py
+++ b/test/dialect/mssql/test_types.py
@@ -31,7 +31,6 @@ from sqlalchemy import Time
 from sqlalchemy import types
 from sqlalchemy import Unicode
 from sqlalchemy import UnicodeText
-from sqlalchemy import util
 from sqlalchemy.dialects.mssql import base as mssql
 from sqlalchemy.dialects.mssql import ROWVERSION
 from sqlalchemy.dialects.mssql import TIMESTAMP
@@ -790,7 +789,7 @@ class TypeRoundTripTest(
             2,
             32,
             123456,
-            util.timezone(datetime.timedelta(hours=-5)),
+            datetime.timezone(datetime.timedelta(hours=-5)),
         )
         return t, (d1, t1, d2, d3)
 
@@ -828,7 +827,7 @@ class TypeRoundTripTest(
                 11,
                 2,
                 32,
-                tzinfo=util.timezone(datetime.timedelta(hours=-5)),
+                tzinfo=datetime.timezone(datetime.timedelta(hours=-5)),
             ),
         ),
         (datetime.datetime(2007, 10, 30, 11, 2, 32)),
@@ -849,7 +848,7 @@ class TypeRoundTripTest(
         ).first()
 
         if not date.tzinfo:
-            eq_(row, (date, date.replace(tzinfo=util.timezone.utc)))
+            eq_(row, (date, date.replace(tzinfo=datetime.timezone.utc)))
         else:
             eq_(row, (date.replace(tzinfo=None), date))
 
@@ -875,7 +874,7 @@ class TypeRoundTripTest(
                 2,
                 32,
                 123456,
-                util.timezone(datetime.timedelta(hours=1)),
+                datetime.timezone(datetime.timedelta(hours=1)),
             ),
             1,
             False,
@@ -890,7 +889,7 @@ class TypeRoundTripTest(
                 2,
                 32,
                 123456,
-                util.timezone(datetime.timedelta(hours=-5)),
+                datetime.timezone(datetime.timedelta(hours=-5)),
             ),
             -5,
             False,
@@ -905,7 +904,7 @@ class TypeRoundTripTest(
                 2,
                 32,
                 123456,
-                util.timezone(datetime.timedelta(seconds=4000)),
+                datetime.timezone(datetime.timedelta(seconds=4000)),
             ),
             None,
             True,
@@ -973,7 +972,7 @@ class TypeRoundTripTest(
                     2,
                     32,
                     123456,
-                    util.timezone(
+                    datetime.timezone(
                         datetime.timedelta(hours=expected_offset_hours)
                     ),
                 ),
@@ -1168,7 +1167,7 @@ class StringTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_string_text_literal_binds_explicit_unicode_right(self):
         self.assert_compile(
-            column("x", String()) == util.u("foo"),
+            column("x", String()) == "foo",
             "x = 'foo'",
             literal_binds=True,
         )
@@ -1178,7 +1177,7 @@ class StringTest(fixtures.TestBase, AssertsCompiledSQL):
         # Unicode on Python 3 for plain string, test with unicode
         # string just to confirm literal is doing this
         self.assert_compile(
-            column("x", String()) == literal(util.u("foo")),
+            column("x", String()) == literal("foo"),
             "x = N'foo'",
             literal_binds=True,
         )
diff --git a/test/dialect/mysql/test_reflection.py b/test/dialect/mysql/test_reflection.py
index 60d7e3a5d..08c7d9a4d 100644
--- a/test/dialect/mysql/test_reflection.py
+++ b/test/dialect/mysql/test_reflection.py
@@ -30,7 +30,6 @@ from sqlalchemy import types
 from sqlalchemy import Unicode
 from sqlalchemy import UnicodeText
 from sqlalchemy import UniqueConstraint
-from sqlalchemy import util
 from sqlalchemy.dialects.mysql import base as mysql
 from sqlalchemy.dialects.mysql import reflection as _reflection
 from sqlalchemy.schema import CreateIndex
@@ -848,8 +847,8 @@ class ReflectionTest(fixtures.TestBase, AssertsCompiledSQL):
             },
         ]
         ischema_casing_1 = [
-            (util.u("Test"), util.u("Track"), "TrackID"),
-            (util.u("Test_Schema"), util.u("Track"), "TrackID"),
+            ("Test", "Track", "TrackID"),
+            ("Test_Schema", "Track", "TrackID"),
         ]
         return fkeys_casing_1, ischema_casing_1
 
diff --git a/test/dialect/mysql/test_types.py b/test/dialect/mysql/test_types.py
index c83de7f49..3d26e1d07 100644
--- a/test/dialect/mysql/test_types.py
+++ b/test/dialect/mysql/test_types.py
@@ -21,7 +21,6 @@ from sqlalchemy import TIMESTAMP
 from sqlalchemy import TypeDecorator
 from sqlalchemy import types as sqltypes
 from sqlalchemy import UnicodeText
-from sqlalchemy import util
 from sqlalchemy.dialects.mysql import base as mysql
 from sqlalchemy.testing import assert_raises
 from sqlalchemy.testing import assert_raises_message
@@ -31,7 +30,6 @@ from sqlalchemy.testing import eq_
 from sqlalchemy.testing import eq_regex
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
-from sqlalchemy.util import u
 
 
 class TypeCompileTest(fixtures.TestBase, AssertsCompiledSQL):
@@ -520,8 +518,8 @@ class TypeRoundTripTest(fixtures.TestBase, AssertsExecutionResults):
         # in order to test the condition here, need to use
         # MySQLdb 1.2.3 and also need to pass either use_unicode=1
         # or charset=utf8 to the URL.
-        connection.execute(t.insert(), dict(id=1, data=u("some text")))
-        assert isinstance(connection.scalar(select(t.c.data)), util.text_type)
+        connection.execute(t.insert(), dict(id=1, data="some text"))
+        assert isinstance(connection.scalar(select(t.c.data)), str)
 
     @testing.metadata_fixture(ddl="class")
     def bit_table(self, metadata):
@@ -1077,17 +1075,17 @@ class EnumSetTest(
             "t",
             metadata,
             Column("id", Integer, primary_key=True),
-            Column("data", mysql.SET(u("réveillé"), u("drôle"), u("S’il"))),
+            Column("data", mysql.SET("réveillé", "drôle", "S’il")),
         )
 
         set_table.create(connection)
         connection.execute(
-            set_table.insert(), {"data": set([u("réveillé"), u("drôle")])}
+            set_table.insert(), {"data": set(["réveillé", "drôle"])}
         )
 
         row = connection.execute(set_table.select()).first()
 
-        eq_(row, (1, set([u("réveillé"), u("drôle")])))
+        eq_(row, (1, set(["réveillé", "drôle"])))
 
     def test_int_roundtrip(self, metadata, connection):
         set_table = self._set_fixture_one(metadata)
@@ -1159,25 +1157,25 @@ class EnumSetTest(
             "table",
             metadata,
             Column("id", Integer, primary_key=True),
-            Column("value", Enum(u("réveillé"), u("drôle"), u("S’il"))),
-            Column("value2", mysql.ENUM(u("réveillé"), u("drôle"), u("S’il"))),
+            Column("value", Enum("réveillé", "drôle", "S’il")),
+            Column("value2", mysql.ENUM("réveillé", "drôle", "S’il")),
         )
         metadata.create_all(connection)
 
         connection.execute(
             t1.insert(),
             [
-                dict(value=u("drôle"), value2=u("drôle")),
-                dict(value=u("réveillé"), value2=u("réveillé")),
-                dict(value=u("S’il"), value2=u("S’il")),
+                dict(value="drôle", value2="drôle"),
+                dict(value="réveillé", value2="réveillé"),
+                dict(value="S’il", value2="S’il"),
             ],
         )
         eq_(
             connection.execute(t1.select().order_by(t1.c.id)).fetchall(),
             [
-                (1, u("drôle"), u("drôle")),
-                (2, u("réveillé"), u("réveillé")),
-                (3, u("S’il"), u("S’il")),
+                (1, "drôle", "drôle"),
+                (2, "réveillé", "réveillé"),
+                (3, "S’il", "S’il"),
             ],
         )
 
@@ -1189,11 +1187,11 @@ class EnumSetTest(
         #       latin-1 stuff forcing its way in ?
 
         eq_(
-            t2.c.value.type.enums[0:2], [u("réveillé"), u("drôle")]
+            t2.c.value.type.enums[0:2], ["réveillé", "drôle"]
         )  # u'S’il') # eh ?
 
         eq_(
-            t2.c.value2.type.enums[0:2], [u("réveillé"), u("drôle")]
+            t2.c.value2.type.enums[0:2], ["réveillé", "drôle"]
         )  # u'S’il') # eh ?
 
     def test_enum_compile(self):
diff --git a/test/dialect/oracle/test_dialect.py b/test/dialect/oracle/test_dialect.py
index 52162a286..18996c3f9 100644
--- a/test/dialect/oracle/test_dialect.py
+++ b/test/dialect/oracle/test_dialect.py
@@ -1,6 +1,7 @@
 # coding: utf-8
 
 import re
+from unittest.mock import Mock
 
 from sqlalchemy import bindparam
 from sqlalchemy import Computed
@@ -30,12 +31,9 @@ from sqlalchemy.testing import engines
 from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import mock
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.suite import test_select
-from sqlalchemy.util import u
-from sqlalchemy.util import ue
 
 
 class DialectTest(fixtures.TestBase):
@@ -242,7 +240,7 @@ class EncodingErrorsTest(fixtures.TestBase):
     )
 
     def _assert_errorhandler(self, outconverter, has_errorhandler):
-        data = ue("\uee2c\u9a66")  # this is u"\uee2c\u9a66"
+        data = "\uee2c\u9a66"  # this is u"\uee2c\u9a66"
 
         utf8_w_errors = data.encode("utf-16")
 
@@ -757,25 +755,25 @@ class UnicodeSchemaTest(fixtures.TestBase):
         )
         metadata.create_all(connection)
 
-        connection.execute(table.insert(), {"_underscorecolumn": u("’é")})
+        connection.execute(table.insert(), {"_underscorecolumn": "’é"})
         result = connection.execute(
-            table.select().where(table.c._underscorecolumn == u("’é"))
+            table.select().where(table.c._underscorecolumn == "’é")
         ).scalar()
-        eq_(result, u("’é"))
+        eq_(result, "’é")
 
     def test_quoted_column_unicode(self, metadata, connection):
         table = Table(
             "atable",
             metadata,
-            Column(u("méil"), Unicode(255), primary_key=True),
+            Column("méil", Unicode(255), primary_key=True),
         )
         metadata.create_all(connection)
 
-        connection.execute(table.insert(), {u("méil"): u("’é")})
+        connection.execute(table.insert(), {"méil": "’é"})
         result = connection.execute(
-            table.select().where(table.c[u("méil")] == u("’é"))
+            table.select().where(table.c["méil"] == "’é")
         ).scalar()
-        eq_(result, u("’é"))
+        eq_(result, "’é")
 
 
 class CXOracleConnectArgsTest(fixtures.TestBase):
diff --git a/test/dialect/oracle/test_types.py b/test/dialect/oracle/test_types.py
index 703472055..db5717e17 100644
--- a/test/dialect/oracle/test_types.py
+++ b/test/dialect/oracle/test_types.py
@@ -32,7 +32,6 @@ from sqlalchemy import TypeDecorator
 from sqlalchemy import types as sqltypes
 from sqlalchemy import Unicode
 from sqlalchemy import UnicodeText
-from sqlalchemy import util
 from sqlalchemy import VARCHAR
 from sqlalchemy.dialects.oracle import base as oracle
 from sqlalchemy.dialects.oracle import cx_oracle
@@ -48,7 +47,6 @@ from sqlalchemy.testing.engines import testing_engine
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.util import b
-from sqlalchemy.util import u
 
 
 def exec_sql(conn, sql, *args, **kwargs):
@@ -784,13 +782,13 @@ class TypesTest(fixtures.TestBase):
                 cx_oracle._OracleNChar,
             )
 
-        data = u("m’a réveillé.")
+        data = "m’a réveillé."
         connection.execute(t2.insert(), dict(nv_data=data, c_data=data))
         nv_data, c_data = connection.execute(t2.select()).first()
         eq_(nv_data, data)
         eq_(c_data, data + (" " * 7))  # char is space padded
-        assert isinstance(nv_data, util.text_type)
-        assert isinstance(c_data, util.text_type)
+        assert isinstance(nv_data, str)
+        assert isinstance(c_data, str)
 
     def test_reflect_unicode_no_nvarchar(self, metadata, connection):
         Table("tnv", metadata, Column("data", sqltypes.Unicode(255)))
@@ -805,11 +803,11 @@ class TypesTest(fixtures.TestBase):
                 cx_oracle._OracleString,
             )
 
-        data = u("m’a réveillé.")
+        data = "m’a réveillé."
         connection.execute(t2.insert(), {"data": data})
         res = connection.execute(t2.select()).first().data
         eq_(res, data)
-        assert isinstance(res, util.text_type)
+        assert isinstance(res, str)
 
     def test_char_length(self, metadata, connection):
         t1 = Table(
@@ -1133,7 +1131,7 @@ class EuroNumericTest(fixtures.TestBase):
                     {},
                 ),
             ]:
-                if isinstance(stmt, util.string_types):
+                if isinstance(stmt, str):
                     test_exp = conn.exec_driver_sql(stmt, kw).scalar()
                 else:
                     test_exp = conn.scalar(stmt, **kw)
@@ -1153,13 +1151,13 @@ class SetInputSizesTest(fixtures.TestBase):
         (oracle.BINARY_DOUBLE, 25.34534, "NATIVE_FLOAT", False),
         (oracle.BINARY_FLOAT, 25.34534, "NATIVE_FLOAT", False),
         (oracle.DOUBLE_PRECISION, 25.34534, None, False),
-        (Unicode(30), u("test"), "NCHAR", True),
-        (UnicodeText(), u("test"), "NCLOB", True),
-        (Unicode(30), u("test"), None, False),
-        (UnicodeText(), u("test"), "CLOB", False),
+        (Unicode(30), "test", "NCHAR", True),
+        (UnicodeText(), "test", "NCLOB", True),
+        (Unicode(30), "test", None, False),
+        (UnicodeText(), "test", "CLOB", False),
         (String(30), "test", None, False),
         (CHAR(30), "test", "FIXED_CHAR", False),
-        (NCHAR(30), u("test"), "FIXED_NCHAR", False),
+        (NCHAR(30), "test", "FIXED_NCHAR", False),
         (oracle.LONG(), "test", None, False),
         argnames="datatype, value, sis_value_text, set_nchar_flag",
     )
diff --git a/test/dialect/postgresql/test_compiler.py b/test/dialect/postgresql/test_compiler.py
index 7e91f0ebb..a04e2932a 100644
--- a/test/dialect/postgresql/test_compiler.py
+++ b/test/dialect/postgresql/test_compiler.py
@@ -56,7 +56,6 @@ from sqlalchemy.testing.assertions import AssertsCompiledSQL
 from sqlalchemy.testing.assertions import expect_warnings
 from sqlalchemy.testing.assertions import is_
 from sqlalchemy.util import OrderedDict
-from sqlalchemy.util import u
 
 
 class SequenceTest(fixtures.TestBase, AssertsCompiledSQL):
@@ -190,15 +189,10 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_create_drop_enum(self):
         # test escaping and unicode within CREATE TYPE for ENUM
-        typ = postgresql.ENUM(
-            "val1", "val2", "val's 3", u("méil"), name="myname"
-        )
+        typ = postgresql.ENUM("val1", "val2", "val's 3", "méil", name="myname")
         self.assert_compile(
             postgresql.CreateEnumType(typ),
-            u(
-                "CREATE TYPE myname AS "
-                "ENUM ('val1', 'val2', 'val''s 3', 'méil')"
-            ),
+            "CREATE TYPE myname AS ENUM ('val1', 'val2', 'val''s 3', 'méil')",
         )
 
         typ = postgresql.ENUM("val1", "val2", "val's 3", name="PleaseQuoteMe")
diff --git a/test/dialect/postgresql/test_dialect.py b/test/dialect/postgresql/test_dialect.py
index 7d4ea2ced..57682686c 100644
--- a/test/dialect/postgresql/test_dialect.py
+++ b/test/dialect/postgresql/test_dialect.py
@@ -51,8 +51,6 @@ from sqlalchemy.testing.assertions import AssertsExecutionResults
 from sqlalchemy.testing.assertions import eq_
 from sqlalchemy.testing.assertions import eq_regex
 from sqlalchemy.testing.assertions import ne_
-from sqlalchemy.util import u
-from sqlalchemy.util import ue
 
 if True:
     from sqlalchemy.dialects.postgresql.psycopg2 import (
@@ -313,10 +311,10 @@ class ExecuteManyMode:
         )
 
         Table(
-            u("Unitéble2"),
+            "Unitéble2",
             metadata,
-            Column(u("méil"), Integer, primary_key=True),
-            Column(ue("\u6e2c\u8a66"), Integer),
+            Column("méil", Integer, primary_key=True),
+            Column("\u6e2c\u8a66", Integer),
         )
 
     def test_insert(self, connection):
@@ -478,16 +476,16 @@ class ExecuteManyMode:
         )
 
     def test_insert_unicode_keys(self, connection):
-        table = self.tables[u("Unitéble2")]
+        table = self.tables["Unitéble2"]
 
         stmt = table.insert()
 
         connection.execute(
             stmt,
             [
-                {u("méil"): 1, ue("\u6e2c\u8a66"): 1},
-                {u("méil"): 2, ue("\u6e2c\u8a66"): 2},
-                {u("méil"): 3, ue("\u6e2c\u8a66"): 3},
+                {"méil": 1, "\u6e2c\u8a66": 1},
+                {"méil": 2, "\u6e2c\u8a66": 2},
+                {"méil": 3, "\u6e2c\u8a66": 3},
             ],
         )
 
diff --git a/test/dialect/postgresql/test_types.py b/test/dialect/postgresql/test_types.py
index 4c0b91f93..acca0926e 100644
--- a/test/dialect/postgresql/test_types.py
+++ b/test/dialect/postgresql/test_types.py
@@ -1,6 +1,7 @@
 # coding: utf-8
 import datetime
 import decimal
+from enum import Enum as _PY_Enum
 import re
 import uuid
 
@@ -319,30 +320,30 @@ class EnumTest(fixtures.TestBase, AssertsExecutionResults):
             Column(
                 "value",
                 Enum(
-                    util.u("réveillé"),
-                    util.u("drôle"),
-                    util.u("S’il"),
+                    "réveillé",
+                    "drôle",
+                    "S’il",
                     name="onetwothreetype",
                 ),
             ),
         )
         metadata.create_all(connection)
-        connection.execute(t1.insert(), dict(value=util.u("drôle")))
-        connection.execute(t1.insert(), dict(value=util.u("réveillé")))
-        connection.execute(t1.insert(), dict(value=util.u("S’il")))
+        connection.execute(t1.insert(), dict(value="drôle"))
+        connection.execute(t1.insert(), dict(value="réveillé"))
+        connection.execute(t1.insert(), dict(value="S’il"))
         eq_(
             connection.execute(t1.select().order_by(t1.c.id)).fetchall(),
             [
-                (1, util.u("drôle")),
-                (2, util.u("réveillé")),
-                (3, util.u("S’il")),
+                (1, "drôle"),
+                (2, "réveillé"),
+                (3, "S’il"),
             ],
         )
         m2 = MetaData()
         t2 = Table("table", m2, autoload_with=connection)
         eq_(
             t2.c.value.type.enums,
-            [util.u("réveillé"), util.u("drôle"), util.u("S’il")],
+            ["réveillé", "drôle", "S’il"],
         )
 
     def test_non_native_enum(self, metadata, connection):
@@ -390,7 +391,7 @@ class EnumTest(fixtures.TestBase, AssertsExecutionResults):
                 "bar",
                 Enum(
                     "B",
-                    util.u("Ü"),
+                    "Ü",
                     name="myenum",
                     create_constraint=True,
                     native_enum=False,
@@ -406,18 +407,16 @@ class EnumTest(fixtures.TestBase, AssertsExecutionResults):
             go,
             [
                 (
-                    util.u(
-                        "CREATE TABLE foo (\tbar "
-                        "VARCHAR(1), \tCONSTRAINT myenum CHECK "
-                        "(bar IN ('B', 'Ü')))"
-                    ),
+                    "CREATE TABLE foo (\tbar "
+                    "VARCHAR(1), \tCONSTRAINT myenum CHECK "
+                    "(bar IN ('B', 'Ü')))",
                     {},
                 )
             ],
         )
 
-        connection.execute(t1.insert(), {"bar": util.u("Ü")})
-        eq_(connection.scalar(select(t1.c.bar)), util.u("Ü"))
+        connection.execute(t1.insert(), {"bar": "Ü"})
+        eq_(connection.scalar(select(t1.c.bar)), "Ü")
 
     def test_disable_create(self, metadata, connection):
         metadata = self.metadata
@@ -1628,13 +1627,13 @@ class ArrayRoundTripTest:
             arrtable.insert(),
             dict(
                 intarr=[1, 2, 3],
-                strarr=[util.u("abc"), util.u("def")],
+                strarr=["abc", "def"],
             ),
         )
         results = connection.execute(arrtable.select()).fetchall()
         eq_(len(results), 1)
         eq_(results[0].intarr, [1, 2, 3])
-        eq_(results[0].strarr, [util.u("abc"), util.u("def")])
+        eq_(results[0].strarr, ["abc", "def"])
 
     def test_insert_array_w_null(self, connection):
         arrtable = self.tables.arrtable
@@ -1642,13 +1641,13 @@ class ArrayRoundTripTest:
             arrtable.insert(),
             dict(
                 intarr=[1, None, 3],
-                strarr=[util.u("abc"), None],
+                strarr=["abc", None],
             ),
         )
         results = connection.execute(arrtable.select()).fetchall()
         eq_(len(results), 1)
         eq_(results[0].intarr, [1, None, 3])
-        eq_(results[0].strarr, [util.u("abc"), None])
+        eq_(results[0].strarr, ["abc", None])
 
     def test_array_where(self, connection):
         arrtable = self.tables.arrtable
@@ -1656,11 +1655,11 @@ class ArrayRoundTripTest:
             arrtable.insert(),
             dict(
                 intarr=[1, 2, 3],
-                strarr=[util.u("abc"), util.u("def")],
+                strarr=["abc", "def"],
             ),
         )
         connection.execute(
-            arrtable.insert(), dict(intarr=[4, 5, 6], strarr=util.u("ABC"))
+            arrtable.insert(), dict(intarr=[4, 5, 6], strarr="ABC")
         )
         results = connection.execute(
             arrtable.select().where(arrtable.c.intarr == [1, 2, 3])
@@ -1672,7 +1671,7 @@ class ArrayRoundTripTest:
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            dict(intarr=[1, 2, 3], strarr=[util.u("abc"), util.u("def")]),
+            dict(intarr=[1, 2, 3], strarr=["abc", "def"]),
         )
         results = connection.execute(
             select(arrtable.c.intarr + [4, 5, 6])
@@ -1684,9 +1683,7 @@ class ArrayRoundTripTest:
         arrtable = self.tables.arrtable
         connection.execute(
             arrtable.insert(),
-            dict(
-                id=5, intarr=[1, 2, 3], strarr=[util.u("abc"), util.u("def")]
-            ),
+            dict(id=5, intarr=[1, 2, 3], strarr=["abc", "def"]),
         )
         results = connection.execute(
             select(arrtable.c.id).where(arrtable.c.intarr < [4, 5, 6])
@@ -1700,24 +1697,24 @@ class ArrayRoundTripTest:
             arrtable.insert(),
             dict(
                 intarr=[4, 5, 6],
-                strarr=[[util.ue("m\xe4\xe4")], [util.ue("m\xf6\xf6")]],
+                strarr=[["m\xe4\xe4"], ["m\xf6\xf6"]],
             ),
         )
         connection.execute(
             arrtable.insert(),
             dict(
                 intarr=[1, 2, 3],
-                strarr=[util.ue("m\xe4\xe4"), util.ue("m\xf6\xf6")],
+                strarr=["m\xe4\xe4", "m\xf6\xf6"],
             ),
         )
         results = connection.execute(
             arrtable.select().order_by(arrtable.c.intarr)
         ).fetchall()
         eq_(len(results), 2)
-        eq_(results[0].strarr, [util.ue("m\xe4\xe4"), util.ue("m\xf6\xf6")])
+        eq_(results[0].strarr, ["m\xe4\xe4", "m\xf6\xf6"])
         eq_(
             results[1].strarr,
-            [[util.ue("m\xe4\xe4")], [util.ue("m\xf6\xf6")]],
+            [["m\xe4\xe4"], ["m\xf6\xf6"]],
         )
 
     def test_array_literal_roundtrip(self, connection):
@@ -1790,7 +1787,7 @@ class ArrayRoundTripTest:
             arrtable.insert(),
             dict(
                 intarr=[4, 5, 6],
-                strarr=[util.u("abc"), util.u("def")],
+                strarr=["abc", "def"],
             ),
         )
         eq_(connection.scalar(select(arrtable.c.intarr[2:3])), [5, 6])
@@ -1909,11 +1906,11 @@ class ArrayRoundTripTest:
 
         def unicode_values(x):
             return [
-                util.u("réveillé"),
-                util.u("drôle"),
-                util.u("S’il %s" % x),
-                util.u("🐍 %s" % x),
-                util.u("« S’il vous"),
+                "réveillé",
+                "drôle",
+                "S’il %s" % x,
+                "🐍 %s" % x,
+                "« S’il vous",
             ]
 
         def json_values(x):
@@ -2328,6 +2325,11 @@ class ArrayEnum(fixtures.TestBase):
     @testing.fixture
     def array_of_enum_fixture(self, metadata, connection):
         def go(array_cls, enum_cls):
+            class MyEnum(_PY_Enum):
+                a = "aaa"
+                b = "bbb"
+                c = "ccc"
+
             tbl = Table(
                 "enum_table",
                 metadata,
@@ -2336,23 +2338,11 @@ class ArrayEnum(fixtures.TestBase):
                     "enum_col",
                     array_cls(enum_cls("foo", "bar", "baz", name="an_enum")),
                 ),
+                Column(
+                    "pyenum_col",
+                    array_cls(enum_cls(MyEnum)),
+                ),
             )
-            if util.py3k:
-                from enum import Enum
-
-                class MyEnum(Enum):
-                    a = "aaa"
-                    b = "bbb"
-                    c = "ccc"
-
-                tbl.append_column(
-                    Column(
-                        "pyenum_col",
-                        array_cls(enum_cls(MyEnum)),
-                    ),
-                )
-            else:
-                MyEnum = None
 
             metadata.create_all(connection)
             connection.execute(
@@ -3151,16 +3141,16 @@ class HStoreRoundTripTest(fixtures.TablesTest):
     def _test_unicode_round_trip(self, connection):
         s = select(
             hstore(
-                array([util.u("réveillé"), util.u("drôle"), util.u("S’il")]),
-                array([util.u("réveillé"), util.u("drôle"), util.u("S’il")]),
+                array(["réveillé", "drôle", "S’il"]),
+                array(["réveillé", "drôle", "S’il"]),
             )
         )
         eq_(
             connection.scalar(s),
             {
-                util.u("réveillé"): util.u("réveillé"),
-                util.u("drôle"): util.u("drôle"),
-                util.u("S’il"): util.u("S’il"),
+                "réveillé": "réveillé",
+                "drôle": "drôle",
+                "S’il": "S’il",
             },
         )
 
@@ -3826,7 +3816,7 @@ class JSONRoundTripTest(fixtures.TablesTest):
         result = connection.execute(
             select(data_table.c.data["k1"].astext)
         ).first()
-        assert isinstance(result[0], util.text_type)
+        assert isinstance(result[0], str)
 
     def test_query_returned_as_int(self, connection):
         self._fixture_data(connection)
@@ -3854,8 +3844,8 @@ class JSONRoundTripTest(fixtures.TablesTest):
         s = select(
             cast(
                 {
-                    util.u("réveillé"): util.u("réveillé"),
-                    "data": {"k1": util.u("drôle")},
+                    "réveillé": "réveillé",
+                    "data": {"k1": "drôle"},
                 },
                 self.data_type,
             )
@@ -3863,8 +3853,8 @@ class JSONRoundTripTest(fixtures.TablesTest):
         eq_(
             connection.scalar(s),
             {
-                util.u("réveillé"): util.u("réveillé"),
-                "data": {"k1": util.u("drôle")},
+                "réveillé": "réveillé",
+                "data": {"k1": "drôle"},
             },
         )
 
diff --git a/test/dialect/test_sqlite.py b/test/dialect/test_sqlite.py
index f827533d4..141033c1b 100644
--- a/test/dialect/test_sqlite.py
+++ b/test/dialect/test_sqlite.py
@@ -34,7 +34,6 @@ from sqlalchemy import text
 from sqlalchemy import tuple_
 from sqlalchemy import types as sqltypes
 from sqlalchemy import UniqueConstraint
-from sqlalchemy import util
 from sqlalchemy.dialects.sqlite import base as sqlite
 from sqlalchemy.dialects.sqlite import insert
 from sqlalchemy.dialects.sqlite import provision
@@ -60,8 +59,6 @@ from sqlalchemy.types import DateTime
 from sqlalchemy.types import Integer
 from sqlalchemy.types import String
 from sqlalchemy.types import Time
-from sqlalchemy.util import u
-from sqlalchemy.util import ue
 
 
 def exec_sql(engine, sql, *args, **kwargs):
@@ -160,7 +157,7 @@ class TestTypes(fixtures.TestBase, AssertsExecutionResults):
                 ),
             )
             r = conn.execute(func.current_date()).scalar()
-            assert isinstance(r, util.string_types)
+            assert isinstance(r, str)
 
     @testing.provide_metadata
     def test_custom_datetime(self, connection):
@@ -281,9 +278,7 @@ class TestTypes(fixtures.TestBase, AssertsExecutionResults):
             sqltypes.UnicodeText(),
         ):
             bindproc = t.dialect_impl(dialect).bind_processor(dialect)
-            assert not bindproc or isinstance(
-                bindproc(util.u("some string")), util.text_type
-            )
+            assert not bindproc or isinstance(bindproc("some string"), str)
 
 
 class JSONTest(fixtures.TestBase):
@@ -700,14 +695,14 @@ class DialectTest(
         t = Table(
             "x",
             self.metadata,
-            Column(u("méil"), Integer, primary_key=True),
-            Column(ue("\u6e2c\u8a66"), Integer),
+            Column("méil", Integer, primary_key=True),
+            Column("\u6e2c\u8a66", Integer),
         )
         self.metadata.create_all(testing.db)
 
         result = connection.execute(t.select())
-        assert u("méil") in result.keys()
-        assert ue("\u6e2c\u8a66") in result.keys()
+        assert "méil" in result.keys()
+        assert "\u6e2c\u8a66" in result.keys()
 
     def test_pool_class(self):
         e = create_engine("sqlite+pysqlite://")
diff --git a/test/engine/test_deprecations.py b/test/engine/test_deprecations.py
index d0cbe1a77..77c5c6a22 100644
--- a/test/engine/test_deprecations.py
+++ b/test/engine/test_deprecations.py
@@ -1,4 +1,5 @@
 import re
+from unittest.mock import Mock
 
 import sqlalchemy as tsa
 import sqlalchemy as sa
@@ -36,7 +37,6 @@ from sqlalchemy.testing import mock
 from sqlalchemy.testing.assertions import expect_deprecated
 from sqlalchemy.testing.assertions import expect_raises_message
 from sqlalchemy.testing.engines import testing_engine
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 
diff --git a/test/engine/test_execute.py b/test/engine/test_execute.py
index e1c86444d..4670297c1 100644
--- a/test/engine/test_execute.py
+++ b/test/engine/test_execute.py
@@ -1,8 +1,14 @@
 # coding: utf-8
 
+import collections.abc as collections_abc
 from contextlib import contextmanager
+from contextlib import nullcontext
+from io import StringIO
 import re
 import threading
+from unittest.mock import call
+from unittest.mock import Mock
+from unittest.mock import patch
 import weakref
 
 import sqlalchemy as tsa
@@ -46,14 +52,10 @@ from sqlalchemy.testing import is_true
 from sqlalchemy.testing import mock
 from sqlalchemy.testing.assertions import expect_deprecated
 from sqlalchemy.testing.assertsql import CompiledSQL
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
-from sqlalchemy.testing.mock import patch
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.util import gc_collect
 from sqlalchemy.testing.util import picklers
-from sqlalchemy.util import collections_abc
 
 
 class SomeException(Exception):
@@ -65,7 +67,7 @@ class Foo:
         return "foo"
 
     def __unicode__(self):
-        return util.u("fóó")
+        return "fóó"
 
 
 class ExecuteTest(fixtures.TablesTest):
@@ -444,7 +446,7 @@ class ExecuteTest(fixtures.TablesTest):
                     eq_(conn.execute(obj).scalar(), 1)
 
     def test_stmt_exception_bytestring_raised(self):
-        name = util.u("méil")
+        name = "méil"
         users = self.tables.users
         with testing.db.connect() as conn:
             assert_raises_message(
@@ -461,26 +463,26 @@ class ExecuteTest(fixtures.TablesTest):
     def test_stmt_exception_bytestring_utf8(self):
         # uncommon case for Py3K, bytestring object passed
         # as the error message
-        message = util.u("some message méil").encode("utf-8")
+        message = "some message méil".encode("utf-8")
 
         err = tsa.exc.SQLAlchemyError(message)
-        eq_(str(err), util.u("some message méil"))
+        eq_(str(err), "some message méil")
 
     def test_stmt_exception_bytestring_latin1(self):
         # uncommon case for Py3K, bytestring object passed
         # as the error message
-        message = util.u("some message méil").encode("latin-1")
+        message = "some message méil".encode("latin-1")
 
         err = tsa.exc.SQLAlchemyError(message)
-        eq_(str(err), util.u("some message m\\xe9il"))
+        eq_(str(err), "some message m\\xe9il")
 
     def test_stmt_exception_unicode_hook_unicode(self):
         # uncommon case for Py2K, Unicode object passed
         # as the error message
-        message = util.u("some message méil")
+        message = "some message méil"
 
         err = tsa.exc.SQLAlchemyError(message)
-        eq_(str(err), util.u("some message méil"))
+        eq_(str(err), "some message méil")
 
     def test_stmt_exception_object_arg(self):
         err = tsa.exc.SQLAlchemyError(Foo())
@@ -491,13 +493,13 @@ class ExecuteTest(fixtures.TablesTest):
         eq_(str(err), "('some message', 206)")
 
     def test_stmt_exception_str_multi_args_bytestring(self):
-        message = util.u("some message méil").encode("utf-8")
+        message = "some message méil".encode("utf-8")
 
         err = tsa.exc.SQLAlchemyError(message, 206)
         eq_(str(err), str((message, 206)))
 
     def test_stmt_exception_str_multi_args_unicode(self):
-        message = util.u("some message méil")
+        message = "some message méil"
 
         err = tsa.exc.SQLAlchemyError(message, 206)
         eq_(str(err), str((message, 206)))
@@ -1156,10 +1158,10 @@ class CompiledCacheTest(fixtures.TestBase):
 
 class MockStrategyTest(fixtures.TestBase):
     def _engine_fixture(self):
-        buf = util.StringIO()
+        buf = StringIO()
 
         def dump(sql, *multiparams, **params):
-            buf.write(util.text_type(sql.compile(dialect=engine.dialect)))
+            buf.write(str(sql.compile(dialect=engine.dialect)))
 
         engine = create_mock_engine("postgresql+psycopg2://", executor=dump)
         return engine, buf
@@ -1667,7 +1669,7 @@ class EngineEventsTest(fixtures.TestBase):
                     lambda self: None,
                 )
         else:
-            patcher = util.nullcontext()
+            patcher = nullcontext()
 
         with patcher:
             e1 = testing_engine(config.db_url)
diff --git a/test/engine/test_logging.py b/test/engine/test_logging.py
index bd5bde775..0c3d5e43b 100644
--- a/test/engine/test_logging.py
+++ b/test/engine/test_logging.py
@@ -10,7 +10,6 @@ from sqlalchemy import select
 from sqlalchemy import String
 from sqlalchemy import Table
 from sqlalchemy import testing
-from sqlalchemy import util
 from sqlalchemy.sql import util as sql_util
 from sqlalchemy.testing import assert_raises
 from sqlalchemy.testing import assert_raises_message
@@ -353,31 +352,17 @@ class LogParamsTest(fixtures.TestBase):
             % (largeparam[0:149], largeparam[-149:]),
         )
 
-        if util.py3k:
-            eq_(
-                self.buf.buffer[5].message,
-                "Row ('%s ... (4702 characters truncated) ... %s',)"
-                % (largeparam[0:149], largeparam[-149:]),
-            )
-        else:
-            eq_(
-                self.buf.buffer[5].message,
-                "Row (u'%s ... (4703 characters truncated) ... %s',)"
-                % (largeparam[0:148], largeparam[-149:]),
-            )
+        eq_(
+            self.buf.buffer[5].message,
+            "Row ('%s ... (4702 characters truncated) ... %s',)"
+            % (largeparam[0:149], largeparam[-149:]),
+        )
 
-        if util.py3k:
-            eq_(
-                repr(row),
-                "('%s ... (4702 characters truncated) ... %s',)"
-                % (largeparam[0:149], largeparam[-149:]),
-            )
-        else:
-            eq_(
-                repr(row),
-                "(u'%s ... (4703 characters truncated) ... %s',)"
-                % (largeparam[0:148], largeparam[-149:]),
-            )
+        eq_(
+            repr(row),
+            "('%s ... (4702 characters truncated) ... %s',)"
+            % (largeparam[0:149], largeparam[-149:]),
+        )
 
     def test_error_large_dict(self):
         assert_raises_message(
diff --git a/test/engine/test_parseconnect.py b/test/engine/test_parseconnect.py
index f0a1dba4b..c69b332a8 100644
--- a/test/engine/test_parseconnect.py
+++ b/test/engine/test_parseconnect.py
@@ -1,3 +1,7 @@
+from unittest.mock import call
+from unittest.mock import MagicMock
+from unittest.mock import Mock
+
 import sqlalchemy as tsa
 from sqlalchemy import create_engine
 from sqlalchemy import engine_from_config
@@ -19,9 +23,6 @@ from sqlalchemy.testing import mock
 from sqlalchemy.testing import ne_
 from sqlalchemy.testing.assertions import expect_deprecated
 from sqlalchemy.testing.assertions import expect_raises_message
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import MagicMock
-from sqlalchemy.testing.mock import Mock
 
 
 dialect = None
diff --git a/test/engine/test_pool.py b/test/engine/test_pool.py
index b1a099d31..c2ac6637f 100644
--- a/test/engine/test_pool.py
+++ b/test/engine/test_pool.py
@@ -2,6 +2,10 @@ import collections
 import random
 import threading
 import time
+from unittest.mock import ANY
+from unittest.mock import call
+from unittest.mock import Mock
+from unittest.mock import patch
 import weakref
 
 import sqlalchemy as tsa
@@ -25,10 +29,6 @@ from sqlalchemy.testing import is_not_none
 from sqlalchemy.testing import is_true
 from sqlalchemy.testing import mock
 from sqlalchemy.testing.engines import testing_engine
-from sqlalchemy.testing.mock import ANY
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
-from sqlalchemy.testing.mock import patch
 from sqlalchemy.testing.util import gc_collect
 from sqlalchemy.testing.util import lazy_gc
 
diff --git a/test/engine/test_reconnect.py b/test/engine/test_reconnect.py
index c9894b0f2..afd027698 100644
--- a/test/engine/test_reconnect.py
+++ b/test/engine/test_reconnect.py
@@ -1,4 +1,6 @@
 import time
+from unittest.mock import call
+from unittest.mock import Mock
 
 import sqlalchemy as tsa
 from sqlalchemy import create_engine
@@ -26,8 +28,6 @@ from sqlalchemy.testing import is_true
 from sqlalchemy.testing import mock
 from sqlalchemy.testing import ne_
 from sqlalchemy.testing.engines import testing_engine
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.util import gc_collect
diff --git a/test/engine/test_reflection.py b/test/engine/test_reflection.py
index 3072eba27..efd30071e 100644
--- a/test/engine/test_reflection.py
+++ b/test/engine/test_reflection.py
@@ -36,7 +36,6 @@ from sqlalchemy.testing import not_in
 from sqlalchemy.testing import skip
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
-from sqlalchemy.util import ue
 
 
 class ReflectionTest(fixtures.TestBase, ComparesTables):
@@ -1515,33 +1514,33 @@ class UnicodeReflectionTest(fixtures.TablesTest):
         no_has_table = [
             (
                 "no_has_table_1",
-                ue("col_Unit\u00e9ble"),
-                ue("ix_Unit\u00e9ble"),
+                "col_Unit\u00e9ble",
+                "ix_Unit\u00e9ble",
             ),
-            ("no_has_table_2", ue("col_\u6e2c\u8a66"), ue("ix_\u6e2c\u8a66")),
+            ("no_has_table_2", "col_\u6e2c\u8a66", "ix_\u6e2c\u8a66"),
         ]
         no_case_sensitivity = [
             (
-                ue("\u6e2c\u8a66"),
-                ue("col_\u6e2c\u8a66"),
-                ue("ix_\u6e2c\u8a66"),
+                "\u6e2c\u8a66",
+                "col_\u6e2c\u8a66",
+                "ix_\u6e2c\u8a66",
             ),
             (
-                ue("unit\u00e9ble"),
-                ue("col_unit\u00e9ble"),
-                ue("ix_unit\u00e9ble"),
+                "unit\u00e9ble",
+                "col_unit\u00e9ble",
+                "ix_unit\u00e9ble",
             ),
         ]
         full = [
             (
-                ue("Unit\u00e9ble"),
-                ue("col_Unit\u00e9ble"),
-                ue("ix_Unit\u00e9ble"),
+                "Unit\u00e9ble",
+                "col_Unit\u00e9ble",
+                "ix_Unit\u00e9ble",
             ),
             (
-                ue("\u6e2c\u8a66"),
-                ue("col_\u6e2c\u8a66"),
-                ue("ix_\u6e2c\u8a66"),
+                "\u6e2c\u8a66",
+                "col_\u6e2c\u8a66",
+                "ix_\u6e2c\u8a66",
             ),
         ]
 
diff --git a/test/engine/test_transaction.py b/test/engine/test_transaction.py
index e3be847e8..ca242c2c0 100644
--- a/test/engine/test_transaction.py
+++ b/test/engine/test_transaction.py
@@ -302,9 +302,8 @@ class TransactionTest(fixtures.TablesTest):
         savepoint = savepoint[0]
         assert not savepoint.is_active
 
-        if util.py3k:
-            # ensure cause comes from the DBAPI
-            assert isinstance(exc_.__cause__, testing.db.dialect.dbapi.Error)
+        # ensure cause comes from the DBAPI
+        assert isinstance(exc_.__cause__, testing.db.dialect.dbapi.Error)
 
     def test_retains_through_options(self, local_connection):
         connection = local_connection
diff --git a/test/ext/mypy/incremental/ticket_6435/enum_col_import2.py b/test/ext/mypy/incremental/ticket_6435/enum_col_import2.py
index 4f29932e5..161dce087 100644
--- a/test/ext/mypy/incremental/ticket_6435/enum_col_import2.py
+++ b/test/ext/mypy/incremental/ticket_6435/enum_col_import2.py
@@ -1,8 +1,10 @@
 from sqlalchemy import Column
 from sqlalchemy import Enum
-from sqlalchemy.orm import declarative_base, Mapped
+from sqlalchemy.orm import declarative_base
+from sqlalchemy.orm import Mapped
 from . import enum_col_import1
-from .enum_col_import1 import IntEnum, StrEnum
+from .enum_col_import1 import IntEnum
+from .enum_col_import1 import StrEnum
 
 Base = declarative_base()
 
diff --git a/test/ext/test_associationproxy.py b/test/ext/test_associationproxy.py
index ae5e6c848..93da104de 100644
--- a/test/ext/test_associationproxy.py
+++ b/test/ext/test_associationproxy.py
@@ -1,5 +1,7 @@
 import copy
 import pickle
+from unittest.mock import call
+from unittest.mock import Mock
 
 from sqlalchemy import cast
 from sqlalchemy import exc
@@ -35,8 +37,6 @@ from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
 from sqlalchemy.testing import is_false
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.util import gc_collect
diff --git a/test/ext/test_automap.py b/test/ext/test_automap.py
index eaafa3477..625bb8da2 100644
--- a/test/ext/test_automap.py
+++ b/test/ext/test_automap.py
@@ -1,6 +1,8 @@
 import random
 import threading
 import time
+from unittest.mock import Mock
+from unittest.mock import patch
 
 from sqlalchemy import create_engine
 from sqlalchemy import ForeignKey
@@ -19,8 +21,6 @@ from sqlalchemy.orm import Session
 from sqlalchemy.testing import assert_raises_message
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
-from sqlalchemy.testing.mock import Mock
-from sqlalchemy.testing.mock import patch
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from ..orm._fixtures import FixtureTest
diff --git a/test/ext/test_mutable.py b/test/ext/test_mutable.py
index 6545d4545..3370fa1b5 100644
--- a/test/ext/test_mutable.py
+++ b/test/ext/test_mutable.py
@@ -7,7 +7,6 @@ from sqlalchemy import func
 from sqlalchemy import Integer
 from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy import util
 from sqlalchemy.ext.mutable import MutableComposite
 from sqlalchemy.ext.mutable import MutableDict
 from sqlalchemy.ext.mutable import MutableList
@@ -573,44 +572,24 @@ class _MutableListTestBase(_MutableListTestFixture):
         # print(repr(pickles))
         # return
 
-        if util.py3k:
-            pickles = [
-                b"\x80\x04\x95<\x00\x00\x00\x00\x00\x00\x00\x8c\x16"
-                b"sqlalchemy.ext.mutable\x94\x8c\x0bMutableList\x94\x93\x94)"
-                b"\x81\x94(K\x01K\x02e]\x94(K\x01K\x02eb.",
-                b"ccopy_reg\n_reconstructor\np0\n(csqlalchemy.ext.mutable\n"
-                b"MutableList\np1\nc__builtin__\nlist\np2\n(lp3\nI1\naI2\n"
-                b"atp4\nRp5\n(lp6\nI1\naI2\nab.",
-                b"ccopy_reg\n_reconstructor\nq\x00(csqlalchemy.ext.mutable\n"
-                b"MutableList\nq\x01c__builtin__\nlist\nq\x02]q\x03(K\x01K"
-                b"\x02etq\x04Rq\x05]q\x06(K\x01K\x02eb.",
-                b"\x80\x02csqlalchemy.ext.mutable\nMutableList\nq\x00)\x81q"
-                b"\x01(K\x01K\x02e]q\x02(K\x01K\x02eb.",
-                b"\x80\x03csqlalchemy.ext.mutable\nMutableList\nq\x00)\x81q"
-                b"\x01(K\x01K\x02e]q\x02(K\x01K\x02eb.",
-                b"\x80\x04\x95<\x00\x00\x00\x00\x00\x00\x00\x8c\x16"
-                b"sqlalchemy.ext.mutable\x94\x8c\x0bMutableList\x94\x93\x94)"
-                b"\x81\x94(K\x01K\x02e]\x94(K\x01K\x02eb.",
-            ]
-        else:
-            pickles = [
-                "\x80\x02csqlalchemy.ext.mutable\nMutableList\nq\x00]q\x01"
-                "(K\x01K\x02e\x85q\x02Rq\x03.",
-                "\x80\x02csqlalchemy.ext.mutable\nMutableList"
-                "\nq\x00]q\x01(K\x01K\x02e\x85q\x02Rq\x03.",
-                "csqlalchemy.ext.mutable\nMutableList\np0\n"
-                "((lp1\nI1\naI2\natp2\nRp3\n.",
-                "csqlalchemy.ext.mutable\nMutableList\nq\x00(]"
-                "q\x01(K\x01K\x02etq\x02Rq\x03.",
-                "\x80\x02csqlalchemy.ext.mutable\nMutableList"
-                "\nq\x01]q\x02(K\x01K\x02e\x85Rq\x03.",
-                "\x80\x02csqlalchemy.ext.mutable\nMutableList\n"
-                "q\x01]q\x02(K\x01K\x02e\x85Rq\x03.",
-                "csqlalchemy.ext.mutable\nMutableList\np1\n"
-                "((lp2\nI1\naI2\natRp3\n.",
-                "csqlalchemy.ext.mutable\nMutableList\nq\x01"
-                "(]q\x02(K\x01K\x02etRq\x03.",
-            ]
+        pickles = [
+            b"\x80\x04\x95<\x00\x00\x00\x00\x00\x00\x00\x8c\x16"
+            b"sqlalchemy.ext.mutable\x94\x8c\x0bMutableList\x94\x93\x94)"
+            b"\x81\x94(K\x01K\x02e]\x94(K\x01K\x02eb.",
+            b"ccopy_reg\n_reconstructor\np0\n(csqlalchemy.ext.mutable\n"
+            b"MutableList\np1\nc__builtin__\nlist\np2\n(lp3\nI1\naI2\n"
+            b"atp4\nRp5\n(lp6\nI1\naI2\nab.",
+            b"ccopy_reg\n_reconstructor\nq\x00(csqlalchemy.ext.mutable\n"
+            b"MutableList\nq\x01c__builtin__\nlist\nq\x02]q\x03(K\x01K"
+            b"\x02etq\x04Rq\x05]q\x06(K\x01K\x02eb.",
+            b"\x80\x02csqlalchemy.ext.mutable\nMutableList\nq\x00)\x81q"
+            b"\x01(K\x01K\x02e]q\x02(K\x01K\x02eb.",
+            b"\x80\x03csqlalchemy.ext.mutable\nMutableList\nq\x00)\x81q"
+            b"\x01(K\x01K\x02e]q\x02(K\x01K\x02eb.",
+            b"\x80\x04\x95<\x00\x00\x00\x00\x00\x00\x00\x8c\x16"
+            b"sqlalchemy.ext.mutable\x94\x8c\x0bMutableList\x94\x93\x94)"
+            b"\x81\x94(K\x01K\x02e]\x94(K\x01K\x02eb.",
+        ]
 
         for pickle_ in pickles:
             obj = pickle.loads(pickle_)
diff --git a/test/ext/test_serializer.py b/test/ext/test_serializer.py
index 03ad96b3c..9a05e1fae 100644
--- a/test/ext/test_serializer.py
+++ b/test/ext/test_serializer.py
@@ -24,7 +24,6 @@ from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
-from sqlalchemy.util import ue
 
 
 def pickle_protocols():
@@ -195,7 +194,6 @@ class SerializeTest(AssertsCompiledSQL, fixtures.MappedTest):
             ],
         )
 
-    @testing.requires.non_broken_pickle
     def test_query_two(self):
         q = (
             Session.query(User)
@@ -206,7 +204,6 @@ class SerializeTest(AssertsCompiledSQL, fixtures.MappedTest):
         eq_(q2.all(), [User(name="fred")])
         eq_(list(q2.with_entities(User.id, User.name)), [(9, "fred")])
 
-    @testing.requires.non_broken_pickle
     def test_query_three(self):
         ua = aliased(User)
         q = (
@@ -233,7 +230,6 @@ class SerializeTest(AssertsCompiledSQL, fixtures.MappedTest):
             pickled_failing = serializer.dumps(j, prot)
             serializer.loads(pickled_failing, users.metadata, None)
 
-    @testing.requires.non_broken_pickle
     def test_orm_join(self):
         from sqlalchemy.orm.util import join
 
@@ -264,7 +260,6 @@ class SerializeTest(AssertsCompiledSQL, fixtures.MappedTest):
             [(u7, u8), (u7, u9), (u7, u10), (u8, u9), (u8, u10)],
         )
 
-    @testing.requires.non_broken_pickle
     def test_any(self):
         r = User.addresses.any(Address.email == "x")
         ser = serializer.dumps(r, -1)
@@ -273,20 +268,16 @@ class SerializeTest(AssertsCompiledSQL, fixtures.MappedTest):
 
     def test_unicode(self):
         m = MetaData()
-        t = Table(
-            ue("\u6e2c\u8a66"), m, Column(ue("\u6e2c\u8a66_id"), Integer)
-        )
+        t = Table("\u6e2c\u8a66", m, Column("\u6e2c\u8a66_id", Integer))
 
-        expr = select(t).where(t.c[ue("\u6e2c\u8a66_id")] == 5)
+        expr = select(t).where(t.c["\u6e2c\u8a66_id"] == 5)
 
         expr2 = serializer.loads(serializer.dumps(expr, -1), m)
 
         self.assert_compile(
             expr2,
-            ue(
-                'SELECT "\u6e2c\u8a66"."\u6e2c\u8a66_id" FROM "\u6e2c\u8a66" '
-                'WHERE "\u6e2c\u8a66"."\u6e2c\u8a66_id" = :\u6e2c\u8a66_id_1'
-            ),
+            'SELECT "\u6e2c\u8a66"."\u6e2c\u8a66_id" FROM "\u6e2c\u8a66" '
+            'WHERE "\u6e2c\u8a66"."\u6e2c\u8a66_id" = :\u6e2c\u8a66_id_1',
             dialect="default",
         )
 
diff --git a/test/orm/declarative/test_basic.py b/test/orm/declarative/test_basic.py
index f8cbdee36..902caca6f 100644
--- a/test/orm/declarative/test_basic.py
+++ b/test/orm/declarative/test_basic.py
@@ -10,7 +10,6 @@ from sqlalchemy import Integer
 from sqlalchemy import String
 from sqlalchemy import testing
 from sqlalchemy import UniqueConstraint
-from sqlalchemy import util
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import backref
 from sqlalchemy.orm import class_mapper
@@ -46,7 +45,6 @@ from sqlalchemy.testing import mock
 from sqlalchemy.testing.fixtures import fixture_session
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
-from sqlalchemy.util import with_metaclass
 
 
 Base = None
@@ -71,7 +69,7 @@ class DeclarativeTestBase(
         elif self.base_style == "explicit":
             mapper_registry = registry()
 
-            class Base(with_metaclass(DeclarativeMeta)):
+            class Base(metaclass=DeclarativeMeta):
                 __abstract__ = True
                 registry = mapper_registry
                 metadata = mapper_registry.metadata
@@ -252,7 +250,7 @@ class DeclarativeTest(DeclarativeTestBase):
                 "id", Integer, primary_key=True, test_needs_autoincrement=True
             )
             name = Column("name", String(50))
-            addresses = relationship(util.u("Address"), backref="user")
+            addresses = relationship("Address", backref="user")
 
         class Address(Base, fixtures.ComparableEntity):
             __tablename__ = "addresses"
@@ -288,7 +286,7 @@ class DeclarativeTest(DeclarativeTestBase):
             )
             user = relationship(
                 User,
-                backref=backref("addresses", order_by=util.u("Address.email")),
+                backref=backref("addresses", order_by="Address.email"),
             )
 
         assert Address.user.property.mapper.class_ is User
@@ -534,7 +532,7 @@ class DeclarativeTest(DeclarativeTestBase):
 
         # even though this class has an xyzzy attribute, getattr(cls,"xyzzy")
         # fails
-        class BrokenParent(with_metaclass(BrokenMeta)):
+        class BrokenParent(metaclass=BrokenMeta):
             xyzzy = "magic"
 
         # _as_declarative() inspects obj.__class__.__bases__
@@ -1076,7 +1074,7 @@ class DeclarativeTest(DeclarativeTestBase):
             r"registry is not a sqlalchemy.orm.registry\(\) object",
         ):
 
-            class Base(with_metaclass(DeclarativeMeta)):
+            class Base(metaclass=DeclarativeMeta):
                 metadata = sa.MetaData()
 
     def test_shared_class_registry(self):
@@ -1183,7 +1181,7 @@ class DeclarativeTest(DeclarativeTestBase):
         try:
             hasattr(User.addresses, "property")
         except exc.InvalidRequestError:
-            assert sa.util.compat.py3k
+            assert True
 
         # the exception is preserved.  Remains the
         # same through repeated calls.
diff --git a/test/orm/inheritance/test_relationship.py b/test/orm/inheritance/test_relationship.py
index d12cb1999..6d071a1e2 100644
--- a/test/orm/inheritance/test_relationship.py
+++ b/test/orm/inheritance/test_relationship.py
@@ -1,10 +1,11 @@
+from contextlib import nullcontext
+
 from sqlalchemy import ForeignKey
 from sqlalchemy import func
 from sqlalchemy import Integer
 from sqlalchemy import select
 from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy import util
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm import backref
 from sqlalchemy.orm import configure_mappers
@@ -2922,7 +2923,7 @@ class BetweenSubclassJoinWExtraJoinedLoad(
 
         with _aliased_join_warning(
             "Manager->managers"
-        ) if autoalias else util.nullcontext():
+        ) if autoalias else nullcontext():
             self.assert_compile(
                 q,
                 "SELECT people.type AS people_type, engineers.id AS "
diff --git a/test/orm/inheritance/test_single.py b/test/orm/inheritance/test_single.py
index fbafdd85b..93ec64304 100644
--- a/test/orm/inheritance/test_single.py
+++ b/test/orm/inheritance/test_single.py
@@ -1,3 +1,5 @@
+from contextlib import nullcontext
+
 from sqlalchemy import and_
 from sqlalchemy import ForeignKey
 from sqlalchemy import func
@@ -10,7 +12,6 @@ from sqlalchemy import select
 from sqlalchemy import String
 from sqlalchemy import testing
 from sqlalchemy import true
-from sqlalchemy import util
 from sqlalchemy.orm import aliased
 from sqlalchemy.orm import Bundle
 from sqlalchemy.orm import joinedload
@@ -1826,7 +1827,7 @@ class SingleFromPolySelectableTest(
 
         with _aliased_join_warning(
             "Engineer->engineer"
-        ) if autoalias else util.nullcontext():
+        ) if autoalias else nullcontext():
             self.assert_compile(
                 q,
                 "SELECT manager.id AS manager_id, employee.id AS employee_id, "
@@ -1891,7 +1892,7 @@ class SingleFromPolySelectableTest(
 
         with _aliased_join_warning(
             "Boss->manager"
-        ) if autoalias else util.nullcontext():
+        ) if autoalias else nullcontext():
             self.assert_compile(
                 q,
                 "SELECT engineer.id AS engineer_id, "
diff --git a/test/orm/test_attributes.py b/test/orm/test_attributes.py
index 4d0a1b03c..08de5d3d9 100644
--- a/test/orm/test_attributes.py
+++ b/test/orm/test_attributes.py
@@ -1,4 +1,6 @@
 import pickle
+from unittest.mock import call
+from unittest.mock import Mock
 
 from sqlalchemy import event
 from sqlalchemy import exc as sa_exc
@@ -17,8 +19,6 @@ from sqlalchemy.testing import is_false
 from sqlalchemy.testing import is_not
 from sqlalchemy.testing import is_true
 from sqlalchemy.testing import not_in
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.util import all_partial_orderings
 from sqlalchemy.testing.util import gc_collect
 
diff --git a/test/orm/test_bind.py b/test/orm/test_bind.py
index 417986338..11e34645d 100644
--- a/test/orm/test_bind.py
+++ b/test/orm/test_bind.py
@@ -1,3 +1,5 @@
+from unittest.mock import Mock
+
 import sqlalchemy as sa
 from sqlalchemy import delete
 from sqlalchemy import ForeignKey
@@ -23,7 +25,6 @@ from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
 from sqlalchemy.testing import mock
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from test.orm import _fixtures
diff --git a/test/orm/test_cascade.py b/test/orm/test_cascade.py
index c64c5a03a..51ed50255 100644
--- a/test/orm/test_cascade.py
+++ b/test/orm/test_cascade.py
@@ -7,7 +7,6 @@ from sqlalchemy import Integer
 from sqlalchemy import select
 from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy import util
 from sqlalchemy.orm import attributes
 from sqlalchemy.orm import backref
 from sqlalchemy.orm import class_mapper
@@ -170,7 +169,7 @@ class CascadeArgTest(fixtures.MappedTest):
         Address = self.classes.Address
 
         rel = relationship(Address)
-        rel.cascade = util.u("save-update, merge, expunge")
+        rel.cascade = "save-update, merge, expunge"
         eq_(rel.cascade, set(["save-update", "merge", "expunge"]))
 
 
diff --git a/test/orm/test_collection.py b/test/orm/test_collection.py
index ca14d7658..9babe6366 100644
--- a/test/orm/test_collection.py
+++ b/test/orm/test_collection.py
@@ -1,4 +1,5 @@
 import contextlib
+from functools import reduce
 from operator import and_
 
 from sqlalchemy import event
@@ -251,7 +252,7 @@ class CollectionsTest(OrderedDictFixture, fixtures.ORMTest):
             control[0] = e
             assert_eq()
 
-            if util.reduce(
+            if reduce(
                 and_,
                 [
                     hasattr(direct, a)
diff --git a/test/orm/test_deprecations.py b/test/orm/test_deprecations.py
index 962161f7b..fc0720ce6 100644
--- a/test/orm/test_deprecations.py
+++ b/test/orm/test_deprecations.py
@@ -1,3 +1,8 @@
+from contextlib import nullcontext
+import pickle
+from unittest.mock import call
+from unittest.mock import Mock
+
 import sqlalchemy as sa
 from sqlalchemy import and_
 from sqlalchemy import cast
@@ -21,7 +26,6 @@ from sqlalchemy import table
 from sqlalchemy import testing
 from sqlalchemy import text
 from sqlalchemy import true
-from sqlalchemy import util
 from sqlalchemy.engine import default
 from sqlalchemy.engine import result_tuple
 from sqlalchemy.orm import aliased
@@ -77,12 +81,9 @@ from sqlalchemy.testing import mock
 from sqlalchemy.testing.assertsql import CompiledSQL
 from sqlalchemy.testing.fixtures import ComparableEntity
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.util import resolve_lambda
-from sqlalchemy.util import pickle
 from . import _fixtures
 from .inheritance import _poly_fixtures
 from .inheritance._poly_fixtures import _Polymorphic
@@ -433,7 +434,6 @@ class PickleTest(fixtures.MappedTest):
         sess.expunge_all()
         return sess, User, Address, Dingaling
 
-    @testing.requires.non_broken_pickle
     def test_became_bound_options(self):
         sess, User, Address, Dingaling = self._option_test_fixture()
 
@@ -457,7 +457,6 @@ class PickleTest(fixtures.MappedTest):
         u1 = sess.query(User).options(opt).first()
         pickle.loads(pickle.dumps(u1))
 
-    @testing.requires.non_broken_pickle
     @testing.combinations(
         lambda: sa.orm.joinedload("addresses"),
         lambda: sa.orm.defer("name"),
@@ -477,7 +476,6 @@ class PickleTest(fixtures.MappedTest):
             u1 = sess.query(User).options(opt).first()
         pickle.loads(pickle.dumps(u1))
 
-    @testing.requires.non_broken_pickle
     @testing.combinations(
         lambda User: sa.orm.Load(User).joinedload("addresses"),
         lambda User: sa.orm.Load(User).joinedload("addresses").raiseload("*"),
@@ -8413,7 +8411,7 @@ class CollectionCascadesDespiteBackrefTest(fixtures.TestBase):
         b3 = B(key="b3")
 
         if future:
-            dep_ctx = util.nullcontext
+            dep_ctx = nullcontext
         else:
 
             def dep_ctx():
diff --git a/test/orm/test_events.py b/test/orm/test_events.py
index aa17f2b6c..3437d7942 100644
--- a/test/orm/test_events.py
+++ b/test/orm/test_events.py
@@ -1,3 +1,7 @@
+from unittest.mock import ANY
+from unittest.mock import call
+from unittest.mock import Mock
+
 import sqlalchemy as sa
 from sqlalchemy import delete
 from sqlalchemy import event
@@ -39,9 +43,6 @@ from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_not
 from sqlalchemy.testing.assertsql import CompiledSQL
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.testing.mock import ANY
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.util import gc_collect
diff --git a/test/orm/test_instrumentation.py b/test/orm/test_instrumentation.py
index 6b999f9f8..8f5455850 100644
--- a/test/orm/test_instrumentation.py
+++ b/test/orm/test_instrumentation.py
@@ -3,7 +3,6 @@ from sqlalchemy import event
 from sqlalchemy import ForeignKey
 from sqlalchemy import Integer
 from sqlalchemy import MetaData
-from sqlalchemy import util
 from sqlalchemy.orm import attributes
 from sqlalchemy.orm import class_mapper
 from sqlalchemy.orm import clear_mappers
@@ -655,39 +654,32 @@ class Py3KFunctionInstTest(fixtures.ORMTest):
 
         assert_raises(TypeError, cls, "a", "b", c="c")
 
+    def _kw_only_fixture(self):
+        class A(object):
+            def __init__(self, a, *, b, c):
+                self.a = a
+                self.b = b
+                self.c = c
 
-if util.py3k:
-    _locals = {}
-    exec(
-        """
-def _kw_only_fixture(self):
-    class A:
-        def __init__(self, a, *, b, c):
-            self.a = a
-            self.b = b
-            self.c = c
-    return self._instrument(A)
-
-def _kw_plus_posn_fixture(self):
-    class A:
-        def __init__(self, a, *args, b, c):
-            self.a = a
-            self.b = b
-            self.c = c
-    return self._instrument(A)
-
-def _kw_opt_fixture(self):
-    class A:
-        def __init__(self, a, *, b, c="c"):
-            self.a = a
-            self.b = b
-            self.c = c
-    return self._instrument(A)
-""",
-        _locals,
-    )
-    for k in _locals:
-        setattr(Py3KFunctionInstTest, k, _locals[k])
+        return self._instrument(A)
+
+    def _kw_plus_posn_fixture(self):
+        class A(object):
+            def __init__(self, a, *args, b, c):
+                self.a = a
+                self.b = b
+                self.c = c
+
+        return self._instrument(A)
+
+    def _kw_opt_fixture(self):
+        class A(object):
+            def __init__(self, a, *, b, c="c"):
+                self.a = a
+                self.b = b
+                self.c = c
+
+        return self._instrument(A)
 
 
 class MiscTest(fixtures.MappedTest):
diff --git a/test/orm/test_mapper.py b/test/orm/test_mapper.py
index 073f48119..e5e819bbb 100644
--- a/test/orm/test_mapper.py
+++ b/test/orm/test_mapper.py
@@ -256,7 +256,7 @@ class MapperTest(_fixtures.FixtureTest, AssertsCompiledSQL):
         try:
             hasattr(Address.user, "property")
         except sa.orm.exc.UnmappedClassError:
-            assert util.compat.py3k
+            assert True
 
         for i in range(3):
             assert_raises_message(
@@ -460,11 +460,7 @@ class MapperTest(_fixtures.FixtureTest, AssertsCompiledSQL):
         self.mapper(
             User,
             users,
-            properties={
-                util.u("addresses"): relationship(
-                    Address, backref=util.u("user")
-                )
-            },
+            properties={"addresses": relationship(Address, backref="user")},
         )
         u1 = User()
         a1 = Address()
diff --git a/test/orm/test_pickled.py b/test/orm/test_pickled.py
index 2072b60e3..4bccb5ee7 100644
--- a/test/orm/test_pickled.py
+++ b/test/orm/test_pickled.py
@@ -1,4 +1,5 @@
 import copy
+import pickle
 
 import sqlalchemy as sa
 from sqlalchemy import ForeignKey
@@ -34,7 +35,6 @@ from sqlalchemy.testing.pickleable import User
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.util import picklers
-from sqlalchemy.util import pickle
 from test.orm import _fixtures
 from .inheritance._poly_fixtures import _Polymorphic
 from .inheritance._poly_fixtures import Company
@@ -324,7 +324,6 @@ class PickleTest(fixtures.MappedTest):
         u2.addresses.append(Address())
         eq_(len(u2.addresses), 2)
 
-    @testing.requires.non_broken_pickle
     def test_instance_deferred_cols(self):
         users, addresses = (self.tables.users, self.tables.addresses)
 
@@ -495,7 +494,6 @@ class PickleTest(fixtures.MappedTest):
         u2 = state.obj()
         eq_(sa.inspect(u2).info["some_key"], "value")
 
-    @testing.requires.non_broken_pickle
     @testing.combinations(
         lambda User: sa.orm.joinedload(User.addresses),
         lambda User: sa.orm.defer(User.name),
@@ -515,7 +513,6 @@ class PickleTest(fixtures.MappedTest):
         u1 = sess.query(User).options(opt).first()
         pickle.loads(pickle.dumps(u1))
 
-    @testing.requires.non_broken_pickle
     @testing.combinations(
         lambda User: sa.orm.Load(User).joinedload(User.addresses),
         lambda User: sa.orm.Load(User)
@@ -542,7 +539,6 @@ class PickleTest(fixtures.MappedTest):
         u1 = sess.query(User).options(opt).first()
         pickle.loads(pickle.dumps(u1))
 
-    @testing.requires.non_broken_pickle
     def test_became_bound_options(self):
         sess, User, Address, Dingaling = self._option_test_fixture()
 
@@ -695,7 +691,6 @@ class PickleTest(fixtures.MappedTest):
 
 
 class OptionsTest(_Polymorphic):
-    @testing.requires.non_broken_pickle
     def test_options_of_type(self):
 
         with_poly = with_polymorphic(Person, [Engineer, Manager], flat=True)
diff --git a/test/orm/test_query.py b/test/orm/test_query.py
index 5bbe150c0..32a46463d 100644
--- a/test/orm/test_query.py
+++ b/test/orm/test_query.py
@@ -1,3 +1,4 @@
+import collections.abc as collections_abc
 import contextlib
 import functools
 
@@ -82,7 +83,6 @@ from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.types import NullType
 from sqlalchemy.types import TypeDecorator
-from sqlalchemy.util import collections_abc
 from test.orm import _fixtures
 
 
diff --git a/test/orm/test_scoping.py b/test/orm/test_scoping.py
index 1558da655..c5458f5ce 100644
--- a/test/orm/test_scoping.py
+++ b/test/orm/test_scoping.py
@@ -1,3 +1,5 @@
+from unittest.mock import Mock
+
 import sqlalchemy as sa
 from sqlalchemy import ForeignKey
 from sqlalchemy import Integer
@@ -13,7 +15,6 @@ from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
 from sqlalchemy.testing import mock
-from sqlalchemy.testing.mock import Mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 
diff --git a/test/orm/test_session.py b/test/orm/test_session.py
index c11897ea5..1b92da248 100644
--- a/test/orm/test_session.py
+++ b/test/orm/test_session.py
@@ -1,4 +1,5 @@
 import inspect as _py_inspect
+import pickle
 
 import sqlalchemy as sa
 from sqlalchemy import event
@@ -40,7 +41,6 @@ from sqlalchemy.testing.fixtures import fixture_session
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.testing.util import gc_collect
-from sqlalchemy.util import pickle
 from sqlalchemy.util.compat import inspect_getfullargspec
 from test.orm import _fixtures
 
diff --git a/test/orm/test_unitofwork.py b/test/orm/test_unitofwork.py
index 4ae842c4b..c0a347e24 100644
--- a/test/orm/test_unitofwork.py
+++ b/test/orm/test_unitofwork.py
@@ -32,8 +32,6 @@ from sqlalchemy.testing.fixtures import fixture_session
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from sqlalchemy.util import OrderedDict
-from sqlalchemy.util import u
-from sqlalchemy.util import ue
 from test.orm import _fixtures
 
 
@@ -124,7 +122,7 @@ class UnicodeTest(fixtures.MappedTest):
 
         self.mapper_registry.map_imperatively(Test, uni_t1)
 
-        txt = ue("\u0160\u0110\u0106\u010c\u017d")
+        txt = "\u0160\u0110\u0106\u010c\u017d"
         t1 = Test(id=1, txt=txt)
         self.assert_(t1.txt == txt)
 
@@ -147,7 +145,7 @@ class UnicodeTest(fixtures.MappedTest):
         )
         self.mapper_registry.map_imperatively(Test2, uni_t2)
 
-        txt = ue("\u0160\u0110\u0106\u010c\u017d")
+        txt = "\u0160\u0110\u0106\u010c\u017d"
         t1 = Test(txt=txt)
         t1.t2s.append(Test2())
         t1.t2s.append(Test2())
@@ -172,31 +170,31 @@ class UnicodeSchemaTest(fixtures.MappedTest):
             "unitable1",
             metadata,
             Column(
-                u("méil"),
+                "méil",
                 Integer,
                 primary_key=True,
                 key="a",
                 test_needs_autoincrement=True,
             ),
-            Column(ue("\u6e2c\u8a66"), Integer, key="b"),
+            Column("\u6e2c\u8a66", Integer, key="b"),
             Column("type", String(20)),
             test_needs_fk=True,
             test_needs_autoincrement=True,
         )
         t2 = Table(
-            u("Unitéble2"),
+            "Unitéble2",
             metadata,
             Column(
-                u("méil"),
+                "méil",
                 Integer,
                 primary_key=True,
                 key="cc",
                 test_needs_autoincrement=True,
             ),
             Column(
-                ue("\u6e2c\u8a66"), Integer, ForeignKey("unitable1.a"), key="d"
+                "\u6e2c\u8a66", Integer, ForeignKey("unitable1.a"), key="d"
             ),
-            Column(ue("\u6e2c\u8a66_2"), Integer, key="e"),
+            Column("\u6e2c\u8a66_2", Integer, key="e"),
             test_needs_fk=True,
             test_needs_autoincrement=True,
         )
@@ -3594,21 +3592,18 @@ class EnsurePKSortableTest(fixtures.MappedTest):
 
         a.data = "bar"
         b.data = "foo"
-        if sa.util.py3k:
-            message = (
-                r"Could not sort objects by primary key; primary key "
-                r"values must be sortable in Python \(was: '<' not "
-                r"supported between instances of 'MyNotSortableEnum'"
-                r" and 'MyNotSortableEnum'\)"
-            )
+        message = (
+            r"Could not sort objects by primary key; primary key "
+            r"values must be sortable in Python \(was: '<' not "
+            r"supported between instances of 'MyNotSortableEnum'"
+            r" and 'MyNotSortableEnum'\)"
+        )
 
-            assert_raises_message(
-                sa.exc.InvalidRequestError,
-                message,
-                s.flush,
-            )
-        else:
-            s.flush()
+        assert_raises_message(
+            sa.exc.InvalidRequestError,
+            message,
+            s.flush,
+        )
         s.close()
 
     def test_persistent_flush_sortable(self):
diff --git a/test/orm/test_unitofworkv2.py b/test/orm/test_unitofworkv2.py
index efd581db2..c93cc2edf 100644
--- a/test/orm/test_unitofworkv2.py
+++ b/test/orm/test_unitofworkv2.py
@@ -1,3 +1,6 @@
+from unittest.mock import Mock
+from unittest.mock import patch
+
 from sqlalchemy import cast
 from sqlalchemy import DateTime
 from sqlalchemy import event
@@ -34,8 +37,6 @@ from sqlalchemy.testing.assertsql import AllOf
 from sqlalchemy.testing.assertsql import CompiledSQL
 from sqlalchemy.testing.assertsql import Conditional
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.testing.mock import Mock
-from sqlalchemy.testing.mock import patch
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 from test.orm import _fixtures
diff --git a/test/orm/test_utils.py b/test/orm/test_utils.py
index 748ef152d..122524cc0 100644
--- a/test/orm/test_utils.py
+++ b/test/orm/test_utils.py
@@ -23,7 +23,6 @@ from sqlalchemy.testing import expect_warnings
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.util import compat
 from test.orm import _fixtures
 from .inheritance import _poly_fixtures
 
@@ -313,7 +312,7 @@ class AliasedClassTest(fixtures.MappedTest, AssertsCompiledSQL):
                     return cls.x
                 raise AttributeError(key)
 
-        class Point(compat.with_metaclass(MetaPoint)):
+        class Point(metaclass=MetaPoint):
             pass
 
         self._fixture(Point)
@@ -354,7 +353,7 @@ class AliasedClassTest(fixtures.MappedTest, AssertsCompiledSQL):
                     return cls._impl_double_x
                 raise AttributeError(key)
 
-        class Point(compat.with_metaclass(MetaPoint)):
+        class Point(metaclass=MetaPoint):
             @hybrid_property
             def _impl_double_x(self):
                 return self.x * 2
@@ -387,7 +386,7 @@ class AliasedClassTest(fixtures.MappedTest, AssertsCompiledSQL):
                     return double_x.__get__(None, cls)
                 raise AttributeError(key)
 
-        class Point(compat.with_metaclass(MetaPoint)):
+        class Point(metaclass=MetaPoint):
             pass
 
         self._fixture(Point)
diff --git a/test/orm/test_validators.py b/test/orm/test_validators.py
index 817d0fbc5..6b0fee49d 100644
--- a/test/orm/test_validators.py
+++ b/test/orm/test_validators.py
@@ -1,3 +1,6 @@
+from unittest.mock import call
+from unittest.mock import Mock
+
 from sqlalchemy import exc
 from sqlalchemy.orm import collections
 from sqlalchemy.orm import relationship
@@ -8,8 +11,6 @@ from sqlalchemy.testing import eq_
 from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import ne_
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.testing.mock import call
-from sqlalchemy.testing.mock import Mock
 from test.orm import _fixtures
 
 
diff --git a/test/orm/test_versioning.py b/test/orm/test_versioning.py
index 0d11f68a7..9d14ceba1 100644
--- a/test/orm/test_versioning.py
+++ b/test/orm/test_versioning.py
@@ -1,5 +1,6 @@
 import contextlib
 import datetime
+from unittest.mock import patch
 import uuid
 
 import sqlalchemy as sa
@@ -29,7 +30,6 @@ from sqlalchemy.testing import is_false
 from sqlalchemy.testing import is_true
 from sqlalchemy.testing.assertsql import CompiledSQL
 from sqlalchemy.testing.fixtures import fixture_session
-from sqlalchemy.testing.mock import patch
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
 
diff --git a/test/perf/invalidate_stresstest.py b/test/perf/invalidate_stresstest.py
index c7e1482c7..2e11b7ca9 100644
--- a/test/perf/invalidate_stresstest.py
+++ b/test/perf/invalidate_stresstest.py
@@ -1,5 +1,3 @@
-from __future__ import print_function
-
 import logging
 import random
 import sys
diff --git a/test/sql/test_compare.py b/test/sql/test_compare.py
index 814d9a2ad..af78ea19b 100644
--- a/test/sql/test_compare.py
+++ b/test/sql/test_compare.py
@@ -957,8 +957,7 @@ class CoreFixtures:
             .where(table_b_b.c.c > 10),
         )
 
-    if util.py37:
-        fixtures.append(_update_dml_w_dicts)
+    fixtures.append(_update_dml_w_dicts)
 
     def _lambda_fixtures():
         def one():
diff --git a/test/sql/test_compiler.py b/test/sql/test_compiler.py
index 23a2833ca..6779ea7bf 100644
--- a/test/sql/test_compiler.py
+++ b/test/sql/test_compiler.py
@@ -97,7 +97,6 @@ from sqlalchemy.testing import is_
 from sqlalchemy.testing import is_true
 from sqlalchemy.testing import mock
 from sqlalchemy.testing import ne_
-from sqlalchemy.util import u
 
 table1 = table(
     "mytable",
@@ -5002,10 +5001,10 @@ class DDLTest(fixtures.TestBase, AssertsCompiledSQL):
 
     def test_reraise_of_column_spec_issue_unicode(self):
         MyType = self._illegal_type_fixture()
-        t1 = Table("t", MetaData(), Column(u("méil"), MyType()))
+        t1 = Table("t", MetaData(), Column("méil", MyType()))
         assert_raises_message(
             exc.CompileError,
-            u(r"\(in table 't', column 'méil'\): Couldn't compile type"),
+            r"\(in table 't', column 'méil'\): Couldn't compile type",
             schema.CreateTable(t1).compile,
         )
 
diff --git a/test/sql/test_ddlemit.py b/test/sql/test_ddlemit.py
index 667891236..8e70ed9b4 100644
--- a/test/sql/test_ddlemit.py
+++ b/test/sql/test_ddlemit.py
@@ -1,3 +1,5 @@
+from unittest.mock import Mock
+
 from sqlalchemy import Column
 from sqlalchemy import ForeignKey
 from sqlalchemy import Index
@@ -9,7 +11,6 @@ from sqlalchemy import Table
 from sqlalchemy.sql.ddl import SchemaDropper
 from sqlalchemy.sql.ddl import SchemaGenerator
 from sqlalchemy.testing import fixtures
-from sqlalchemy.testing.mock import Mock
 
 
 class EmitDDLTest(fixtures.TestBase):
diff --git a/test/sql/test_deprecations.py b/test/sql/test_deprecations.py
index 89938ee5e..5828fbdcc 100644
--- a/test/sql/test_deprecations.py
+++ b/test/sql/test_deprecations.py
@@ -49,7 +49,6 @@ from sqlalchemy.testing import is_true
 from sqlalchemy.testing import mock
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
-from sqlalchemy.util import compat
 from .test_update import _UpdateFromTestBase
 
 
@@ -178,7 +177,7 @@ class DeprecationWarningsTest(fixtures.TestBase, AssertsCompiledSQL):
         obj = cls.__new__(cls)
         with mock.patch.object(cls, "_copy") as _copy:
             with testing.expect_deprecated(
-                r"The %s\(\) method is deprecated" % compat._qualname(cls.copy)
+                r"The %s\(\) method is deprecated" % cls.copy.__qualname__
             ):
                 obj.copy(schema="s", target_table="tt", arbitrary="arb")
 
diff --git a/test/sql/test_external_traversal.py b/test/sql/test_external_traversal.py
index e01ec0738..0ac73fc16 100644
--- a/test/sql/test_external_traversal.py
+++ b/test/sql/test_external_traversal.py
@@ -1,3 +1,4 @@
+import pickle
 import re
 
 from sqlalchemy import and_
@@ -44,7 +45,6 @@ from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import is_
 from sqlalchemy.testing import is_not
 from sqlalchemy.testing.schema import eq_clause_element
-from sqlalchemy.util import pickle
 
 A = B = t1 = t2 = t3 = table1 = table2 = table3 = table4 = None
 
diff --git a/test/sql/test_functions.py b/test/sql/test_functions.py
index 6c794717c..9378cfc38 100644
--- a/test/sql/test_functions.py
+++ b/test/sql/test_functions.py
@@ -1,6 +1,7 @@
 from copy import deepcopy
 import datetime
 import decimal
+import pickle
 
 from sqlalchemy import ARRAY
 from sqlalchemy import bindparam
@@ -26,7 +27,6 @@ from sqlalchemy import testing
 from sqlalchemy import Text
 from sqlalchemy import true
 from sqlalchemy import types as sqltypes
-from sqlalchemy import util
 from sqlalchemy.dialects import mysql
 from sqlalchemy.dialects import oracle
 from sqlalchemy.dialects import postgresql
@@ -510,7 +510,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
 
         # test pickling
         self.assert_compile(
-            util.pickle.loads(util.pickle.dumps(f1)),
+            pickle.loads(pickle.dumps(f1)),
             "my_func(:my_func_1, :my_func_2, NULL, :my_func_3)",
         )
 
@@ -533,7 +533,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
         f1 = func.row_number().over()
 
         self.assert_compile(
-            util.pickle.loads(util.pickle.dumps(f1)),
+            pickle.loads(pickle.dumps(f1)),
             "row_number() OVER ()",
         )
 
@@ -550,7 +550,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
         f1 = func.percentile_cont(literal(1)).within_group()
 
         self.assert_compile(
-            util.pickle.loads(util.pickle.dumps(f1)),
+            pickle.loads(pickle.dumps(f1)),
             "percentile_cont(:param_1) WITHIN GROUP (ORDER BY )",
         )
 
@@ -558,7 +558,7 @@ class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
             column("q"), column("p").desc()
         )
         self.assert_compile(
-            util.pickle.loads(util.pickle.dumps(f1)),
+            pickle.loads(pickle.dumps(f1)),
             "percentile_cont(:param_1) WITHIN GROUP (ORDER BY q, p DESC)",
         )
 
diff --git a/test/sql/test_operators.py b/test/sql/test_operators.py
index b86e8d075..831b75e7e 100644
--- a/test/sql/test_operators.py
+++ b/test/sql/test_operators.py
@@ -1,5 +1,7 @@
+import collections.abc as collections_abc
 import datetime
 import operator
+import pickle
 
 from sqlalchemy import and_
 from sqlalchemy import between
@@ -14,7 +16,6 @@ from sqlalchemy import or_
 from sqlalchemy import String
 from sqlalchemy import testing
 from sqlalchemy import text
-from sqlalchemy import util
 from sqlalchemy.dialects import mssql
 from sqlalchemy.dialects import mysql
 from sqlalchemy.dialects import oracle
@@ -677,7 +678,7 @@ class ExtensionOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL):
                     return self.op("->")(index)
 
         col = Column("x", MyType())
-        assert not isinstance(col, util.collections_abc.Iterable)
+        assert not isinstance(col, collections_abc.Iterable)
 
     def test_lshift(self):
         class MyType(UserDefinedType):
@@ -2234,11 +2235,11 @@ class ComparisonOperatorTest(fixtures.TestBase, testing.AssertsCompiledSQL):
             & self.table1.c.myid.between(15, 20)
             & self.table1.c.myid.like("hoho")
         )
-        eq_(str(clause), str(util.pickle.loads(util.pickle.dumps(clause))))
+        eq_(str(clause), str(pickle.loads(pickle.dumps(clause))))
 
     def test_pickle_operators_two(self):
         clause = tuple_(1, 2, 3)
-        eq_(str(clause), str(util.pickle.loads(util.pickle.dumps(clause))))
+        eq_(str(clause), str(pickle.loads(pickle.dumps(clause))))
 
     @testing.combinations(
         (operator.lt, "<", ">"),
diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py
index 9d4e14517..c5dd35ce1 100644
--- a/test/sql/test_resultset.py
+++ b/test/sql/test_resultset.py
@@ -1,7 +1,12 @@
 import collections
+import collections.abc as collections_abc
 from contextlib import contextmanager
 import csv
+from io import StringIO
 import operator
+import pickle
+from unittest.mock import Mock
+from unittest.mock import patch
 
 from sqlalchemy import CHAR
 from sqlalchemy import column
@@ -24,7 +29,6 @@ from sqlalchemy import true
 from sqlalchemy import tuple_
 from sqlalchemy import type_coerce
 from sqlalchemy import TypeDecorator
-from sqlalchemy import util
 from sqlalchemy import VARCHAR
 from sqlalchemy.engine import cursor as _cursor
 from sqlalchemy.engine import default
@@ -54,11 +58,8 @@ from sqlalchemy.testing import le_
 from sqlalchemy.testing import mock
 from sqlalchemy.testing import ne_
 from sqlalchemy.testing import not_in
-from sqlalchemy.testing.mock import Mock
-from sqlalchemy.testing.mock import patch
 from sqlalchemy.testing.schema import Column
 from sqlalchemy.testing.schema import Table
-from sqlalchemy.util import collections_abc
 
 
 class CursorResultTest(fixtures.TablesTest):
@@ -290,7 +291,7 @@ class CursorResultTest(fixtures.TablesTest):
             ],
         )
 
-        for pickle in False, True:
+        for use_pickle in False, True:
             for use_labels in False, True:
                 result = connection.execute(
                     users.select()
@@ -302,8 +303,8 @@ class CursorResultTest(fixtures.TablesTest):
                     )
                 ).fetchall()
 
-                if pickle:
-                    result = util.pickle.loads(util.pickle.dumps(result))
+                if use_pickle:
+                    result = pickle.loads(pickle.dumps(result))
 
                 eq_(result, [(7, "jack"), (8, "ed"), (9, "fred")])
                 if use_labels:
@@ -325,7 +326,7 @@ class CursorResultTest(fixtures.TablesTest):
 
                 # previously would warn
 
-                if pickle:
+                if use_pickle:
                     with expect_raises_message(
                         exc.NoSuchColumnError,
                         "Row was unpickled; lookup by ColumnElement is "
@@ -335,7 +336,7 @@ class CursorResultTest(fixtures.TablesTest):
                 else:
                     eq_(result[0]._mapping[users.c.user_id], 7)
 
-                if pickle:
+                if use_pickle:
                     with expect_raises_message(
                         exc.NoSuchColumnError,
                         "Row was unpickled; lookup by ColumnElement is "
@@ -972,7 +973,7 @@ class CursorResultTest(fixtures.TablesTest):
             lambda: r._mapping[fake_table.c.user_id],
         )
 
-        r = util.pickle.loads(util.pickle.dumps(r))
+        r = pickle.loads(pickle.dumps(r))
         assert_raises_message(
             exc.InvalidRequestError,
             "Ambiguous column name",
@@ -1605,7 +1606,7 @@ class CursorResultTest(fixtures.TablesTest):
             users.select().where(users.c.user_id == 1)
         ).fetchone()
 
-        s = util.StringIO()
+        s = StringIO()
         writer = csv.writer(s)
         # csv performs PySequenceCheck call
         writer.writerow(row)
diff --git a/test/sql/test_selectable.py b/test/sql/test_selectable.py
index f0df92b70..eca4623c4 100644
--- a/test/sql/test_selectable.py
+++ b/test/sql/test_selectable.py
@@ -1,4 +1,6 @@
 """Test various algorithmic properties of selectables."""
+from itertools import zip_longest
+
 from sqlalchemy import and_
 from sqlalchemy import bindparam
 from sqlalchemy import Boolean
@@ -627,7 +629,7 @@ class SelectableTest(
         """tests for #6808"""
         s1 = select(*cols_expr).select_from(*select_from)
 
-        for ff, efp in util.zip_longest(s1.get_final_froms(), exp_final_froms):
+        for ff, efp in zip_longest(s1.get_final_froms(), exp_final_froms):
             assert ff.compare(efp)
 
         eq_(s1.columns_clause_froms, exp_cc_froms)
diff --git a/test/sql/test_sequences.py b/test/sql/test_sequences.py
index c5c76ad08..d11961862 100644
--- a/test/sql/test_sequences.py
+++ b/test/sql/test_sequences.py
@@ -5,7 +5,6 @@ from sqlalchemy import MetaData
 from sqlalchemy import Sequence
 from sqlalchemy import String
 from sqlalchemy import testing
-from sqlalchemy import util
 from sqlalchemy.dialects import sqlite
 from sqlalchemy.schema import CreateSequence
 from sqlalchemy.schema import DropSequence
@@ -113,7 +112,7 @@ class SequenceExecTest(fixtures.TestBase):
     def _assert_seq_result(self, ret):
         """asserts return of next_value is an int"""
 
-        assert isinstance(ret, util.int_types)
+        assert isinstance(ret, int)
         assert ret >= testing.db.dialect.default_sequence_base
 
     def test_execute(self, connection):
diff --git a/test/sql/test_types.py b/test/sql/test_types.py
index 0891defc2..f63e1e01b 100644
--- a/test/sql/test_types.py
+++ b/test/sql/test_types.py
@@ -275,13 +275,13 @@ class AdaptTest(fixtures.TestBase):
         eq_(types.Integer().python_type, int)
         eq_(types.Numeric().python_type, decimal.Decimal)
         eq_(types.Numeric(asdecimal=False).python_type, float)
-        eq_(types.LargeBinary().python_type, util.binary_type)
+        eq_(types.LargeBinary().python_type, bytes)
         eq_(types.Float().python_type, float)
         eq_(types.Interval().python_type, datetime.timedelta)
         eq_(types.Date().python_type, datetime.date)
         eq_(types.DateTime().python_type, datetime.datetime)
         eq_(types.String().python_type, str)
-        eq_(types.Unicode().python_type, util.text_type)
+        eq_(types.Unicode().python_type, str)
         eq_(types.Enum("one", "two", "three").python_type, str)
 
         assert_raises(
@@ -624,8 +624,8 @@ class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest):
                 user_id=2,
                 goofy="jack",
                 goofy2="jack",
-                goofy4=util.u("jack"),
-                goofy7=util.u("jack"),
+                goofy4="jack",
+                goofy7="jack",
                 goofy8=12,
                 goofy9=12,
                 goofy10=12,
@@ -637,8 +637,8 @@ class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest):
                 user_id=3,
                 goofy="lala",
                 goofy2="lala",
-                goofy4=util.u("lala"),
-                goofy7=util.u("lala"),
+                goofy4="lala",
+                goofy7="lala",
                 goofy8=15,
                 goofy9=15,
                 goofy10=15,
@@ -650,8 +650,8 @@ class UserDefinedRoundTripTest(_UserDefinedTypeFixture, fixtures.TablesTest):
                 user_id=4,
                 goofy="fred",
                 goofy2="fred",
-                goofy4=util.u("fred"),
-                goofy7=util.u("fred"),
+                goofy4="fred",
+                goofy7="fred",
                 goofy8=9,
                 goofy9=9,
                 goofy10=9,
@@ -786,8 +786,8 @@ class BindProcessorInsertValuesTest(UserDefinedRoundTripTest):
                 user_id=2,
                 goofy="jack",
                 goofy2="jack",
-                goofy4=util.u("jack"),
-                goofy7=util.u("jack"),
+                goofy4="jack",
+                goofy7="jack",
                 goofy8=12,
                 goofy9=12,
                 goofy10=12,
@@ -798,8 +798,8 @@ class BindProcessorInsertValuesTest(UserDefinedRoundTripTest):
                 user_id=3,
                 goofy="lala",
                 goofy2="lala",
-                goofy4=util.u("lala"),
-                goofy7=util.u("lala"),
+                goofy4="lala",
+                goofy7="lala",
                 goofy8=15,
                 goofy9=15,
                 goofy10=15,
@@ -810,8 +810,8 @@ class BindProcessorInsertValuesTest(UserDefinedRoundTripTest):
                 user_id=4,
                 goofy="fred",
                 goofy2="fred",
-                goofy4=util.u("fred"),
-                goofy7=util.u("fred"),
+                goofy4="fred",
+                goofy7="fred",
                 goofy8=9,
                 goofy9=9,
                 goofy10=9,
@@ -3494,7 +3494,7 @@ class NumericRawSQLTest(fixtures.TestBase):
         metadata = self.metadata
         self._fixture(connection, metadata, Integer, 45)
         val = connection.exec_driver_sql("select val from t").scalar()
-        assert isinstance(val, util.int_types)
+        assert isinstance(val, int)
         eq_(val, 45)
 
     @testing.provide_metadata
diff --git a/test/sql/test_utils.py b/test/sql/test_utils.py
index 24a149ece..61777def5 100644
--- a/test/sql/test_utils.py
+++ b/test/sql/test_utils.py
@@ -1,3 +1,5 @@
+from itertools import zip_longest
+
 from sqlalchemy import Column
 from sqlalchemy import Integer
 from sqlalchemy import MetaData
@@ -5,7 +7,6 @@ from sqlalchemy import select
 from sqlalchemy import String
 from sqlalchemy import Table
 from sqlalchemy import testing
-from sqlalchemy import util
 from sqlalchemy.sql import base as sql_base
 from sqlalchemy.sql import coercions
 from sqlalchemy.sql import column
@@ -146,5 +147,5 @@ class MiscTest(fixtures.TestBase):
 
         unwrapped = sql_util.unwrap_order_by(expr)
 
-        for a, b in util.zip_longest(unwrapped, expected):
+        for a, b in zip_longest(unwrapped, expected):
             assert a is not None and a.compare(b)