Clean up most py3k compat

Change-Id: I8172fdcc3103ff92aa049827728484c8779af6b7

12 files changed, 120 insertions, 151 deletions

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://")