diff --git a/Lib/modulefinder.py b/Lib/modulefinder.py
index 1dbc5bb..cd9906c 100644
--- a/Lib/modulefinder.py
+++ b/Lib/modulefinder.py
@@ -16,12 +16,13 @@
     # remain compatible with Python  < 2.3
     READ_MODE = "r"
 
-LOAD_CONST = chr(dis.opname.index('LOAD_CONST'))
-IMPORT_NAME = chr(dis.opname.index('IMPORT_NAME'))
-STORE_NAME = chr(dis.opname.index('STORE_NAME'))
-STORE_GLOBAL = chr(dis.opname.index('STORE_GLOBAL'))
+# XXX Clean up once str8's cstor matches bytes.
+LOAD_CONST = str8(chr(dis.opname.index('LOAD_CONST')))
+IMPORT_NAME = str8(chr(dis.opname.index('IMPORT_NAME')))
+STORE_NAME = str8(chr(dis.opname.index('STORE_NAME')))
+STORE_GLOBAL = str8(chr(dis.opname.index('STORE_GLOBAL')))
 STORE_OPS = [STORE_NAME, STORE_GLOBAL]
-HAVE_ARGUMENT = chr(dis.HAVE_ARGUMENT)
+HAVE_ARGUMENT = str8(chr(dis.HAVE_ARGUMENT))
 
 # Modulefinder does a good job at simulating Python's, but it can not
 # handle __path__ modifications packages make at runtime.  Therefore there
@@ -367,7 +368,7 @@
         consts = co.co_consts
         LOAD_LOAD_AND_IMPORT = LOAD_CONST + LOAD_CONST + IMPORT_NAME
         while code:
-            c = chr(code[0])
+            c = str8(chr(code[0]))
             if c in STORE_OPS:
                 oparg, = unpack('<H', code[1:3])
                 yield "store", (names[oparg],)
diff --git a/Lib/sqlite3/test/types.py b/Lib/sqlite3/test/types.py
index 1377835..4ff948d 100644
--- a/Lib/sqlite3/test/types.py
+++ b/Lib/sqlite3/test/types.py
@@ -76,6 +76,10 @@
 class DeclTypesTests(unittest.TestCase):
     class Foo:
         def __init__(self, _val):
+            if isinstance(_val, str8):
+                # sqlite3 always calls __init__ with a str8 created from a
+                # UTF-8 string when __conform__ was used to store the object.
+                _val = _val.decode('utf8')
             self.val = _val
 
         def __cmp__(self, other):
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 0bdd036..d6a51dd 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -157,7 +157,7 @@
         s256 = "".join(["\n"] * 256 + ["spam"])
         co = compile(s256, 'fn', 'exec')
         self.assertEqual(co.co_firstlineno, 257)
-        self.assertEqual(co.co_lnotab, '')
+        self.assertEqual(co.co_lnotab, str8(''))
 
     def test_literals_with_leading_zeroes(self):
         for arg in ["077787", "0xj", "0x.", "0e",  "090000000000000",
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
index 4c3d36e..0b02adf 100644
--- a/Lib/test/test_format.py
+++ b/Lib/test/test_format.py
@@ -39,163 +39,158 @@
             if verbose:
                 print('yes')
 
-def testboth(formatstr, *args):
-    testformat(str8(formatstr), *args)
-    testformat(formatstr, *args)
+testformat("%.1d", (1,), "1")
+testformat("%.*d", (sys.maxint,1))  # expect overflow
+testformat("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
+testformat("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
+testformat("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
 
-
-testboth("%.1d", (1,), "1")
-testboth("%.*d", (sys.maxint,1))  # expect overflow
-testboth("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-testboth("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-testboth("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
-
-testboth("%f", (1.0,), "1.000000")
+testformat("%f", (1.0,), "1.000000")
 # these are trying to test the limits of the internal magic-number-length
 # formatting buffer, if that number changes then these tests are less
 # effective
-testboth("%#.*g", (109, -1.e+49/3.))
-testboth("%#.*g", (110, -1.e+49/3.))
-testboth("%#.*g", (110, -1.e+100/3.))
+testformat("%#.*g", (109, -1.e+49/3.))
+testformat("%#.*g", (110, -1.e+49/3.))
+testformat("%#.*g", (110, -1.e+100/3.))
 
 # test some ridiculously large precision, expect overflow
-testboth('%12.*f', (123456, 1.0))
+testformat('%12.*f', (123456, 1.0))
 
 # check for internal overflow validation on length of precision
 overflowrequired = 1
-testboth("%#.*g", (110, -1.e+100/3.))
-testboth("%#.*G", (110, -1.e+100/3.))
-testboth("%#.*f", (110, -1.e+100/3.))
-testboth("%#.*F", (110, -1.e+100/3.))
+testformat("%#.*g", (110, -1.e+100/3.))
+testformat("%#.*G", (110, -1.e+100/3.))
+testformat("%#.*f", (110, -1.e+100/3.))
+testformat("%#.*F", (110, -1.e+100/3.))
 overflowrequired = 0
 
 # Formatting of long integers. Overflow is not ok
 overflowok = 0
-testboth("%x", 10, "a")
-testboth("%x", 100000000000, "174876e800")
-testboth("%o", 10, "12")
-testboth("%o", 100000000000, "1351035564000")
-testboth("%d", 10, "10")
-testboth("%d", 100000000000, "100000000000")
+testformat("%x", 10, "a")
+testformat("%x", 100000000000, "174876e800")
+testformat("%o", 10, "12")
+testformat("%o", 100000000000, "1351035564000")
+testformat("%d", 10, "10")
+testformat("%d", 100000000000, "100000000000")
 
 big = 123456789012345678901234567890
-testboth("%d", big, "123456789012345678901234567890")
-testboth("%d", -big, "-123456789012345678901234567890")
-testboth("%5d", -big, "-123456789012345678901234567890")
-testboth("%31d", -big, "-123456789012345678901234567890")
-testboth("%32d", -big, " -123456789012345678901234567890")
-testboth("%-32d", -big, "-123456789012345678901234567890 ")
-testboth("%032d", -big, "-0123456789012345678901234567890")
-testboth("%-032d", -big, "-123456789012345678901234567890 ")
-testboth("%034d", -big, "-000123456789012345678901234567890")
-testboth("%034d", big, "0000123456789012345678901234567890")
-testboth("%0+34d", big, "+000123456789012345678901234567890")
-testboth("%+34d", big, "   +123456789012345678901234567890")
-testboth("%34d", big, "    123456789012345678901234567890")
-testboth("%.2d", big, "123456789012345678901234567890")
-testboth("%.30d", big, "123456789012345678901234567890")
-testboth("%.31d", big, "0123456789012345678901234567890")
-testboth("%32.31d", big, " 0123456789012345678901234567890")
+testformat("%d", big, "123456789012345678901234567890")
+testformat("%d", -big, "-123456789012345678901234567890")
+testformat("%5d", -big, "-123456789012345678901234567890")
+testformat("%31d", -big, "-123456789012345678901234567890")
+testformat("%32d", -big, " -123456789012345678901234567890")
+testformat("%-32d", -big, "-123456789012345678901234567890 ")
+testformat("%032d", -big, "-0123456789012345678901234567890")
+testformat("%-032d", -big, "-123456789012345678901234567890 ")
+testformat("%034d", -big, "-000123456789012345678901234567890")
+testformat("%034d", big, "0000123456789012345678901234567890")
+testformat("%0+34d", big, "+000123456789012345678901234567890")
+testformat("%+34d", big, "   +123456789012345678901234567890")
+testformat("%34d", big, "    123456789012345678901234567890")
+testformat("%.2d", big, "123456789012345678901234567890")
+testformat("%.30d", big, "123456789012345678901234567890")
+testformat("%.31d", big, "0123456789012345678901234567890")
+testformat("%32.31d", big, " 0123456789012345678901234567890")
 
 big = 0x1234567890abcdef12345  # 21 hex digits
-testboth("%x", big, "1234567890abcdef12345")
-testboth("%x", -big, "-1234567890abcdef12345")
-testboth("%5x", -big, "-1234567890abcdef12345")
-testboth("%22x", -big, "-1234567890abcdef12345")
-testboth("%23x", -big, " -1234567890abcdef12345")
-testboth("%-23x", -big, "-1234567890abcdef12345 ")
-testboth("%023x", -big, "-01234567890abcdef12345")
-testboth("%-023x", -big, "-1234567890abcdef12345 ")
-testboth("%025x", -big, "-0001234567890abcdef12345")
-testboth("%025x", big, "00001234567890abcdef12345")
-testboth("%0+25x", big, "+0001234567890abcdef12345")
-testboth("%+25x", big, "   +1234567890abcdef12345")
-testboth("%25x", big, "    1234567890abcdef12345")
-testboth("%.2x", big, "1234567890abcdef12345")
-testboth("%.21x", big, "1234567890abcdef12345")
-testboth("%.22x", big, "01234567890abcdef12345")
-testboth("%23.22x", big, " 01234567890abcdef12345")
-testboth("%-23.22x", big, "01234567890abcdef12345 ")
-testboth("%X", big, "1234567890ABCDEF12345")
-testboth("%#X", big, "0X1234567890ABCDEF12345")
-testboth("%#x", big, "0x1234567890abcdef12345")
-testboth("%#x", -big, "-0x1234567890abcdef12345")
-testboth("%#.23x", -big, "-0x001234567890abcdef12345")
-testboth("%#+.23x", big, "+0x001234567890abcdef12345")
-testboth("%# .23x", big, " 0x001234567890abcdef12345")
-testboth("%#+.23X", big, "+0X001234567890ABCDEF12345")
-testboth("%#-+.23X", big, "+0X001234567890ABCDEF12345")
-testboth("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
-testboth("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
-testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
+testformat("%x", big, "1234567890abcdef12345")
+testformat("%x", -big, "-1234567890abcdef12345")
+testformat("%5x", -big, "-1234567890abcdef12345")
+testformat("%22x", -big, "-1234567890abcdef12345")
+testformat("%23x", -big, " -1234567890abcdef12345")
+testformat("%-23x", -big, "-1234567890abcdef12345 ")
+testformat("%023x", -big, "-01234567890abcdef12345")
+testformat("%-023x", -big, "-1234567890abcdef12345 ")
+testformat("%025x", -big, "-0001234567890abcdef12345")
+testformat("%025x", big, "00001234567890abcdef12345")
+testformat("%0+25x", big, "+0001234567890abcdef12345")
+testformat("%+25x", big, "   +1234567890abcdef12345")
+testformat("%25x", big, "    1234567890abcdef12345")
+testformat("%.2x", big, "1234567890abcdef12345")
+testformat("%.21x", big, "1234567890abcdef12345")
+testformat("%.22x", big, "01234567890abcdef12345")
+testformat("%23.22x", big, " 01234567890abcdef12345")
+testformat("%-23.22x", big, "01234567890abcdef12345 ")
+testformat("%X", big, "1234567890ABCDEF12345")
+testformat("%#X", big, "0X1234567890ABCDEF12345")
+testformat("%#x", big, "0x1234567890abcdef12345")
+testformat("%#x", -big, "-0x1234567890abcdef12345")
+testformat("%#.23x", -big, "-0x001234567890abcdef12345")
+testformat("%#+.23x", big, "+0x001234567890abcdef12345")
+testformat("%# .23x", big, " 0x001234567890abcdef12345")
+testformat("%#+.23X", big, "+0X001234567890ABCDEF12345")
+testformat("%#-+.23X", big, "+0X001234567890ABCDEF12345")
+testformat("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
+testformat("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
+testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
 # next one gets two leading zeroes from precision, and another from the
 # 0 flag and the width
-testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
+testformat("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
 # same, except no 0 flag
-testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345")
+testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
 
 big = 0o12345670123456701234567012345670  # 32 octal digits
-testboth("%o", big, "12345670123456701234567012345670")
-testboth("%o", -big, "-12345670123456701234567012345670")
-testboth("%5o", -big, "-12345670123456701234567012345670")
-testboth("%33o", -big, "-12345670123456701234567012345670")
-testboth("%34o", -big, " -12345670123456701234567012345670")
-testboth("%-34o", -big, "-12345670123456701234567012345670 ")
-testboth("%034o", -big, "-012345670123456701234567012345670")
-testboth("%-034o", -big, "-12345670123456701234567012345670 ")
-testboth("%036o", -big, "-00012345670123456701234567012345670")
-testboth("%036o", big, "000012345670123456701234567012345670")
-testboth("%0+36o", big, "+00012345670123456701234567012345670")
-testboth("%+36o", big, "   +12345670123456701234567012345670")
-testboth("%36o", big, "    12345670123456701234567012345670")
-testboth("%.2o", big, "12345670123456701234567012345670")
-testboth("%.32o", big, "12345670123456701234567012345670")
-testboth("%.33o", big, "012345670123456701234567012345670")
-testboth("%34.33o", big, " 012345670123456701234567012345670")
-testboth("%-34.33o", big, "012345670123456701234567012345670 ")
-testboth("%o", big, "12345670123456701234567012345670")
-testboth("%#o", big, "0o12345670123456701234567012345670")
-testboth("%#o", -big, "-0o12345670123456701234567012345670")
-testboth("%#.34o", -big, "-0o0012345670123456701234567012345670")
-testboth("%#+.34o", big, "+0o0012345670123456701234567012345670")
-testboth("%# .34o", big, " 0o0012345670123456701234567012345670")
-testboth("%#-+.34o", big, "+0o0012345670123456701234567012345670")
-testboth("%#-+39.34o", big, "+0o0012345670123456701234567012345670  ")
-testboth("%#+39.34o", big, "  +0o0012345670123456701234567012345670")
+testformat("%o", big, "12345670123456701234567012345670")
+testformat("%o", -big, "-12345670123456701234567012345670")
+testformat("%5o", -big, "-12345670123456701234567012345670")
+testformat("%33o", -big, "-12345670123456701234567012345670")
+testformat("%34o", -big, " -12345670123456701234567012345670")
+testformat("%-34o", -big, "-12345670123456701234567012345670 ")
+testformat("%034o", -big, "-012345670123456701234567012345670")
+testformat("%-034o", -big, "-12345670123456701234567012345670 ")
+testformat("%036o", -big, "-00012345670123456701234567012345670")
+testformat("%036o", big, "000012345670123456701234567012345670")
+testformat("%0+36o", big, "+00012345670123456701234567012345670")
+testformat("%+36o", big, "   +12345670123456701234567012345670")
+testformat("%36o", big, "    12345670123456701234567012345670")
+testformat("%.2o", big, "12345670123456701234567012345670")
+testformat("%.32o", big, "12345670123456701234567012345670")
+testformat("%.33o", big, "012345670123456701234567012345670")
+testformat("%34.33o", big, " 012345670123456701234567012345670")
+testformat("%-34.33o", big, "012345670123456701234567012345670 ")
+testformat("%o", big, "12345670123456701234567012345670")
+testformat("%#o", big, "0o12345670123456701234567012345670")
+testformat("%#o", -big, "-0o12345670123456701234567012345670")
+testformat("%#.34o", -big, "-0o0012345670123456701234567012345670")
+testformat("%#+.34o", big, "+0o0012345670123456701234567012345670")
+testformat("%# .34o", big, " 0o0012345670123456701234567012345670")
+testformat("%#-+.34o", big, "+0o0012345670123456701234567012345670")
+testformat("%#-+39.34o", big, "+0o0012345670123456701234567012345670  ")
+testformat("%#+39.34o", big, "  +0o0012345670123456701234567012345670")
 # next one gets one leading zero from precision
-testboth("%.33o", big, "012345670123456701234567012345670")
+testformat("%.33o", big, "012345670123456701234567012345670")
 # one leading zero from precision
-testboth("%#.33o", big, "0o012345670123456701234567012345670")
+testformat("%#.33o", big, "0o012345670123456701234567012345670")
 # leading zero vanishes
-testboth("%#.32o", big, "0o12345670123456701234567012345670")
+testformat("%#.32o", big, "0o12345670123456701234567012345670")
 # one leading zero from precision, and another from '0' flag & width
-testboth("%034.33o", big, "0012345670123456701234567012345670")
+testformat("%034.33o", big, "0012345670123456701234567012345670")
 # max width includes base marker; padding zeroes come after marker
-testboth("%0#38.33o", big, "0o000012345670123456701234567012345670")
+testformat("%0#38.33o", big, "0o000012345670123456701234567012345670")
 # padding spaces come before marker
-testboth("%#36.33o", big, " 0o012345670123456701234567012345670")
+testformat("%#36.33o", big, " 0o012345670123456701234567012345670")
 
 # Some small ints, in both Python int and long flavors).
-testboth("%d", 42, "42")
-testboth("%d", -42, "-42")
-testboth("%#x", 1, "0x1")
-testboth("%#X", 1, "0X1")
-testboth("%#o", 1, "0o1")
-testboth("%#o", 1, "0o1")
-testboth("%#o", 0, "0o0")
-testboth("%#o", 0, "0o0")
-testboth("%o", 0, "0")
-testboth("%d", 0, "0")
-testboth("%#x", 0, "0x0")
-testboth("%#X", 0, "0X0")
+testformat("%d", 42, "42")
+testformat("%d", -42, "-42")
+testformat("%#x", 1, "0x1")
+testformat("%#X", 1, "0X1")
+testformat("%#o", 1, "0o1")
+testformat("%#o", 1, "0o1")
+testformat("%#o", 0, "0o0")
+testformat("%#o", 0, "0o0")
+testformat("%o", 0, "0")
+testformat("%d", 0, "0")
+testformat("%#x", 0, "0x0")
+testformat("%#X", 0, "0X0")
 
-testboth("%x", 0x42, "42")
-testboth("%x", -0x42, "-42")
+testformat("%x", 0x42, "42")
+testformat("%x", -0x42, "-42")
 
-testboth("%o", 0o42, "42")
-testboth("%o", -0o42, "-42")
-testboth("%o", 0o42, "42")
-testboth("%o", -0o42, "-42")
+testformat("%o", 0o42, "42")
+testformat("%o", -0o42, "-42")
+testformat("%o", 0o42, "42")
+testformat("%o", -0o42, "-42")
 
 # Test exception for unknown format characters
 if verbose:
diff --git a/Lib/test/test_str.py b/Lib/test/test_str.py
index ad118d6..1d02467 100644
--- a/Lib/test/test_str.py
+++ b/Lib/test/test_str.py
@@ -36,34 +36,9 @@
             def __str__(self):
                 return "foo"
 
-        class Foo2(object):
-            def __str__(self):
-                return "foo"
-
-        class Foo3(object):
-            def __str__(self):
-                return "foo"
-
-        class Foo4(str8):
-            def __str__(self):
-                return "foo"
-
-        class Foo5(str):
-            def __unicode__(self):
-                return "foo"
-
-        class Foo6(str8):
-            def __str__(self):
-                return "foos"
-
-            def __unicode__(self):
-                return "foou"
-
         class Foo7(str):
             def __str__(self):
                 return "foos"
-            def __unicode__(self):
-                return "foou"
 
         class Foo8(str):
             def __new__(cls, content=""):
@@ -71,24 +46,9 @@
             def __str__(self):
                 return self
 
-        class Foo9(str8):
-            def __str__(self):
-                return "string"
-            def __unicode__(self):
-                return "not unicode"
-
         self.assertEqual(str(Foo1()), "foo")
-        self.assertEqual(str(Foo2()), "foo")
-        self.assertEqual(str(Foo3()), "foo")
-        self.assertEqual(str(Foo4("bar")), "foo")
-        self.assertEqual(str(Foo5("bar")), "foo")
-        self.assertEqual(str8(Foo6("bar")), "foos")
-        self.assertEqual(str(Foo6("bar")), "foou")
-        self.assertEqual(str8(Foo7("bar")), "foos")
-        self.assertEqual(str(Foo7("bar")), "foou")
+        self.assertEqual(str(Foo7("bar")), "foos")
         self.assertEqual(str(Foo8("foo")), "foofoo")
-        self.assertEqual(str8(Foo9("foo")), "string")
-        self.assertEqual(str(Foo9("foo")), "not unicode")
 
     def test_expandtabs_overflows_gracefully(self):
         # This test only affects 32-bit platforms because expandtabs can only take
diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py
index cc6db32..7942045 100644
--- a/Lib/test/test_struct.py
+++ b/Lib/test/test_struct.py
@@ -101,7 +101,7 @@
 simple_err(struct.unpack, 'iii', s)
 simple_err(struct.unpack, 'i', s)
 
-c = 'a'
+c = str8('a')
 b = 1
 h = 255
 i = 65535
@@ -183,6 +183,10 @@
             raise TestFailed("calcsize(%r) -> %d # expected %d" % (
                 xfmt, n, len(res)))
         rev = struct.unpack(xfmt, res)[0]
+        if isinstance(arg, str):
+            # Strings are returned as str8 since you can't know the encoding of
+            # the string when packed.
+            arg = str8(arg)
         if rev != arg and not asy:
             raise TestFailed("unpack(%r, %r) -> (%r,) # expected (%r,)" % (
                 fmt, res, rev, arg))
@@ -424,14 +428,14 @@
 
 def test_p_code():
     for code, input, expected, expectedback in [
-            ('p','abc', '\x00', ''),
-            ('1p', 'abc', '\x00', ''),
-            ('2p', 'abc', '\x01a', 'a'),
-            ('3p', 'abc', '\x02ab', 'ab'),
-            ('4p', 'abc', '\x03abc', 'abc'),
-            ('5p', 'abc', '\x03abc\x00', 'abc'),
-            ('6p', 'abc', '\x03abc\x00\x00', 'abc'),
-            ('1000p', 'x'*1000, '\xff' + 'x'*999, 'x'*255)]:
+            ('p','abc', '\x00', str8('')),
+            ('1p', 'abc', '\x00', str8('')),
+            ('2p', 'abc', '\x01a', str8('a')),
+            ('3p', 'abc', '\x02ab', str8('ab')),
+            ('4p', 'abc', '\x03abc', str8('abc')),
+            ('5p', 'abc', '\x03abc\x00', str8('abc')),
+            ('6p', 'abc', '\x03abc\x00\x00', str8('abc')),
+            ('1000p', 'x'*1000, '\xff' + 'x'*999, str8('x'*255))]:
         expected = bytes(expected, "latin-1")
         got = struct.pack(code, input)
         if got != expected:
@@ -560,20 +564,20 @@
         if verbose:
             print("test_unpack_from using", cls.__name__)
         data = cls(test_string)
-        vereq(s.unpack_from(data), ('abcd',))
-        vereq(s.unpack_from(data, 2), ('cd01',))
-        vereq(s.unpack_from(data, 4), ('0123',))
+        vereq(s.unpack_from(data), (str8('abcd'),))
+        vereq(s.unpack_from(data, 2), (str8('cd01'),))
+        vereq(s.unpack_from(data, 4), (str8('0123'),))
         for i in range(6):
-            vereq(s.unpack_from(data, i), (data[i:i+4],))
+            vereq(s.unpack_from(data, i), (str8(data[i:i+4]),))
         for i in range(6, len(test_string) + 1):
             simple_err(s.unpack_from, data, i)
     for cls in (str, str8, bytes): # XXX + memoryview
         data = cls(test_string)
-        vereq(struct.unpack_from(fmt, data), ('abcd',))
-        vereq(struct.unpack_from(fmt, data, 2), ('cd01',))
-        vereq(struct.unpack_from(fmt, data, 4), ('0123',))
+        vereq(struct.unpack_from(fmt, data), (str8('abcd'),))
+        vereq(struct.unpack_from(fmt, data, 2), (str8('cd01'),))
+        vereq(struct.unpack_from(fmt, data, 4), (str8('0123'),))
         for i in range(6):
-            vereq(struct.unpack_from(fmt, data, i), (data[i:i+4],))
+            vereq(struct.unpack_from(fmt, data, i), (str8(data[i:i+4]),))
         for i in range(6, len(test_string) + 1):
             simple_err(struct.unpack_from, fmt, data, i)
 
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 3c92675..fea98dc 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -24,7 +24,7 @@
 # shutdown time.  That frustrates tests trying to check stderr produced
 # from a spawned Python process.
 def remove_stderr_debug_decorations(stderr):
-    return re.sub(r"\[\d+ refs\]\r?\n?$", "", str8(stderr))
+    return re.sub(r"\[\d+ refs\]\r?\n?$", "", str(stderr))
 
 class ProcessTestCase(unittest.TestCase):
     def setUp(self):
diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py
index d33643a..04dddaa 100644
--- a/Lib/test/test_unicode.py
+++ b/Lib/test/test_unicode.py
@@ -200,6 +200,10 @@
         self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
         self.assertRaises(TypeError, 'replace'.replace, "r", 42)
 
+    def test_str8_comparison(self):
+        self.assertEqual('abc' == str8('abc'), False)
+        self.assertEqual('abc' != str8('abc'), True)
+
     def test_comparison(self):
         # Comparisons:
         self.assertEqual('abc', 'abc')
diff --git a/Misc/NEWS b/Misc/NEWS
index 86c5a59..c0fe108 100644
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -11,6 +11,12 @@
 Core and Builtins
 -----------------
 
+- Comparisons between str and str8 now return False/True for ==/!=.  sqlite3
+  returns str8 when recreating on object from it's __conform__ value.  The
+  struct module returns str8 for all string-related formats.  This was true
+  before this change, but becomes more apparent thanks to string comparisons
+  always being False.
+
 - Replaced `PyFile_FromFile()` with `PyFile_FromFd(fd, name. mode, buffer, 
   encoding, newline)`
 
diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c
index 3894ec6..c789faf 100644
--- a/Modules/_sqlite/cursor.c
+++ b/Modules/_sqlite/cursor.c
@@ -182,7 +182,7 @@
                     if (*pos == '[') {
                         type_start = pos + 1;
                     } else if (*pos == ']' && type_start != (const char*)-1) {
-                        key = PyString_FromStringAndSize(type_start, pos - type_start);
+                        key = PyUnicode_FromStringAndSize(type_start, pos - type_start);
                         if (!key) {
                             /* creating a string failed, but it is too complicated
                              * to propagate the error here, we just assume there is
@@ -203,7 +203,7 @@
             if (decltype) {
                 for (pos = decltype;;pos++) {
                     if (*pos == ' ' || *pos == 0) {
-                        py_decltype = PyString_FromStringAndSize(decltype, pos - decltype);
+                        py_decltype = PyUnicode_FromStringAndSize(decltype, pos - decltype);
                         if (!py_decltype) {
                             return -1;
                         }
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index fed2ff5..13644b0 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -6224,16 +6224,6 @@
     if (PyUnicode_Check(left) && PyUnicode_Check(right))
         return unicode_compare((PyUnicodeObject *)left,
                                (PyUnicodeObject *)right);
-    if ((PyString_Check(left) && PyUnicode_Check(right)) ||
-        (PyUnicode_Check(left) && PyString_Check(right))) {
-        if (PyUnicode_Check(left))
-            left = _PyUnicode_AsDefaultEncodedString(left, NULL);
-        if (PyUnicode_Check(right))
-            right = _PyUnicode_AsDefaultEncodedString(right, NULL);
-        assert(PyString_Check(left));
-        assert(PyString_Check(right));
-        return PyObject_Compare(left, right);
-    }
     PyErr_Format(PyExc_TypeError,
                  "Can't compare %.100s and %.100s",
                  left->ob_type->tp_name,