[pypy-commit] pypy py3k-fix-strategies: adapt tests, progress
pjenvey
noreply at buildbot.pypy.org
Fri Apr 18 02:43:10 CEST 2014
Author: Philip Jenvey <pjenvey at underboss.org>
Branch: py3k-fix-strategies
Changeset: r70736:ec5e5a6abac5
Date: 2014-04-17 17:40 -0700
http://bitbucket.org/pypy/pypy/changeset/ec5e5a6abac5/
Log: adapt tests, progress
diff --git a/pypy/interpreter/argument.py b/pypy/interpreter/argument.py
--- a/pypy/interpreter/argument.py
+++ b/pypy/interpreter/argument.py
@@ -351,7 +351,7 @@
limit -= len(self.keyword_names_w)
for i in range(len(self.keywords)):
if i < limit:
- w_key = space.wrap(self.keywords[i])
+ w_key = space.wrap(self.keywords[i].decode('utf-8'))
else:
w_key = self.keyword_names_w[i - limit]
space.setitem(w_kwds, w_key, self.keywords_w[i])
@@ -446,7 +446,7 @@
break
else:
if i < limit:
- w_key = space.wrap(keywords[i])
+ w_key = space.wrap(keywords[i].decode('utf-8'))
else:
w_key = keyword_names_w[i - limit]
space.setitem(w_kwds, w_key, keywords_w[i])
diff --git a/pypy/objspace/std/dictmultiobject.py b/pypy/objspace/std/dictmultiobject.py
--- a/pypy/objspace/std/dictmultiobject.py
+++ b/pypy/objspace/std/dictmultiobject.py
@@ -55,9 +55,9 @@
elif space.config.objspace.std.withmapdict and instance:
from pypy.objspace.std.mapdict import MapDictStrategy
strategy = space.fromcache(MapDictStrategy)
- #elif instance or strdict or module:
- # assert w_type is None
- # strategy = space.fromcache(BytesDictStrategy)
+ elif instance or strdict or module:
+ assert w_type is None
+ strategy = space.fromcache(UnicodeDictStrategy)
elif kwargs:
assert w_type is None
from pypy.objspace.std.kwargsdict import EmptyKwargsDictStrategy
@@ -119,6 +119,7 @@
byteslist = space.listview_bytes(w_keys)
if byteslist is not None:
for key in byteslist:
+ # XXX: bytes is tied to setitem_str here!
w_dict.setitem_str(key, w_fill)
else:
for w_key in space.listview(w_keys):
@@ -430,18 +431,18 @@
return self.erase(None)
def switch_to_correct_strategy(self, w_dict, w_key):
+ from pypy.objspace.std.intobject import W_IntObject
withidentitydict = self.space.config.objspace.std.withidentitydict
- # if type(w_key) is self.space.StringObjectCls:
- # self.switch_to_bytes_strategy(w_dict)
- # return
+ if type(w_key) is self.space.StringObjectCls:
+ self.switch_to_bytes_strategy(w_dict)
+ return
if type(w_key) is self.space.UnicodeObjectCls:
self.switch_to_unicode_strategy(w_dict)
return
+ if type(w_key) is W_IntObject:
+ self.switch_to_int_strategy(w_dict)
+ return
w_type = self.space.type(w_key)
- # XXX: disable IntDictStrategy for now, because in py3k ints are
- # actually long
- ## if self.space.is_w(w_type, self.space.w_int):
- ## self.switch_to_int_strategy(w_dict)
if withidentitydict and w_type.compares_by_identity():
self.switch_to_identity_strategy(w_dict)
else:
@@ -700,6 +701,8 @@
def setitem_str(self, w_dict, key, w_value):
self.switch_to_object_strategy(w_dict)
+ # XXX: wrap(key) means we only allow ascii to
+ # setitem_str. should probaby allow utf-8
w_dict.setitem(self.space.wrap(key), w_value)
def setdefault(self, w_dict, w_key, w_default):
@@ -722,6 +725,8 @@
return len(self.unerase(w_dict.dstorage))
def getitem_str(self, w_dict, key):
+ # XXX: wrapping here caused some issues w/
+ # ByteDictStrat.. double check
return self.getitem(w_dict, self.space.wrap(key))
def getitem(self, w_dict, w_key):
@@ -819,6 +824,7 @@
return self.space.wrap(unwrapped)
def unwrap(self, wrapped):
+ # XXX: bytes_w
return self.space.str_w(wrapped)
def is_correct_type(self, w_obj):
@@ -833,23 +839,23 @@
def _never_equal_to(self, w_lookup_type):
return _never_equal_to_string(self.space, w_lookup_type)
+ ##def setitem_str(self, w_dict, key, w_value):
+ ## assert key is not None
+ ## self.unerase(w_dict.dstorage)[key] = w_value
+
"""
- def setitem_str(self, w_dict, key, w_value):
- assert key is not None
- self.unerase(w_dict.dstorage)[key] = w_value
-
def getitem(self, w_dict, w_key):
space = self.space
# -- This is called extremely often. Hack for performance --
if type(w_key) is space.StringObjectCls:
- return self.getitem_str(w_dict, w_key.unwrap(space))
+ return self.unerase(w_dict.dstorage).get(self.unwrap(w_key), None)
# -- End of performance hack --
return AbstractTypedStrategy.getitem(self, w_dict, w_key)
+ """
- def getitem_str(self, w_dict, key):
- assert key is not None
- return self.unerase(w_dict.dstorage).get(key, None)
- """
+ ##def getitem_str(self, w_dict, key):
+ ## assert key is not None
+ ## return self.unerase(w_dict.dstorage).get(key, None)
def listview_bytes(self, w_dict):
return self.unerase(w_dict.dstorage).keys()
@@ -858,7 +864,7 @@
return self.space.newlist_bytes(self.listview_bytes(w_dict))
def wrapkey(space, key):
- return space.wrap(key)
+ return space.wrapbytes(key)
@jit.look_inside_iff(lambda self, w_dict:
w_dict_unrolling_heuristic(w_dict))
@@ -909,11 +915,19 @@
def getitem(self, w_dict, w_key):
space = self.space
# -- This is called extremely often. Hack for performance --
- if type(w_key) is space.StringObjectCls:
+ if type(w_key) is space.UnicodeObjectCls:
#return self.getitem_str(w_dict, w_key.unwrap(space))
# XXX:
- key = w_key.unwrap(space)
- return self.unerase(w_dict.dstorage).get(key, None)
+ #key = w_key.unwrap(space) # XXX:
+ #return self.unerase(w_dict.dstorage).get(key, None)
+ # XXX: triggers failure because s.unwrapped isn't set o_O
+
+ #assert type(self) is UnicodeDictStrategy
+ #key = self.unwrap(w_key)
+ #assert key is not None
+ #return self.unerase(w_dict.dstorage).get(key, None)
+ #return self.unerase(w_dict.dstorage).get(self.unwrap(w_key), None)
+ return self.unerase(w_dict.dstorage).get(w_key.unwrap(space), None)
# -- End of performance hack --
return AbstractTypedStrategy.getitem(self, w_dict, w_key)
@@ -925,7 +939,7 @@
return self.unerase(w_dict.dstorage).keys()
#def w_keys(self, w_dict):
- # # XXX: I think we can completely kill w_keys...
+ # # XXX: we can completely kill w_keys on py3k
# return self.space.newlist_str(self.listview_str(w_dict))
def wrapkey(space, key):
@@ -962,8 +976,10 @@
return self.erase({})
def is_correct_type(self, w_obj):
- space = self.space
- return space.is_w(space.type(w_obj), space.w_int)
+ from pypy.objspace.std.intobject import W_IntObject
+ #space = self.space
+ #return space.is_w(space.type(w_obj), space.w_int)
+ return type(w_obj) is W_IntObject
def _never_equal_to(self, w_lookup_type):
space = self.space
diff --git a/pypy/objspace/std/kwargsdict.py b/pypy/objspace/std/kwargsdict.py
--- a/pypy/objspace/std/kwargsdict.py
+++ b/pypy/objspace/std/kwargsdict.py
@@ -11,7 +11,7 @@
def _wrapkey(space, key):
- return space.wrap(key)
+ return space.wrap(key.decode('utf-8'))
class EmptyKwargsDictStrategy(EmptyDictStrategy):
@@ -138,7 +138,7 @@
w_dict.dstorage = self.get_empty_storage()
def switch_to_object_strategy(self, w_dict):
- strategy = self.space.fromcache(UnicodeDictStrategy)
+ strategy = self.space.fromcache(ObjectDictStrategy)
keys, values_w = self.unerase(w_dict.dstorage)
d_new = strategy.unerase(strategy.get_empty_storage())
for i in range(len(keys)):
@@ -147,7 +147,7 @@
w_dict.dstorage = strategy.erase(d_new)
def switch_to_unicode_strategy(self, w_dict):
- strategy = self.space.fromcache(BytesDictStrategy)
+ strategy = self.space.fromcache(UnicodeDictStrategy)
keys, values_w = self.unerase(w_dict.dstorage)
storage = strategy.get_empty_storage()
d_new = strategy.unerase(storage)
diff --git a/pypy/objspace/std/test/test_dictmultiobject.py b/pypy/objspace/std/test/test_dictmultiobject.py
--- a/pypy/objspace/std/test/test_dictmultiobject.py
+++ b/pypy/objspace/std/test/test_dictmultiobject.py
@@ -125,7 +125,7 @@
assert self.space.eq_w(space.call_function(get, w("33"), w(44)), w(44))
def test_fromkeys_fastpath(self):
- py.test.py3k_skip("XXX: strategies are currently broken")
+ py.test.py3k_skip("XXX: list strategies are currently broken")
space = self.space
w = space.wrap
wb = space.wrapbytes
@@ -138,7 +138,6 @@
assert space.eq_w(w_d.getitem_str("b"), space.w_None)
def test_listview_bytes_dict(self):
- py.test.py3k_skip("XXX: strategies are currently broken")
w = self.space.wrap
wb = self.space.wrapbytes
w_d = self.space.newdict()
@@ -152,38 +151,40 @@
assert self.space.listview_unicode(w_d) == [u"a", u"b"]
def test_listview_int_dict(self):
- py.test.py3k_skip("IntDictStrategy not supported yet")
w = self.space.wrap
w_d = self.space.newdict()
w_d.initialize_content([(w(1), w("a")), (w(2), w("b"))])
assert self.space.listview_int(w_d) == [1, 2]
def test_keys_on_string_unicode_int_dict(self, monkeypatch):
- py.test.py3k_skip("XXX: strategies are currently broken")
w = self.space.wrap
wb = self.space.wrapbytes
w_d = self.space.newdict()
w_d.initialize_content([(w(1), wb("a")), (w(2), wb("b"))])
- w_l = self.space.call_method(w_d, "keys")
+ w_k = self.space.call_method(w_d, "keys")
+ w_l = self.space.call_function(self.space.w_list, w_k)
assert sorted(self.space.listview_int(w_l)) == [1,2]
- # make sure that .keys() calls newlist_bytes for string dicts
+ # make sure that list(d.keys()) calls newlist_bytes for byte dicts
def not_allowed(*args):
assert False, 'should not be called'
monkeypatch.setattr(self.space, 'newlist', not_allowed)
#
w_d = self.space.newdict()
- w_d.initialize_content([(w("a"), w(1)), (w("b"), w(6))])
- w_l = self.space.call_method(w_d, "keys")
- assert sorted(self.space.listview_bytes(w_l)) == ["a", "b"]
+ w_d.initialize_content([(wb("a"), w(1)), (wb("b"), w(6))])
+ w_k = self.space.call_method(w_d, "keys")
+ w_l = self.space.call_function(self.space.w_list, w_k)
+ #XXX: py.test.py3k_skip("XXX: list strategies are currently broken")
+ #assert sorted(self.space.listview_bytes(w_l)) == ["a", "b"]
# XXX: it would be nice if the test passed without monkeypatch.undo(),
# but we need space.newlist_unicode for it
monkeypatch.undo()
w_d = self.space.newdict()
w_d.initialize_content([(w(u"a"), w(1)), (w(u"b"), w(6))])
- w_l = self.space.call_method(w_d, "keys")
+ w_k = self.space.call_method(w_d, "keys")
+ w_l = self.space.call_function(self.space.w_list, w_k)
assert sorted(self.space.listview_unicode(w_l)) == [u"a", u"b"]
class AppTest_DictObject:
@@ -952,10 +953,9 @@
return r[r.find("(") + 1: r.find(")")]
def test_empty_to_string(self):
- py3k_skip("StringDictStrategy not supported yet")
d = {}
assert "EmptyDictStrategy" in self.get_strategy(d)
- d["a"] = 1
+ d[b"a"] = 1
assert "BytesDictStrategy" in self.get_strategy(d)
class O(object):
@@ -964,7 +964,7 @@
d = o.__dict__ = {}
assert "EmptyDictStrategy" in self.get_strategy(d)
o.a = 1
- assert "BytesDictStrategy" in self.get_strategy(d)
+ assert "UnicodeDictStrategy" in self.get_strategy(d)
def test_empty_to_unicode(self):
d = {}
@@ -1029,10 +1029,17 @@
return str.__hash__(self)
class FakeString(FakeWrapper, str):
- pass
+
+ def __hash__(self):
+ self.hash_count += 1
+ return str.__hash__(self)
class FakeUnicode(FakeWrapper, unicode):
- pass
+
+ def __hash__(self):
+ self.hash_count += 1
+ return unicode.__hash__(self)
+
# the minimal 'space' needed to use a W_DictMultiObject
class FakeSpace:
@@ -1060,6 +1067,8 @@
def type(self, w_obj):
if isinstance(w_obj, FakeString):
return str
+ if isinstance(w_obj, FakeUnicode):
+ return unicode
return type(w_obj)
w_str = str
w_unicode = unicode
@@ -1158,11 +1167,13 @@
assert value == d.descr_getitem(self.space, key)
class BaseTestRDictImplementation:
+ FakeString = FakeUnicode
+ allows__str = False
def setup_method(self,method):
self.fakespace = FakeSpace()
- self.string = self.wrapstroruni("fish")
- self.string2 = self.wrapstroruni("fish2")
+ self.string = self.wrapstrorunicode("fish")
+ self.string2 = self.wrapstrorunicode("fish2")
self.impl = self.get_impl()
def wrapstrorunicode(self, obj):
@@ -1197,21 +1208,22 @@
else:
assert a == self.string2
assert b == 2000
- assert self.impl.getitem_str(self.string) == 1000
+ if self.allows__str:
+ result = self.impl.getitem_str(self.string)
+ else:
+ result = self.impl.getitem(self.string)
+ assert result == 1000
self.check_not_devolved()
def test_setitem(self):
self.impl.setitem(self.string, 1000)
assert self.impl.length() == 1
assert self.impl.getitem(self.string) == 1000
- assert self.impl.getitem_str(self.string) == 1000
- self.check_not_devolved()
-
- def test_setitem_str(self):
- self.impl.setitem_str(self.fakespace.str_w(self.string), 1000)
- assert self.impl.length() == 1
- assert self.impl.getitem(self.string) == 1000
- assert self.impl.getitem_str(self.string) == 1000
+ if self.allows__str:
+ result = self.impl.getitem_str(self.string)
+ else:
+ result = self.impl.getitem(self.string)
+ assert result == 1000
self.check_not_devolved()
def test_delitem(self):
@@ -1275,7 +1287,7 @@
def test_setdefault_fast(self):
on_pypy = "__pypy__" in sys.builtin_module_names
impl = self.impl
- key = FakeString(self.string)
+ key = self.FakeString(self.string)
x = impl.setdefault(key, 1)
assert x == 1
if on_pypy:
@@ -1317,19 +1329,33 @@
class TestUnicodeDictImplementation(BaseTestRDictImplementation):
StrategyClass = UnicodeDictStrategy
+ FakeString = FakeUnicode
+ allows__str = True
def test_str_shortcut(self):
self.fill_impl()
- #s = FakeString(self.string)
- s = FakeUnicode(self.string)
+ s = self.FakeString(self.string)
assert self.impl.getitem(s) == 1000
assert s.unwrapped
def test_view_as_kwargs(self):
- #py.test.py3k_skip("XXX: strategies are currently broken")
self.fill_impl()
assert self.fakespace.view_as_kwargs(self.impl) == (["fish", "fish2"], [1000, 2000])
+ def test_setitem_str(self):
+ self.impl.setitem_str(self.fakespace.str_w(self.string), 1000)
+ assert self.impl.length() == 1
+ assert self.impl.getitem(self.string) == 1000
+ assert self.impl.getitem_str(self.string) == 1000
+ self.check_not_devolved()
+
+class TestBytesDictImplementation(BaseTestRDictImplementation):
+ StrategyClass = BytesDictStrategy
+ FakeString = FakeString
+
+ def wrapstrorunicode(self, obj):
+ return self.fakespace.wrapbytes(obj)
+
class BaseTestDevolvedDictImplementation(BaseTestRDictImplementation):
def fill_impl(self):
@@ -1344,8 +1370,7 @@
def test_module_uses_strdict():
- py.test.py3k_skip("XXX: strategies are currently broken")
fakespace = FakeSpace()
d = fakespace.newdict(module=True)
- assert type(d.strategy) is BytesDictStrategy
+ assert type(d.strategy) is UnicodeDictStrategy
diff --git a/pypy/objspace/std/test/test_kwargsdict.py b/pypy/objspace/std/test/test_kwargsdict.py
--- a/pypy/objspace/std/test/test_kwargsdict.py
+++ b/pypy/objspace/std/test/test_kwargsdict.py
@@ -1,3 +1,4 @@
+# encoding: utf-8
import py
from pypy.objspace.std.test.test_dictmultiobject import FakeSpace, W_DictMultiObject
from pypy.objspace.std.kwargsdict import *
@@ -159,3 +160,22 @@
assert a == 3
assert "KwargsDictStrategy" in self.get_strategy(d)
+ def test_unicode(self):
+ """
+ def f(**kwargs):
+ return kwargs
+
+ d = f(λ=True)
+ assert list(d) == ['λ']
+ assert "KwargsDictStrategy" in self.get_strategy(d)
+
+ d['foo'] = 'bar'
+ assert sorted(d) == ['foo', 'λ']
+ assert "KwargsDictStrategy" in self.get_strategy(d)
+
+ d = f(λ=True)
+ o = object()
+ d[o] = 'baz'
+ assert set(d) == set(['λ', o])
+ assert "ObjectDictStrategy" in self.get_strategy(d)
+ """
diff --git a/pypy/objspace/std/test/test_liststrategies.py b/pypy/objspace/std/test/test_liststrategies.py
--- a/pypy/objspace/std/test/test_liststrategies.py
+++ b/pypy/objspace/std/test/test_liststrategies.py
@@ -7,7 +7,7 @@
from pypy.objspace.std import listobject
from pypy.objspace.std.test.test_listobject import TestW_ListObject
-py.test.py3k_skip("XXX: strategies are currently broken")
+#py.test.py3k_skip("XXX: strategies are currently broken")
class TestW_ListStrategies(TestW_ListObject):
def test_check_strategy(self):
More information about the pypy-commit
mailing list