[Python-3000-checkins] r58596 - in python/branches/py3k: Lib/modulefinder.py Lib/sqlite3/test/types.py Lib/test/test_compile.py Lib/test/test_format.py Lib/test/test_str.py Lib/test/test_struct.py Lib/test/test_subprocess.py Lib/test/test_unicode.py Misc/NEWS Modules/_sqlite/cursor.c Objects/unicodeobject.c
brett.cannon
python-3000-checkins at python.org
Mon Oct 22 22:24:52 CEST 2007
Author: brett.cannon
Date: Mon Oct 22 22:24:51 2007
New Revision: 58596
Modified:
python/branches/py3k/Lib/modulefinder.py
python/branches/py3k/Lib/sqlite3/test/types.py
python/branches/py3k/Lib/test/test_compile.py
python/branches/py3k/Lib/test/test_format.py
python/branches/py3k/Lib/test/test_str.py
python/branches/py3k/Lib/test/test_struct.py
python/branches/py3k/Lib/test/test_subprocess.py
python/branches/py3k/Lib/test/test_unicode.py
python/branches/py3k/Misc/NEWS
python/branches/py3k/Modules/_sqlite/cursor.c
python/branches/py3k/Objects/unicodeobject.c
Log:
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.
Modified: python/branches/py3k/Lib/modulefinder.py
==============================================================================
--- python/branches/py3k/Lib/modulefinder.py (original)
+++ python/branches/py3k/Lib/modulefinder.py Mon Oct 22 22:24:51 2007
@@ -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],)
Modified: python/branches/py3k/Lib/sqlite3/test/types.py
==============================================================================
--- python/branches/py3k/Lib/sqlite3/test/types.py (original)
+++ python/branches/py3k/Lib/sqlite3/test/types.py Mon Oct 22 22:24:51 2007
@@ -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):
Modified: python/branches/py3k/Lib/test/test_compile.py
==============================================================================
--- python/branches/py3k/Lib/test/test_compile.py (original)
+++ python/branches/py3k/Lib/test/test_compile.py Mon Oct 22 22:24:51 2007
@@ -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",
Modified: python/branches/py3k/Lib/test/test_format.py
==============================================================================
--- python/branches/py3k/Lib/test/test_format.py (original)
+++ python/branches/py3k/Lib/test/test_format.py Mon Oct 22 22:24:51 2007
@@ -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")
-
-testboth("%x", 0x42, "42")
-testboth("%x", -0x42, "-42")
-
-testboth("%o", 0o42, "42")
-testboth("%o", -0o42, "-42")
-testboth("%o", 0o42, "42")
-testboth("%o", -0o42, "-42")
+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")
+
+testformat("%x", 0x42, "42")
+testformat("%x", -0x42, "-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:
Modified: python/branches/py3k/Lib/test/test_str.py
==============================================================================
--- python/branches/py3k/Lib/test/test_str.py (original)
+++ python/branches/py3k/Lib/test/test_str.py Mon Oct 22 22:24:51 2007
@@ -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
Modified: python/branches/py3k/Lib/test/test_struct.py
==============================================================================
--- python/branches/py3k/Lib/test/test_struct.py (original)
+++ python/branches/py3k/Lib/test/test_struct.py Mon Oct 22 22:24:51 2007
@@ -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)
Modified: python/branches/py3k/Lib/test/test_subprocess.py
==============================================================================
--- python/branches/py3k/Lib/test/test_subprocess.py (original)
+++ python/branches/py3k/Lib/test/test_subprocess.py Mon Oct 22 22:24:51 2007
@@ -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):
Modified: python/branches/py3k/Lib/test/test_unicode.py
==============================================================================
--- python/branches/py3k/Lib/test/test_unicode.py (original)
+++ python/branches/py3k/Lib/test/test_unicode.py Mon Oct 22 22:24:51 2007
@@ -200,6 +200,10 @@
self.checkequalnofix('one at 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')
Modified: python/branches/py3k/Misc/NEWS
==============================================================================
--- python/branches/py3k/Misc/NEWS (original)
+++ python/branches/py3k/Misc/NEWS Mon Oct 22 22:24:51 2007
@@ -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)`
Modified: python/branches/py3k/Modules/_sqlite/cursor.c
==============================================================================
--- python/branches/py3k/Modules/_sqlite/cursor.c (original)
+++ python/branches/py3k/Modules/_sqlite/cursor.c Mon Oct 22 22:24:51 2007
@@ -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;
}
Modified: python/branches/py3k/Objects/unicodeobject.c
==============================================================================
--- python/branches/py3k/Objects/unicodeobject.c (original)
+++ python/branches/py3k/Objects/unicodeobject.c Mon Oct 22 22:24:51 2007
@@ -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,
More information about the Python-3000-checkins
mailing list