[pypy-svn] rev 603 - in pypy/trunk/src/pypy/objspace/std: . test
mwh at codespeak.net
mwh at codespeak.net
Tue May 27 18:27:10 CEST 2003
Author: mwh
Date: Tue May 27 18:27:09 2003
New Revision: 603
Modified:
pypy/trunk/src/pypy/objspace/std/moduleobject.py
pypy/trunk/src/pypy/objspace/std/objspace.py
pypy/trunk/src/pypy/objspace/std/stringobject.py
pypy/trunk/src/pypy/objspace/std/test/test_dictobject.py
pypy/trunk/src/pypy/objspace/std/test/test_intobject.py
pypy/trunk/src/pypy/objspace/std/test/test_iterobject.py
pypy/trunk/src/pypy/objspace/std/test/test_listobject.py
pypy/trunk/src/pypy/objspace/std/tupleobject.py
Log:
W_Foo first arg changes
Modified: pypy/trunk/src/pypy/objspace/std/moduleobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/moduleobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/moduleobject.py Tue May 27 18:27:09 2003
@@ -11,7 +11,7 @@
w_key_doc = space.wrap('__doc__')
items = [(w_key_name, w_name),
(w_key_doc, space.w_None)]
- self.w_dict = W_DictObject(items)
+ self.w_dict = W_DictObject(self.space, items)
def getattr_module_any(space, w_module, w_attr):
Modified: pypy/trunk/src/pypy/objspace/std/objspace.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/objspace.py (original)
+++ pypy/trunk/src/pypy/objspace/std/objspace.py Tue May 27 18:27:09 2003
@@ -61,44 +61,44 @@
if isinstance(x, booltype):
return self.newbool(x)
import intobject
- return intobject.W_IntObject(x)
+ return intobject.W_IntObject(self, x)
if isinstance(x, str):
import stringobject
- return stringobject.W_StringObject(x)
+ return stringobject.W_StringObject(self, x)
#if isinstance(x, float):
# import floatobject
# return floatobject.W_FloatObject(x)
if isinstance(x, tuple):
wrappeditems = [self.wrap(item) for item in x]
import tupleobject
- return tupleobject.W_TupleObject(wrappeditems)
+ return tupleobject.W_TupleObject(self, wrappeditems)
if isinstance(x, list):
wrappeditems = [self.wrap(item) for item in x]
import listobject
- return listobject.W_ListObject(wrappeditems)
+ return listobject.W_ListObject(self, wrappeditems)
import cpythonobject
- return cpythonobject.W_CPythonObject(x)
+ return cpythonobject.W_CPythonObject(self, x)
def newtuple(self, list_w):
import tupleobject
- return tupleobject.W_TupleObject(list_w)
+ return tupleobject.W_TupleObject(self, list_w)
def newlist(self, list_w):
import listobject
- return listobject.W_ListObject(list_w)
+ return listobject.W_ListObject(self, list_w)
def newdict(self, list_pairs_w):
import dictobject
- return dictobject.W_DictObject(list_pairs_w)
+ return dictobject.W_DictObject(self, list_pairs_w)
def newslice(self, w_start, w_end, w_step):
# w_step may be a real None
import sliceobject
- return sliceobject.W_SliceObject(w_start, w_end, w_step)
+ return sliceobject.W_SliceObject(self, w_start, w_end, w_step)
def newfunction(self, code, w_globals, w_defaultarguments, w_closure=None):
import funcobject
- return funcobject.W_FuncObject(code, w_globals,
+ return funcobject.W_FuncObject(self, code, w_globals,
w_defaultarguments, w_closure)
def newmodule(self, w_name):
@@ -115,7 +115,7 @@
raise OperationError(self.w_ValueError,
self.wrap("character code not in range(256)"))
import stringobject
- return stringobject.W_StringObject(''.join(chars))
+ return stringobject.W_StringObject(self, ''.join(chars))
# special multimethods
unwrap = MultiMethod('unwrap', 1) # returns an unwrapped object
@@ -153,7 +153,7 @@
def default_id(space, w_obj):
import intobject
- return intobject.W_IntObject(id(w_obj))
+ return intobject.W_IntObject(space, id(w_obj))
StdObjSpace.id.register(default_id, W_ANY)
Modified: pypy/trunk/src/pypy/objspace/std/stringobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/stringobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/stringobject.py Tue May 27 18:27:09 2003
@@ -12,9 +12,9 @@
""" representation for debugging purposes """
return "%s(%r)" % (w_self.__class__.__name__, w_self.value)
def nonzero(w_self):
- return W_IntObject(w_self.value != 0)
+ return W_IntObject(self.space, w_self.value != 0)
def hash(w_self):
- return W_IntObject(hash(self.value))
+ return W_IntObject(self, hash(self.value))
def str_unwrap(space, w_str):
@@ -60,10 +60,10 @@
def getitem_str_int(space, w_str, w_int):
- return W_StringObject(w_str.value[w_int.intval])
+ return W_StringObject(space, w_str.value[w_int.intval])
StdObjSpace.getitem.register(getitem_str_int,
- W_StringObject, W_IntObject)
+ W_StringObject, W_IntObject)
def getitem_str_slice(space, w_str, w_slice):
return applicationfile.call(space, "getitem_string_slice", [w_str, w_slice])
@@ -72,7 +72,7 @@
W_StringObject, W_SliceObject)
def add_str_str(space, w_left, w_right):
- return W_StringObject(w_left.value + w_right.value)
+ return W_StringObject(space, w_left.value + w_right.value)
StdObjSpace.add.register(add_str_str, W_StringObject, W_StringObject)
Modified: pypy/trunk/src/pypy/objspace/std/test/test_dictobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_dictobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_dictobject.py Tue May 27 18:27:09 2003
@@ -15,14 +15,14 @@
def test_empty(self):
space = self.space
- d = dobj.W_DictObject([])
+ d = dobj.W_DictObject(space, [])
self.failIf_w(d)
def test_nonempty(self):
space = self.space
wNone = space.w_None
- d = dobj.W_DictObject([(wNone, wNone)])
- self.failUnless(self.space.is_true(d))
+ d = dobj.W_DictObject(space, [(wNone, wNone)])
+ self.failUnless(space.is_true(d))
i = space.getitem(d, wNone)
equal = space.eq(i, wNone)
self.failUnless(space.is_true(equal))
@@ -31,7 +31,7 @@
space = self.space
wk1 = space.wrap('key')
wone = space.wrap(1)
- d = dobj.W_DictObject([(space.wrap('zero'),space.wrap(0))])
+ d = dobj.W_DictObject(space, [(space.wrap('zero'),space.wrap(0))])
space.setitem(d,wk1,wone)
wback = space.getitem(d,wk1)
self.assertEqual_w(wback,wone)
@@ -39,7 +39,8 @@
def test_delitem(self):
space = self.space
wk1 = space.wrap('key')
- d = dobj.W_DictObject([(space.wrap('zero'),space.wrap(0)),
+ d = dobj.W_DictObject(space,
+ [(space.wrap('zero'),space.wrap(0)),
(space.wrap('one'),space.wrap(1)),
(space.wrap('two'),space.wrap(2))])
space.delitem(d,space.wrap('one'))
@@ -50,7 +51,7 @@
def test_cell(self):
space = self.space
wk1 = space.wrap('key')
- d = dobj.W_DictObject([])
+ d = dobj.W_DictObject(space, [])
w_cell = d.cell(space,wk1)
cell = space.unwrap(w_cell)
self.failUnless(cell.is_empty())
Modified: pypy/trunk/src/pypy/objspace/std/test/test_intobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_intobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_intobject.py Tue May 27 18:27:09 2003
@@ -42,19 +42,19 @@
def test_repr(self):
x = 1
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
result = iobj.int_repr(self.space, f1)
self.assertEquals(self.space.unwrap(result), repr(x))
def test_str(self):
x = 12345
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
result = iobj.int_str(self.space, f1)
self.assertEquals(self.space.unwrap(result), str(x))
def test_hash(self):
x = 42
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
result = iobj.int_hash(self.space, f1)
self.assertEquals(result.intval, hash(x))
@@ -64,8 +64,8 @@
for x in (-10, -1, 0, 1, 2, 1000, sys.maxint):
for y in (-sys.maxint-1, -11, -9, -2, 0, 1, 3, 1111, sys.maxint):
for op in optab:
- wx = iobj.W_IntObject(x)
- wy = iobj.W_IntObject(y)
+ wx = iobj.W_IntObject(self.space, x)
+ wy = iobj.W_IntObject(self.space, y)
res = getattr(operator, op)(x, y)
method = getattr(iobj, 'int_int_%s' % op)
myres = method(self.space, wx, wy)
@@ -74,28 +74,28 @@
def test_add(self):
x = 1
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
result = iobj.int_int_add(self.space, f1, f2)
self.assertEquals(result.intval, x+y)
x = sys.maxint
y = 1
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_int_add, self.space, f1, f2))
def test_sub(self):
x = 1
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
result = iobj.int_int_sub(self.space, f1, f2)
self.assertEquals(result.intval, x-y)
x = sys.maxint
y = -1
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_int_sub, self.space, f1, f2))
@@ -103,14 +103,14 @@
def test_mul(self):
x = 2
y = 3
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
result = iobj.int_int_mul(self.space, f1, f2)
self.assertEquals(result.intval, x*y)
x = -sys.maxint-1
y = -1
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_int_mul, self.space, f1, f2))
@@ -118,22 +118,22 @@
def test_div(self):
for i in range(10):
res = i//3
- f1 = iobj.W_IntObject(i)
- f2 = iobj.W_IntObject(3)
+ f1 = iobj.W_IntObject(self.space, i)
+ f2 = iobj.W_IntObject(self.space, 3)
result = iobj.int_int_div(self.space, f1, f2)
self.assertEquals(result.intval, res)
x = -sys.maxint-1
y = -1
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_int_div, self.space, f1, f2))
def test_mod(self):
x = 1
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
v = iobj.int_int_mod(self.space, f1, f2)
self.assertEquals(v.intval, x % y)
# not that mod cannot overflow
@@ -141,15 +141,15 @@
def test_divmod(self):
x = 1
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
ret = iobj.int_int_divmod(self.space, f1, f2)
v, w = self.space.unwrap(ret)
self.assertEquals((v, w), divmod(x, y))
x = -sys.maxint-1
y = -1
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_int_divmod, self.space, f1, f2))
@@ -157,9 +157,9 @@
x = 10
y = 2
z = 13
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
- f3 = iobj.W_IntObject(z)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
+ f3 = iobj.W_IntObject(self.space, z)
v = iobj.int_int_int_pow(self.space, f1, f2, f3)
self.assertEquals(v.intval, pow(x, y, z))
f1, f2, f3 = map(iobj.W_IntObject, (10, -1, 42))
@@ -172,8 +172,8 @@
def test_pow_iin(self):
x = 10
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
v = iobj.int_int_none_pow(self.space, f1, f2)
self.assertEquals(v.intval, x ** y)
f1, f2 = map(iobj.W_IntObject, (10, 20))
@@ -185,111 +185,111 @@
def test_neg(self):
x = 42
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
v = iobj.int_neg(self.space, f1)
self.assertEquals(v.intval, -x)
x = -sys.maxint-1
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_neg, self.space, f1))
def test_pos(self):
x = 42
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
v = iobj.int_pos(self.space, f1)
self.assertEquals(v.intval, +x)
def test_abs(self):
x = 42
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
v = iobj.int_abs(self.space, f1)
self.assertEquals(v.intval, abs(x))
x = -42
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
v = iobj.int_abs(self.space, f1)
self.assertEquals(v.intval, abs(x))
x = -sys.maxint-1
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_neg, self.space, f1))
def test_pos(self):
x = 42
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
v = iobj.int_invert(self.space, f1)
self.assertEquals(v.intval, ~x)
def test_lshift(self):
x = 12345678
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
v = iobj.int_int_lshift(self.space, f1, f2)
self.assertEquals(v.intval, x << y)
y = self._longshiftresult(x)
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
self.assertEquals(self.space.w_OverflowError,
self._unwrap_nonimpl(iobj.int_int_lshift, self.space, f1, f2))
def test_rshift(self):
x = 12345678
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
v = iobj.int_int_rshift(self.space, f1, f2)
self.assertEquals(v.intval, x >> y)
def test_and(self):
x = 12345678
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
v = iobj.int_int_and(self.space, f1, f2)
self.assertEquals(v.intval, x & y)
def test_xor(self):
x = 12345678
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
v = iobj.int_int_xor(self.space, f1, f2)
self.assertEquals(v.intval, x ^ y)
def test_or(self):
x = 12345678
y = 2
- f1 = iobj.W_IntObject(x)
- f2 = iobj.W_IntObject(y)
+ f1 = iobj.W_IntObject(self.space, x)
+ f2 = iobj.W_IntObject(self.space, y)
v = iobj.int_int_or(self.space, f1, f2)
self.assertEquals(v.intval, x | y)
def test_int(self):
- f1 = iobj.W_IntObject(1)
+ f1 = iobj.W_IntObject(self.space, 1)
result = iobj.int_int(self.space, f1)
self.assertEquals(result, f1)
## def test_long(self):
## x = 1
-## f1 = iobj.W_IntObject(x)
+## f1 = iobj.W_IntObject(self.space, x)
## result = iobj.int_long(self.space, f1)
## self.assertEquals(self.space.unwrap(result), long(x))
## def test_float(self):
## x = 1
-## f1 = iobj.W_IntObject(x)
+## f1 = iobj.W_IntObject(self.space, x)
## result = iobj.int_float(self.space, f1)
## self.assertEquals(self.space.unwrap(result), float(x))
def test_oct(self):
x = 012345
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
result = iobj.int_oct(self.space, f1)
self.assertEquals(self.space.unwrap(result), oct(x))
def test_hex(self):
x = 0x12345
- f1 = iobj.W_IntObject(x)
+ f1 = iobj.W_IntObject(self.space, x)
result = iobj.int_hex(self.space, f1)
self.assertEquals(self.space.unwrap(result), hex(x))
Modified: pypy/trunk/src/pypy/objspace/std/test/test_iterobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_iterobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_iterobject.py Tue May 27 18:27:09 2003
@@ -16,7 +16,7 @@
def test_iter(self):
w = self.space.wrap
w_tuple = self.space.newtuple([w(5), w(3), w(99)])
- w_iter = iobj.W_SeqIterObject(w_tuple)
+ w_iter = iobj.W_SeqIterObject(self.space, w_tuple)
self.assertEqual_w(self.space.next(w_iter), w(5))
self.assertEqual_w(self.space.next(w_iter), w(3))
self.assertEqual_w(self.space.next(w_iter), w(99))
@@ -25,7 +25,7 @@
def test_emptyiter(self):
w_list = self.space.newlist([])
- w_iter = iobj.W_SeqIterObject(w_list)
+ w_iter = iobj.W_SeqIterObject(self.space, w_list)
self.assertRaises(NoValue, self.space.next, w_iter)
self.assertRaises(NoValue, self.space.next, w_iter)
Modified: pypy/trunk/src/pypy/objspace/std/test/test_listobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_listobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_listobject.py Tue May 27 18:27:09 2003
@@ -16,20 +16,20 @@
def test_is_true(self):
w = self.space.wrap
- w_list = tobj.W_ListObject([])
+ w_list = tobj.W_ListObject(self.space, [])
self.assertEqual(self.space.is_true(w_list), False)
- w_list = tobj.W_ListObject([w(5)])
+ w_list = tobj.W_ListObject(self.space, [w(5)])
self.assertEqual(self.space.is_true(w_list), True)
- w_list = tobj.W_ListObject([w(5), w(3)])
+ w_list = tobj.W_ListObject(self.space, [w(5), w(3)])
self.assertEqual(self.space.is_true(w_list), True)
def test_len(self):
w = self.space.wrap
- w_list = tobj.W_ListObject([])
+ w_list = tobj.W_ListObject(self.space, [])
self.assertEqual_w(self.space.len(w_list), w(0))
- w_list = tobj.W_ListObject([w(5)])
+ w_list = tobj.W_ListObject(self.space, [w(5)])
self.assertEqual_w(self.space.len(w_list), w(1))
- w_list = tobj.W_ListObject([w(5), w(3), w(99)]*111)
+ w_list = tobj.W_ListObject(self.space, [w(5), w(3), w(99)]*111)
self.assertEqual_w(self.space.len(w_list), w(333))
def test_mul(self):
@@ -37,14 +37,14 @@
w = self.space.wrap
arg = w(2)
n = 3
- w_lis = tobj.W_ListObject([arg])
- w_lis3 = tobj.W_ListObject([arg]*n)
+ w_lis = tobj.W_ListObject(self.space, [arg])
+ w_lis3 = tobj.W_ListObject(self.space, [arg]*n)
w_res = self.space.mul(w_lis, w(n))
self.assertEqual_w(w_lis3, w_res)
def test_getitem(self):
w = self.space.wrap
- w_list = tobj.W_ListObject([w(5), w(3)])
+ w_list = tobj.W_ListObject(self.space, [w(5), w(3)])
self.assertEqual_w(self.space.getitem(w_list, w(0)), w(5))
self.assertEqual_w(self.space.getitem(w_list, w(1)), w(3))
self.assertEqual_w(self.space.getitem(w_list, w(-2)), w(5))
@@ -58,7 +58,7 @@
def test_iter(self):
w = self.space.wrap
- w_list = tobj.W_ListObject([w(5), w(3), w(99)])
+ w_list = tobj.W_ListObject(self.space, [w(5), w(3), w(99)])
w_iter = self.space.iter(w_list)
self.assertEqual_w(self.space.next(w_iter), w(5))
self.assertEqual_w(self.space.next(w_iter), w(3))
@@ -68,15 +68,15 @@
def test_add(self):
w = self.space.wrap
- w_list0 = tobj.W_ListObject([])
- w_list1 = tobj.W_ListObject([w(5), w(3), w(99)])
- w_list2 = tobj.W_ListObject([w(-7)] * 111)
+ w_list0 = tobj.W_ListObject(self.space, [])
+ w_list1 = tobj.W_ListObject(self.space, [w(5), w(3), w(99)])
+ w_list2 = tobj.W_ListObject(self.space, [w(-7)] * 111)
self.assertEqual_w(self.space.add(w_list1, w_list1),
- tobj.W_ListObject([w(5), w(3), w(99),
- w(5), w(3), w(99)]))
+ tobj.W_ListObject(self.space, [w(5), w(3), w(99),
+ w(5), w(3), w(99)]))
self.assertEqual_w(self.space.add(w_list1, w_list2),
- tobj.W_ListObject([w(5), w(3), w(99)] +
- [w(-7)] * 111))
+ tobj.W_ListObject(self.space, [w(5), w(3), w(99)] +
+ [w(-7)] * 111))
self.assertEqual_w(self.space.add(w_list1, w_list0), w_list1)
self.assertEqual_w(self.space.add(w_list0, w_list2), w_list2)
@@ -85,7 +85,7 @@
def test1(testlist, start, stop, step, expected):
w_slice = self.space.newslice(w(start), w(stop), w(step))
- w_list = tobj.W_ListObject([w(i) for i in testlist])
+ w_list = tobj.W_ListObject(self.space, [w(i) for i in testlist])
w_result = self.space.getitem(w_list, w_slice)
self.assertEqual(self.space.unwrap(w_result), expected)
Modified: pypy/trunk/src/pypy/objspace/std/tupleobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/tupleobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/tupleobject.py Tue May 27 18:27:09 2003
@@ -28,7 +28,7 @@
def tuple_len(space, w_tuple):
result = len(w_tuple.wrappeditems)
- return W_IntObject(result)
+ return W_IntObject(space, result)
StdObjSpace.len.register(tuple_len, W_TupleObject)
@@ -55,27 +55,27 @@
for i in range(slicelength):
subitems[i] = items[start]
start += step
- return W_TupleObject(subitems)
+ return W_TupleObject(space, subitems)
StdObjSpace.getitem.register(getitem_tuple_slice, W_TupleObject, W_SliceObject)
def tuple_iter(space, w_tuple):
import iterobject
- return iterobject.W_SeqIterObject(w_tuple)
+ return iterobject.W_SeqIterObject(space, w_tuple)
StdObjSpace.iter.register(tuple_iter, W_TupleObject)
def tuple_add(space, w_tuple1, w_tuple2):
items1 = w_tuple1.wrappeditems
items2 = w_tuple2.wrappeditems
- return W_TupleObject(items1 + items2)
+ return W_TupleObject(space, items1 + items2)
StdObjSpace.add.register(tuple_add, W_TupleObject, W_TupleObject)
def tuple_int_mul(space, w_tuple, w_int):
items = w_tuple.wrappeditems
times = w_int.intval
- return W_TupleObject(items * times)
+ return W_TupleObject(space, items * times)
StdObjSpace.mul.register(tuple_int_mul, W_TupleObject, W_IntObject)
More information about the Pypy-commit
mailing list