def test_multiple_inheritance(self):
class W_A(W_Root):
a = 1
b = 2
class W_C(W_A):
b = 3
W_A.typedef = typedef.TypeDef(
"A",
a=typedef.interp_attrproperty("a", cls=W_A),
b=typedef.interp_attrproperty("b", cls=W_A),
)
class W_B(W_Root):
pass
def standalone_method(space, w_obj):
if isinstance(w_obj, W_A):
return space.w_True
else:
return space.w_False
W_B.typedef = typedef.TypeDef("B", c=interp2app(standalone_method))
W_C.typedef = typedef.TypeDef("C", (
W_A.typedef,
W_B.typedef,
))
w_o1 = self.space.wrap(W_C())
w_o2 = self.space.wrap(W_B())
w_c = self.space.gettypefor(W_C)
w_b = self.space.gettypefor(W_B)
w_a = self.space.gettypefor(W_A)
assert w_c.mro_w == [
w_c,
w_a,
w_b,
self.space.w_object,
]
for w_tp in w_c.mro_w:
assert self.space.isinstance_w(w_o1, w_tp)
def assert_attr(w_obj, name, value):
assert self.space.unwrap(
self.space.getattr(w_obj, self.space.wrap(name))) == value
def assert_method(w_obj, name, value):
assert self.space.unwrap(self.space.call_method(w_obj,
name)) == value
assert_attr(w_o1, "a", 1)
assert_attr(w_o1, "b", 3)
assert_method(w_o1, "c", True)
assert_method(w_o2, "c", False)
def Space(*args, **kwds):
space = ReflectiveObjSpace(*args, **kwds)
patch_space_in_place(space, 'reflective', proxymaker)
w___pypy__ = space.getbuiltinmodule("__pypy__")
space.setattr(w___pypy__, space.wrap('set_reflectivespace'),
space.wrap(app_set_reflectivespace))
W_SpaceAccess.typedef = typedef.TypeDef("ObjSpace", **W_SpaceAccess_dict)
return space
def test_destructor(self):
space = self.space
class W_Level1(W_Root):
def __init__(self, space1):
assert space1 is space
self.register_finalizer(space)
def _finalize_(self):
space.call_method(w_seen, 'append', space.wrap(1))
W_Level1.typedef = typedef.TypeDef(
'level1', __new__=typedef.generic_new_descr(W_Level1))
#
w_seen = space.newlist([])
W_Level1(space)
gc.collect()
gc.collect()
assert space.str_w(space.repr(w_seen)) == "[]" # not called yet
ec = space.getexecutioncontext()
self.space.user_del_action.perform(ec, None)
assert space.unwrap(w_seen) == [1] # called by user_del_action
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level1):
class A3(level1):
pass
A3()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
self.space.appexec(
[self.space.gettypeobject(W_Level1.typedef), w_seen],
"""(level1, seen):
class A4(level1):
def __del__(self):
seen.append(4)
A4()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [4, 1] # user __del__, and _finalize_
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level2):
class A5(level2):
pass
A5()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1] # _finalize_ only
def test_unhashable(self):
class W_SomeType(W_Root):
pass
W_SomeType.typedef = typedef.TypeDef('some_type', __hash__=None)
w_obj = self.space.wrap(W_SomeType())
self.space.appexec([w_obj], """(obj):
assert type(obj).__hash__ is None
err = raises(TypeError, hash, obj)
assert str(err.value) == "'some_type' objects are unhashable"
""")
def test_getsetproperty(self):
class W_SomeType(W_Root):
pass
def fget(self, space, w_self):
assert self is prop
prop = typedef.GetSetProperty(fget, use_closure=True)
W_SomeType.typedef = typedef.TypeDef('some_type', x=prop)
w_obj = self.space.wrap(W_SomeType())
assert self.space.getattr(w_obj,
self.space.wrap('x')) is self.space.w_None
def test_getsetproperty(self):
class W_SomeType(W_Root):
pass
def fget(self, space, w_self):
assert self is prop
# NB. this GetSetProperty is not copied when creating the
# W_TypeObject because of 'cls'. Without it, a duplicate of the
# GetSetProperty is taken and it is given the w_objclass that is
# the W_TypeObject
prop = typedef.GetSetProperty(fget, use_closure=True, cls=W_SomeType)
W_SomeType.typedef = typedef.TypeDef(
'some_type',
x=prop)
w_obj = self.space.wrap(W_SomeType())
assert self.space.getattr(w_obj, self.space.wrap('x')) is self.space.w_None
def test_getsetproperty_arguments(self):
class W_SomeType(W_Root):
def fget1(space, w_self):
assert isinstance(space, ObjSpace)
assert isinstance(w_self, W_SomeType)
def fget2(self, space):
assert isinstance(space, ObjSpace)
assert isinstance(self, W_SomeType)
W_SomeType.typedef = typedef.TypeDef(
'some_type',
x1=typedef.GetSetProperty(W_SomeType.fget1),
x2=typedef.GetSetProperty(W_SomeType.fget2),
)
space = self.space
w_obj = space.wrap(W_SomeType())
assert space.getattr(w_obj, space.wrap('x1')) == space.w_None
assert space.getattr(w_obj, space.wrap('x2')) == space.w_None
def test_class_attr(self):
class W_SomeType(W_Root):
pass
seen = []
def make_me(space):
seen.append(1)
return space.wrap("foobar")
W_SomeType.typedef = typedef.TypeDef('some_type',
abc=typedef.ClassAttr(make_me))
assert seen == []
self.space.appexec([W_SomeType()], """(x):
assert type(x).abc == "foobar"
assert x.abc == "foobar"
assert type(x).abc == "foobar"
""")
assert seen == [1]
def test_total_ordering(self):
class W_SomeType(W_Root):
def __init__(self, space, x):
self.space = space
self.x = x
def descr__lt(self, w_other):
assert isinstance(w_other, W_SomeType)
return self.space.wrap(self.x < w_other.x)
def descr__eq(self, w_other):
assert isinstance(w_other, W_SomeType)
return self.space.wrap(self.x == w_other.x)
W_SomeType.typedef = typedef.TypeDef(
'some_type',
__total_ordering__ = 'auto',
__lt__ = interp2app(W_SomeType.descr__lt),
__eq__ = interp2app(W_SomeType.descr__eq),
)
space = self.space
w_b = space.wrap(W_SomeType(space, 2))
w_c = space.wrap(W_SomeType(space, 2))
w_a = space.wrap(W_SomeType(space, 1))
# explicitly defined
assert space.is_true(space.lt(w_a, w_b))
assert not space.is_true(space.eq(w_a, w_b))
assert space.is_true(space.eq(w_b, w_c))
# automatically defined
assert space.is_true(space.le(w_a, w_b))
assert space.is_true(space.le(w_b, w_c))
assert space.is_true(space.gt(w_b, w_a))
assert space.is_true(space.ge(w_b, w_a))
assert space.is_true(space.ge(w_b, w_c))
assert space.is_true(space.ne(w_a, w_b))
assert not space.is_true(space.ne(w_b, w_c))
self.report_error("no exception")
if not space.exception_match(w_exc_type, self.w_ExpectedException):
self.report_error(space.text_w(space.repr(w_exc_type)))
self.w_value = w_exc_value # for the 'value' app-level attribute
return space.w_True # suppress the exception
def report_error(self, got):
space = self.space
raise oefmt(space.w_AssertionError,
"raises() expected %s, but got %s",
space.text_w(space.repr(self.w_ExpectedException)),
got)
W_RaisesContextManager.typedef = typedef.TypeDef("RaisesContextManager",
__enter__ = gateway.interp2app_temp(W_RaisesContextManager.enter),
__exit__ = gateway.interp2app_temp(W_RaisesContextManager.exit),
value = typedef.interp_attrproperty_w('w_value', cls=W_RaisesContextManager)
)
def pypyraises(space, w_ExpectedException, w_expr=None, __args__=None):
"""A built-in function providing the equivalent of py.test.raises()."""
if w_expr is None:
return W_RaisesContextManager(space, w_ExpectedException)
args_w, kwds_w = __args__.unpack()
if space.isinstance_w(w_expr, space.w_text):
if args_w:
raise oefmt(space.w_TypeError,
"raises() takes no argument after a string expression")
expr = space.unwrap(w_expr)
source = py.code.Source(expr)
frame = space.getexecutioncontext().gettopframe()
def test_destructor(self):
space = self.space
class W_Level1(W_Root):
def __init__(self, space1):
assert space1 is space
def __del__(self):
space.call_method(w_seen, 'append', space.wrap(1))
class W_Level2(W_Root):
def __init__(self, space1):
assert space1 is space
def __del__(self):
self.enqueue_for_destruction(space, W_Level2.destructormeth,
'FOO ')
def destructormeth(self):
space.call_method(w_seen, 'append', space.wrap(2))
W_Level1.typedef = typedef.TypeDef(
'level1', __new__=typedef.generic_new_descr(W_Level1))
W_Level2.typedef = typedef.TypeDef(
'level2', __new__=typedef.generic_new_descr(W_Level2))
#
w_seen = space.newlist([])
W_Level1(space)
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
W_Level2(space)
gc.collect()
gc.collect()
assert space.str_w(space.repr(w_seen)) == "[]" # not called yet
ec = space.getexecutioncontext()
self.space.user_del_action.perform(ec, None)
assert space.unwrap(w_seen) == [2]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level1.typedef)],
"""(level1):
class A3(level1):
pass
A3()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [1]
#
w_seen = space.newlist([])
self.space.appexec(
[self.space.gettypeobject(W_Level1.typedef), w_seen],
"""(level1, seen):
class A4(level1):
def __del__(self):
seen.append(4)
A4()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [4, 1]
#
w_seen = space.newlist([])
self.space.appexec([self.space.gettypeobject(W_Level2.typedef)],
"""(level2):
class A5(level2):
pass
A5()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [2]
#
w_seen = space.newlist([])
self.space.appexec(
[self.space.gettypeobject(W_Level2.typedef), w_seen],
"""(level2, seen):
class A6(level2):
def __del__(self):
seen.append(6)
A6()
""")
gc.collect()
gc.collect()
assert space.unwrap(w_seen) == [6, 2]
assert not dbstate.standard_code
space = self.space
if space.isinstance_w(w_buffer, space.w_unicode):
w_buffer = space.call_method(w_buffer, 'encode',
space.newtext('utf-8')) # safe?
revdb.send_output(space.bytes_w(w_buffer))
def descr_get_softspace(space, revdb):
return space.newint(revdb.softspace)
def descr_set_softspace(space, revdb, w_newvalue):
revdb.softspace = space.int_w(w_newvalue)
W_RevDBOutput.typedef = typedef.TypeDef(
"revdb_output",
write = gateway.interp2app(W_RevDBOutput.descr_write),
# XXX is 'softspace' still necessary in Python 3?
softspace = typedef.GetSetProperty(descr_get_softspace,
descr_set_softspace,
cls=W_RevDBOutput),
)
def revdb_displayhook(space, w_obj):
"""Modified sys.displayhook() that also outputs '$NUM = ',
for non-prebuilt objects. Such objects are then recorded in
'printed_objects'.
"""
assert not dbstate.standard_code
if space.is_w(w_obj, space.w_None):
return
uid = revdb.get_unique_id(w_obj)
if uid > 0:
dbstate.printed_objects[uid] = w_obj
