mirror of https://github.com/python/cpython
Make str/str8 comparisons return True/False for !=/==.
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
parent
6464d47195
commit
4043001f5d
|
|
@ -16,12 +16,13 @@ else:
|
|||
# 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 @@ class ModuleFinder:
|
|||
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],)
|
||||
|
|
|
|||
|
|
@ -76,6 +76,10 @@ class SqliteTypeTests(unittest.TestCase):
|
|||
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):
|
||||
|
|
|
|||
|
|
@ -157,7 +157,7 @@ if 1:
|
|||
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",
|
||||
|
|
|
|||
|
|
@ -39,163 +39,158 @@ def testformat(formatstr, args, output=None):
|
|||
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:
|
||||
|
|
|
|||
|
|
@ -36,34 +36,9 @@ class StrTest(
|
|||
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 @@ class StrTest(
|
|||
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
|
||||
|
|
|
|||
|
|
@ -101,7 +101,7 @@ s = struct.pack('ii', 1, 2)
|
|||
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 @@ for fmt, arg, big, lil, asy in tests:
|
|||
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 @@ for args in [("bB", 1),
|
|||
|
||||
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 @@ def test_unpack_from():
|
|||
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)
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ else:
|
|||
# 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):
|
||||
|
|
|
|||
|
|
@ -200,6 +200,10 @@ class UnicodeTest(
|
|||
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')
|
||||
|
|
|
|||
|
|
@ -11,6 +11,12 @@ What's New in Python 3.0a2?
|
|||
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)`
|
||||
|
||||
|
|
|
|||
|
|
@ -182,7 +182,7 @@ int pysqlite_build_row_cast_map(pysqlite_Cursor* self)
|
|||
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 @@ int pysqlite_build_row_cast_map(pysqlite_Cursor* self)
|
|||
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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6224,16 +6224,6 @@ int PyUnicode_Compare(PyObject *left,
|
|||
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,
|
||||
|
|
|
|||
Loading…
Reference in New Issue