mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-21 14:12:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Make str/str8 comparisons return True/False for !=/==.

Browse source 
Code that has been returning str8 becomes much more apparent thanks to this
(e.g., struct module returning str8 for all string-related formats or sqlite3
passing in str8 instances when converting objects that had a __conform__
method).  One also has to watch out in C code when making a key from char *
using PyString in the C code but a str instance in Python code as that will not
longer compare equal.

Once str8 gains a constructor like the current bytes type then
test_modulefinder needs a cleanup as the fix is a little messy in that file.

Thanks goes to Thomas Lee for writing the patch for the change giving an
initial run-down of why most of the tests were failing.
This commit is contained in:
Brett Cannon 2007-10-22 20:24:51 +00:00
parent 6464d47195
commit 4043001f5d
11 changed files with 167 additions and 203 deletions
Download patch file Download diff file Expand all files Collapse all files

13
Lib/modulefinder.py
View file

@ -16,12 +16,13 @@ else:
# remain compatible with Python < 2.3 # remain compatible with Python < 2.3
READ_MODE = "r" READ_MODE = "r"
LOAD_CONST = chr(dis.opname.index('LOAD_CONST')) # XXX Clean up once str8's cstor matches bytes.
IMPORT_NAME = chr(dis.opname.index('IMPORT_NAME')) LOAD_CONST = str8(chr(dis.opname.index('LOAD_CONST')))
STORE_NAME = chr(dis.opname.index('STORE_NAME')) IMPORT_NAME = str8(chr(dis.opname.index('IMPORT_NAME')))
STORE_GLOBAL = chr(dis.opname.index('STORE_GLOBAL')) STORE_NAME = str8(chr(dis.opname.index('STORE_NAME')))
STORE_GLOBAL = str8(chr(dis.opname.index('STORE_GLOBAL')))
STORE_OPS = [STORE_NAME, 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 # Modulefinder does a good job at simulating Python's, but it can not
# handle __path__ modifications packages make at runtime. Therefore there # handle __path__ modifications packages make at runtime. Therefore there
@ -367,7 +368,7 @@ class ModuleFinder:
consts = co.co_consts consts = co.co_consts
LOAD_LOAD_AND_IMPORT = LOAD_CONST + LOAD_CONST + IMPORT_NAME LOAD_LOAD_AND_IMPORT = LOAD_CONST + LOAD_CONST + IMPORT_NAME
while code: while code:
c = chr(code[0]) c = str8(chr(code[0]))
if c in STORE_OPS: if c in STORE_OPS:
oparg, = unpack('<H', code[1:3]) oparg, = unpack('<H', code[1:3])
yield "store", (names[oparg],) yield "store", (names[oparg],)

4
Lib/sqlite3/test/types.py
View file

@ -76,6 +76,10 @@ class SqliteTypeTests(unittest.TestCase):
class DeclTypesTests(unittest.TestCase): class DeclTypesTests(unittest.TestCase):
class Foo: class Foo:
def __init__(self, _val): 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 self.val = _val
def __cmp__(self, other): def __cmp__(self, other):

2
Lib/test/test_compile.py
View file

@ -157,7 +157,7 @@ if 1:
s256 = "".join(["\n"] * 256 + ["spam"]) s256 = "".join(["\n"] * 256 + ["spam"])
co = compile(s256, 'fn', 'exec') co = compile(s256, 'fn', 'exec')
self.assertEqual(co.co_firstlineno, 257) self.assertEqual(co.co_firstlineno, 257)
self.assertEqual(co.co_lnotab, '') self.assertEqual(co.co_lnotab, str8(''))
def test_literals_with_leading_zeroes(self): def test_literals_with_leading_zeroes(self):
for arg in ["077787", "0xj", "0x.", "0e", "090000000000000", for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",

245
Lib/test/test_format.py
View file

@ -39,163 +39,158 @@ def testformat(formatstr, args, output=None):
if verbose: if verbose:
print('yes') print('yes')
def testboth(formatstr, *args): testformat("%.1d", (1,), "1")
testformat(str8(formatstr), *args) testformat("%.*d", (sys.maxint,1)) # expect overflow
testformat(formatstr, *args) testformat("%.100d", (1,), '0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
testformat("%#.117x", (1,), '0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
testformat("%#.118x", (1,), '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001')
testformat("%f", (1.0,), "1.000000")
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")
# these are trying to test the limits of the internal magic-number-length # these are trying to test the limits of the internal magic-number-length
# formatting buffer, if that number changes then these tests are less # formatting buffer, if that number changes then these tests are less
# effective # effective
testboth("%#.*g", (109, -1.e+49/3.)) testformat("%#.*g", (109, -1.e+49/3.))
testboth("%#.*g", (110, -1.e+49/3.)) testformat("%#.*g", (110, -1.e+49/3.))
testboth("%#.*g", (110, -1.e+100/3.)) testformat("%#.*g", (110, -1.e+100/3.))
# test some ridiculously large precision, expect overflow # 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 # check for internal overflow validation on length of precision
overflowrequired = 1 overflowrequired = 1
testboth("%#.*g", (110, -1.e+100/3.)) testformat("%#.*g", (110, -1.e+100/3.))
testboth("%#.*G", (110, -1.e+100/3.)) testformat("%#.*G", (110, -1.e+100/3.))
testboth("%#.*f", (110, -1.e+100/3.)) testformat("%#.*f", (110, -1.e+100/3.))
testboth("%#.*F", (110, -1.e+100/3.)) testformat("%#.*F", (110, -1.e+100/3.))
overflowrequired = 0 overflowrequired = 0
# Formatting of long integers. Overflow is not ok # Formatting of long integers. Overflow is not ok
overflowok = 0 overflowok = 0
testboth("%x", 10, "a") testformat("%x", 10, "a")
testboth("%x", 100000000000, "174876e800") testformat("%x", 100000000000, "174876e800")
testboth("%o", 10, "12") testformat("%o", 10, "12")
testboth("%o", 100000000000, "1351035564000") testformat("%o", 100000000000, "1351035564000")
testboth("%d", 10, "10") testformat("%d", 10, "10")
testboth("%d", 100000000000, "100000000000") testformat("%d", 100000000000, "100000000000")
big = 123456789012345678901234567890 big = 123456789012345678901234567890
testboth("%d", big, "123456789012345678901234567890") testformat("%d", big, "123456789012345678901234567890")
testboth("%d", -big, "-123456789012345678901234567890") testformat("%d", -big, "-123456789012345678901234567890")
testboth("%5d", -big, "-123456789012345678901234567890") testformat("%5d", -big, "-123456789012345678901234567890")
testboth("%31d", -big, "-123456789012345678901234567890") testformat("%31d", -big, "-123456789012345678901234567890")
testboth("%32d", -big, " -123456789012345678901234567890") testformat("%32d", -big, " -123456789012345678901234567890")
testboth("%-32d", -big, "-123456789012345678901234567890 ") testformat("%-32d", -big, "-123456789012345678901234567890 ")
testboth("%032d", -big, "-0123456789012345678901234567890") testformat("%032d", -big, "-0123456789012345678901234567890")
testboth("%-032d", -big, "-123456789012345678901234567890 ") testformat("%-032d", -big, "-123456789012345678901234567890 ")
testboth("%034d", -big, "-000123456789012345678901234567890") testformat("%034d", -big, "-000123456789012345678901234567890")
testboth("%034d", big, "0000123456789012345678901234567890") testformat("%034d", big, "0000123456789012345678901234567890")
testboth("%0+34d", big, "+000123456789012345678901234567890") testformat("%0+34d", big, "+000123456789012345678901234567890")
testboth("%+34d", big, " +123456789012345678901234567890") testformat("%+34d", big, " +123456789012345678901234567890")
testboth("%34d", big, " 123456789012345678901234567890") testformat("%34d", big, " 123456789012345678901234567890")
testboth("%.2d", big, "123456789012345678901234567890") testformat("%.2d", big, "123456789012345678901234567890")
testboth("%.30d", big, "123456789012345678901234567890") testformat("%.30d", big, "123456789012345678901234567890")
testboth("%.31d", big, "0123456789012345678901234567890") testformat("%.31d", big, "0123456789012345678901234567890")
testboth("%32.31d", big, " 0123456789012345678901234567890") testformat("%32.31d", big, " 0123456789012345678901234567890")
big = 0x1234567890abcdef12345 # 21 hex digits big = 0x1234567890abcdef12345 # 21 hex digits
testboth("%x", big, "1234567890abcdef12345") testformat("%x", big, "1234567890abcdef12345")
testboth("%x", -big, "-1234567890abcdef12345") testformat("%x", -big, "-1234567890abcdef12345")
testboth("%5x", -big, "-1234567890abcdef12345") testformat("%5x", -big, "-1234567890abcdef12345")
testboth("%22x", -big, "-1234567890abcdef12345") testformat("%22x", -big, "-1234567890abcdef12345")
testboth("%23x", -big, " -1234567890abcdef12345") testformat("%23x", -big, " -1234567890abcdef12345")
testboth("%-23x", -big, "-1234567890abcdef12345 ") testformat("%-23x", -big, "-1234567890abcdef12345 ")
testboth("%023x", -big, "-01234567890abcdef12345") testformat("%023x", -big, "-01234567890abcdef12345")
testboth("%-023x", -big, "-1234567890abcdef12345 ") testformat("%-023x", -big, "-1234567890abcdef12345 ")
testboth("%025x", -big, "-0001234567890abcdef12345") testformat("%025x", -big, "-0001234567890abcdef12345")
testboth("%025x", big, "00001234567890abcdef12345") testformat("%025x", big, "00001234567890abcdef12345")
testboth("%0+25x", big, "+0001234567890abcdef12345") testformat("%0+25x", big, "+0001234567890abcdef12345")
testboth("%+25x", big, " +1234567890abcdef12345") testformat("%+25x", big, " +1234567890abcdef12345")
testboth("%25x", big, " 1234567890abcdef12345") testformat("%25x", big, " 1234567890abcdef12345")
testboth("%.2x", big, "1234567890abcdef12345") testformat("%.2x", big, "1234567890abcdef12345")
testboth("%.21x", big, "1234567890abcdef12345") testformat("%.21x", big, "1234567890abcdef12345")
testboth("%.22x", big, "01234567890abcdef12345") testformat("%.22x", big, "01234567890abcdef12345")
testboth("%23.22x", big, " 01234567890abcdef12345") testformat("%23.22x", big, " 01234567890abcdef12345")
testboth("%-23.22x", big, "01234567890abcdef12345 ") testformat("%-23.22x", big, "01234567890abcdef12345 ")
testboth("%X", big, "1234567890ABCDEF12345") testformat("%X", big, "1234567890ABCDEF12345")
testboth("%#X", big, "0X1234567890ABCDEF12345") testformat("%#X", big, "0X1234567890ABCDEF12345")
testboth("%#x", big, "0x1234567890abcdef12345") testformat("%#x", big, "0x1234567890abcdef12345")
testboth("%#x", -big, "-0x1234567890abcdef12345") testformat("%#x", -big, "-0x1234567890abcdef12345")
testboth("%#.23x", -big, "-0x001234567890abcdef12345") testformat("%#.23x", -big, "-0x001234567890abcdef12345")
testboth("%#+.23x", big, "+0x001234567890abcdef12345") testformat("%#+.23x", big, "+0x001234567890abcdef12345")
testboth("%# .23x", big, " 0x001234567890abcdef12345") testformat("%# .23x", big, " 0x001234567890abcdef12345")
testboth("%#+.23X", big, "+0X001234567890ABCDEF12345") testformat("%#+.23X", big, "+0X001234567890ABCDEF12345")
testboth("%#-+.23X", big, "+0X001234567890ABCDEF12345") testformat("%#-+.23X", big, "+0X001234567890ABCDEF12345")
testboth("%#-+26.23X", big, "+0X001234567890ABCDEF12345") testformat("%#-+26.23X", big, "+0X001234567890ABCDEF12345")
testboth("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ") testformat("%#-+27.23X", big, "+0X001234567890ABCDEF12345 ")
testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345") testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
# next one gets two leading zeroes from precision, and another from the # next one gets two leading zeroes from precision, and another from the
# 0 flag and the width # 0 flag and the width
testboth("%#+027.23X", big, "+0X0001234567890ABCDEF12345") testformat("%#+027.23X", big, "+0X0001234567890ABCDEF12345")
# same, except no 0 flag # same, except no 0 flag
testboth("%#+27.23X", big, " +0X001234567890ABCDEF12345") testformat("%#+27.23X", big, " +0X001234567890ABCDEF12345")
big = 0o12345670123456701234567012345670 # 32 octal digits big = 0o12345670123456701234567012345670 # 32 octal digits
testboth("%o", big, "12345670123456701234567012345670") testformat("%o", big, "12345670123456701234567012345670")
testboth("%o", -big, "-12345670123456701234567012345670") testformat("%o", -big, "-12345670123456701234567012345670")
testboth("%5o", -big, "-12345670123456701234567012345670") testformat("%5o", -big, "-12345670123456701234567012345670")
testboth("%33o", -big, "-12345670123456701234567012345670") testformat("%33o", -big, "-12345670123456701234567012345670")
testboth("%34o", -big, " -12345670123456701234567012345670") testformat("%34o", -big, " -12345670123456701234567012345670")
testboth("%-34o", -big, "-12345670123456701234567012345670 ") testformat("%-34o", -big, "-12345670123456701234567012345670 ")
testboth("%034o", -big, "-012345670123456701234567012345670") testformat("%034o", -big, "-012345670123456701234567012345670")
testboth("%-034o", -big, "-12345670123456701234567012345670 ") testformat("%-034o", -big, "-12345670123456701234567012345670 ")
testboth("%036o", -big, "-00012345670123456701234567012345670") testformat("%036o", -big, "-00012345670123456701234567012345670")
testboth("%036o", big, "000012345670123456701234567012345670") testformat("%036o", big, "000012345670123456701234567012345670")
testboth("%0+36o", big, "+00012345670123456701234567012345670") testformat("%0+36o", big, "+00012345670123456701234567012345670")
testboth("%+36o", big, " +12345670123456701234567012345670") testformat("%+36o", big, " +12345670123456701234567012345670")
testboth("%36o", big, " 12345670123456701234567012345670") testformat("%36o", big, " 12345670123456701234567012345670")
testboth("%.2o", big, "12345670123456701234567012345670") testformat("%.2o", big, "12345670123456701234567012345670")
testboth("%.32o", big, "12345670123456701234567012345670") testformat("%.32o", big, "12345670123456701234567012345670")
testboth("%.33o", big, "012345670123456701234567012345670") testformat("%.33o", big, "012345670123456701234567012345670")
testboth("%34.33o", big, " 012345670123456701234567012345670") testformat("%34.33o", big, " 012345670123456701234567012345670")
testboth("%-34.33o", big, "012345670123456701234567012345670 ") testformat("%-34.33o", big, "012345670123456701234567012345670 ")
testboth("%o", big, "12345670123456701234567012345670") testformat("%o", big, "12345670123456701234567012345670")
testboth("%#o", big, "0o12345670123456701234567012345670") testformat("%#o", big, "0o12345670123456701234567012345670")
testboth("%#o", -big, "-0o12345670123456701234567012345670") testformat("%#o", -big, "-0o12345670123456701234567012345670")
testboth("%#.34o", -big, "-0o0012345670123456701234567012345670") testformat("%#.34o", -big, "-0o0012345670123456701234567012345670")
testboth("%#+.34o", big, "+0o0012345670123456701234567012345670") testformat("%#+.34o", big, "+0o0012345670123456701234567012345670")
testboth("%# .34o", big, " 0o0012345670123456701234567012345670") testformat("%# .34o", big, " 0o0012345670123456701234567012345670")
testboth("%#-+.34o", big, "+0o0012345670123456701234567012345670") testformat("%#-+.34o", big, "+0o0012345670123456701234567012345670")
testboth("%#-+39.34o", big, "+0o0012345670123456701234567012345670 ") testformat("%#-+39.34o", big, "+0o0012345670123456701234567012345670 ")
testboth("%#+39.34o", big, " +0o0012345670123456701234567012345670") testformat("%#+39.34o", big, " +0o0012345670123456701234567012345670")
# next one gets one leading zero from precision # next one gets one leading zero from precision
testboth("%.33o", big, "012345670123456701234567012345670") testformat("%.33o", big, "012345670123456701234567012345670")
# one leading zero from precision # one leading zero from precision
testboth("%#.33o", big, "0o012345670123456701234567012345670") testformat("%#.33o", big, "0o012345670123456701234567012345670")
# leading zero vanishes # leading zero vanishes
testboth("%#.32o", big, "0o12345670123456701234567012345670") testformat("%#.32o", big, "0o12345670123456701234567012345670")
# one leading zero from precision, and another from '0' flag & width # 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 # 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 # 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). # Some small ints, in both Python int and long flavors).
testboth("%d", 42, "42") testformat("%d", 42, "42")
testboth("%d", -42, "-42") testformat("%d", -42, "-42")
testboth("%#x", 1, "0x1") testformat("%#x", 1, "0x1")
testboth("%#X", 1, "0X1") testformat("%#X", 1, "0X1")
testboth("%#o", 1, "0o1") testformat("%#o", 1, "0o1")
testboth("%#o", 1, "0o1") testformat("%#o", 1, "0o1")
testboth("%#o", 0, "0o0") testformat("%#o", 0, "0o0")
testboth("%#o", 0, "0o0") testformat("%#o", 0, "0o0")
testboth("%o", 0, "0") testformat("%o", 0, "0")
testboth("%d", 0, "0") testformat("%d", 0, "0")
testboth("%#x", 0, "0x0") testformat("%#x", 0, "0x0")
testboth("%#X", 0, "0X0") testformat("%#X", 0, "0X0")
testboth("%x", 0x42, "42") testformat("%x", 0x42, "42")
testboth("%x", -0x42, "-42") testformat("%x", -0x42, "-42")
testboth("%o", 0o42, "42") testformat("%o", 0o42, "42")
testboth("%o", -0o42, "-42") testformat("%o", -0o42, "-42")
testboth("%o", 0o42, "42") testformat("%o", 0o42, "42")
testboth("%o", -0o42, "-42") testformat("%o", -0o42, "-42")
# Test exception for unknown format characters # Test exception for unknown format characters
if verbose: if verbose:

42
Lib/test/test_str.py
View file

@ -36,34 +36,9 @@ class StrTest(
def __str__(self): def __str__(self):
return "foo" 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): class Foo7(str):
def __str__(self): def __str__(self):
return "foos" return "foos"
def __unicode__(self):
return "foou"
class Foo8(str): class Foo8(str):
def __new__(cls, content=""): def __new__(cls, content=""):
@ -71,24 +46,9 @@ class StrTest(
def __str__(self): def __str__(self):
return 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(Foo1()), "foo")
self.assertEqual(str(Foo2()), "foo") self.assertEqual(str(Foo7("bar")), "foos")
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(Foo8("foo")), "foofoo") 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): def test_expandtabs_overflows_gracefully(self):
# This test only affects 32-bit platforms because expandtabs can only take # This test only affects 32-bit platforms because expandtabs can only take

38
Lib/test/test_struct.py
View file

@ -101,7 +101,7 @@ s = struct.pack('ii', 1, 2)
simple_err(struct.unpack, 'iii', s) simple_err(struct.unpack, 'iii', s)
simple_err(struct.unpack, 'i', s) simple_err(struct.unpack, 'i', s)
c = 'a' c = str8('a')
b = 1 b = 1
h = 255 h = 255
i = 65535 i = 65535
@ -183,6 +183,10 @@ for fmt, arg, big, lil, asy in tests:
raise TestFailed("calcsize(%r) -> %d # expected %d" % ( raise TestFailed("calcsize(%r) -> %d # expected %d" % (
xfmt, n, len(res))) xfmt, n, len(res)))
rev = struct.unpack(xfmt, res)[0] 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: if rev != arg and not asy:
raise TestFailed("unpack(%r, %r) -> (%r,) # expected (%r,)" % ( raise TestFailed("unpack(%r, %r) -> (%r,) # expected (%r,)" % (
fmt, res, rev, arg)) fmt, res, rev, arg))
@ -424,14 +428,14 @@ for args in [("bB", 1),
def test_p_code(): def test_p_code():
for code, input, expected, expectedback in [ for code, input, expected, expectedback in [
('p','abc', '\x00', ''), ('p','abc', '\x00', str8('')),
('1p', 'abc', '\x00', ''), ('1p', 'abc', '\x00', str8('')),
('2p', 'abc', '\x01a', 'a'), ('2p', 'abc', '\x01a', str8('a')),
('3p', 'abc', '\x02ab', 'ab'), ('3p', 'abc', '\x02ab', str8('ab')),
('4p', 'abc', '\x03abc', 'abc'), ('4p', 'abc', '\x03abc', str8('abc')),
('5p', 'abc', '\x03abc\x00', 'abc'), ('5p', 'abc', '\x03abc\x00', str8('abc')),
('6p', 'abc', '\x03abc\x00\x00', 'abc'), ('6p', 'abc', '\x03abc\x00\x00', str8('abc')),
('1000p', 'x'*1000, '\xff' + 'x'*999, 'x'*255)]: ('1000p', 'x'*1000, '\xff' + 'x'*999, str8('x'*255))]:
expected = bytes(expected, "latin-1") expected = bytes(expected, "latin-1")
got = struct.pack(code, input) got = struct.pack(code, input)
if got != expected: if got != expected:
@ -560,20 +564,20 @@ def test_unpack_from():
if verbose: if verbose:
print("test_unpack_from using", cls.__name__) print("test_unpack_from using", cls.__name__)
data = cls(test_string) data = cls(test_string)
vereq(s.unpack_from(data), ('abcd',)) vereq(s.unpack_from(data), (str8('abcd'),))
vereq(s.unpack_from(data, 2), ('cd01',)) vereq(s.unpack_from(data, 2), (str8('cd01'),))
vereq(s.unpack_from(data, 4), ('0123',)) vereq(s.unpack_from(data, 4), (str8('0123'),))
for i in range(6): 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): for i in range(6, len(test_string) + 1):
simple_err(s.unpack_from, data, i) simple_err(s.unpack_from, data, i)
for cls in (str, str8, bytes): # XXX + memoryview for cls in (str, str8, bytes): # XXX + memoryview
data = cls(test_string) data = cls(test_string)
vereq(struct.unpack_from(fmt, data), ('abcd',)) vereq(struct.unpack_from(fmt, data), (str8('abcd'),))
vereq(struct.unpack_from(fmt, data, 2), ('cd01',)) vereq(struct.unpack_from(fmt, data, 2), (str8('cd01'),))
vereq(struct.unpack_from(fmt, data, 4), ('0123',)) vereq(struct.unpack_from(fmt, data, 4), (str8('0123'),))
for i in range(6): 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): for i in range(6, len(test_string) + 1):
simple_err(struct.unpack_from, fmt, data, i) simple_err(struct.unpack_from, fmt, data, i)

2
Lib/test/test_subprocess.py
View file

@ -24,7 +24,7 @@ else:
# shutdown time. That frustrates tests trying to check stderr produced # shutdown time. That frustrates tests trying to check stderr produced
# from a spawned Python process. # from a spawned Python process.
def remove_stderr_debug_decorations(stderr): 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): class ProcessTestCase(unittest.TestCase):
def setUp(self): def setUp(self):

4
Lib/test/test_unicode.py
View file

@ -200,6 +200,10 @@ class UnicodeTest(
self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1) self.checkequalnofix('one@two!three!', 'one!two!three!', 'replace', '!', '@', 1)
self.assertRaises(TypeError, 'replace'.replace, "r", 42) 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): def test_comparison(self):
# Comparisons: # Comparisons:
self.assertEqual('abc', 'abc') self.assertEqual('abc', 'abc')

6
Misc/NEWS
View file

@ -11,6 +11,12 @@ What's New in Python 3.0a2?
Core and Builtins 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, - Replaced `PyFile_FromFile()` with `PyFile_FromFd(fd, name. mode, buffer,
encoding, newline)` encoding, newline)`

4
Modules/_sqlite/cursor.c
View file

@ -182,7 +182,7 @@ int pysqlite_build_row_cast_map(pysqlite_Cursor* self)
if (*pos == '[') { if (*pos == '[') {
type_start = pos + 1; type_start = pos + 1;
} else if (*pos == ']' && type_start != (const char*)-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) { if (!key) {
/* creating a string failed, but it is too complicated /* creating a string failed, but it is too complicated
* to propagate the error here, we just assume there is * to propagate the error here, we just assume there is
@ -203,7 +203,7 @@ int pysqlite_build_row_cast_map(pysqlite_Cursor* self)
if (decltype) { if (decltype) {
for (pos = decltype;;pos++) { for (pos = decltype;;pos++) {
if (*pos == ' ' || *pos == 0) { if (*pos == ' ' || *pos == 0) {
py_decltype = PyString_FromStringAndSize(decltype, pos - decltype); py_decltype = PyUnicode_FromStringAndSize(decltype, pos - decltype);
if (!py_decltype) { if (!py_decltype) {
return -1; return -1;
} }

10
Objects/unicodeobject.c
View file

@ -6224,16 +6224,6 @@ int PyUnicode_Compare(PyObject *left,
if (PyUnicode_Check(left) && PyUnicode_Check(right)) if (PyUnicode_Check(left) && PyUnicode_Check(right))
return unicode_compare((PyUnicodeObject *)left, return unicode_compare((PyUnicodeObject *)left,
(PyUnicodeObject *)right); (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, PyErr_Format(PyExc_TypeError,
"Can't compare %.100s and %.100s", "Can't compare %.100s and %.100s",
left->ob_type->tp_name, left->ob_type->tp_name,