[pypy-svn] rev 778 - pypy/trunk/src/pypy/objspace/std/test
mwh at codespeak.net
mwh at codespeak.net
Sat Jun 7 20:26:04 CEST 2003
Author: mwh
Date: Sat Jun 7 20:26:03 2003
New Revision: 778
Modified:
pypy/trunk/src/pypy/objspace/std/test/test_cpythonobject.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/test/test_moduleobject.py
pypy/trunk/src/pypy/objspace/std/test/test_noneobject.py
pypy/trunk/src/pypy/objspace/std/test/test_restricted_int.py
pypy/trunk/src/pypy/objspace/std/test/test_sliceobject.py
pypy/trunk/src/pypy/objspace/std/test/test_stdobjspace.py
pypy/trunk/src/pypy/objspace/std/test/test_stringobject.py
pypy/trunk/src/pypy/objspace/std/test/test_tupleobject.py
pypy/trunk/src/pypy/objspace/std/test/test_typeobject.py
Log:
considerable, but largely cosmetic, test gardening
hope I didn't cause too many conflicts for you!
Modified: pypy/trunk/src/pypy/objspace/std/test/test_cpythonobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_cpythonobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_cpythonobject.py Sat Jun 7 20:26:03 2003
@@ -1,13 +1,13 @@
import unittest, sys, array
import testsupport
from pypy.objspace.std import cpythonobject
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.objspace import OperationError
-class TestW_CPythonObject(unittest.TestCase):
+class TestW_CPythonObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
# arbitrary always-wrapped object
self.stuff = array.array('b', [5,-2,77])
@@ -63,6 +63,7 @@
self.assertEquals(self.space.unwrap(w_result), expected)
def test_hash(self):
+ # i don't understand this test -- mwh
w1 = self.space.wrap(self.stuff)
try:
self.space.hash(w1)
@@ -76,4 +77,4 @@
self.assertEquals(self.space.unwrap(w_result), 11)
if __name__ == '__main__':
- unittest.main()
+ testsupport.main()
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 Sat Jun 7 20:26:03 2003
@@ -1,26 +1,24 @@
-import sys
import testsupport
-from pypy.objspace.std import dictobject as dobj
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.dictobject import W_DictObject
class TestW_DictObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
def test_empty(self):
space = self.space
- d = dobj.W_DictObject(space, [])
+ d = W_DictObject(space, [])
self.failIf_w(d)
def test_nonempty(self):
space = self.space
wNone = space.w_None
- d = dobj.W_DictObject(space, [(wNone, wNone)])
+ d = W_DictObject(space, [(wNone, wNone)])
self.failUnless(space.is_true(d))
i = space.getitem(d, wNone)
equal = space.eq(i, wNone)
@@ -30,7 +28,7 @@
space = self.space
wk1 = space.wrap('key')
wone = space.wrap(1)
- d = dobj.W_DictObject(space, [(space.wrap('zero'),space.wrap(0))])
+ d = W_DictObject(space, [(space.wrap('zero'),space.wrap(0))])
space.setitem(d,wk1,wone)
wback = space.getitem(d,wk1)
self.assertEqual_w(wback,wone)
@@ -38,19 +36,20 @@
def test_delitem(self):
space = self.space
wk1 = space.wrap('key')
- d = dobj.W_DictObject(space,
+ d = 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'))
self.assertEqual_w(space.getitem(d,space.wrap('zero')),space.wrap(0))
self.assertEqual_w(space.getitem(d,space.wrap('two')),space.wrap(2))
- self.failUnlessRaises(OperationError,space.getitem,d,space.wrap('one'))
+ self.assertRaises_w(self.space.w_KeyError,
+ space.getitem,d,space.wrap('one'))
def test_cell(self):
space = self.space
wk1 = space.wrap('key')
- d = dobj.W_DictObject(space, [])
+ d = W_DictObject(space, [])
w_cell = d.cell(space,wk1)
cell = space.unwrap(w_cell)
self.failUnless(cell.is_empty())
@@ -63,7 +62,7 @@
def test_wrap_dict(self):
- self.assert_(isinstance(self.space.wrap({}), dobj.W_DictObject))
+ self.assert_(isinstance(self.space.wrap({}), W_DictObject))
def test_dict_compare(self):
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 Sat Jun 7 20:26:03 2003
@@ -1,14 +1,12 @@
-import unittest, sys
+import sys
import testsupport
-from pypy.interpreter import unittest_w
from pypy.objspace.std import intobject as iobj
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.objspace import FailedToImplement
-
-class TestW_IntObject(unittest_w.TestCase_w):
+class TestW_IntObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
@@ -32,14 +30,6 @@
except FailedToImplement, arg:
return arg[0]
- def _unwrap_except(self, func, *args, **kwds):
- """ make sure that the expected exception occours, and unwrap it """
- try:
- res = func(*args, **kwds)
- raise Exception, "should have failed but returned '%s'!" %repr(res)
- except OperationError, e:
- return e.w_type
-
def test_repr(self):
x = 1
f1 = iobj.W_IntObject(self.space, x)
@@ -163,11 +153,13 @@
v = iobj.int_int_int_pow(self.space, f1, f2, f3)
self.assertEquals(v.intval, pow(x, y, z))
f1, f2, f3 = [iobj.W_IntObject(self.space, i) for i in (10, -1, 42)]
- self.assertEquals(self.space.w_TypeError,
- self._unwrap_except(iobj.int_int_int_pow, self.space, f1, f2, f3))
+ self.assertRaises_w(self.space.w_TypeError,
+ iobj.int_int_int_pow,
+ self.space, f1, f2, f3)
f1, f2, f3 = [iobj.W_IntObject(self.space, i) for i in (10, 5, 0)]
- self.assertEquals(self.space.w_ValueError,
- self._unwrap_except(iobj.int_int_int_pow, self.space, f1, f2, f3))
+ self.assertRaises_w(self.space.w_ValueError,
+ iobj.int_int_int_pow,
+ self.space, f1, f2, f3)
def test_pow_iin(self):
x = 10
@@ -294,4 +286,4 @@
self.assertEquals(self.space.unwrap(result), hex(x))
if __name__ == '__main__':
- unittest.main()
+ testsupport.main()
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 Sat Jun 7 20:26:03 2003
@@ -1,14 +1,11 @@
-import unittest, sys
import testsupport
-from pypy.interpreter import unittest_w
-from pypy.objspace.std import iterobject as iobj
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.iterobject import W_SeqIterObject
+from pypy.objspace.std.objspace import NoValue
-
-class TestW_IterObject(unittest_w.TestCase_w):
+class TestW_IterObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
@@ -16,7 +13,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(self.space, w_tuple)
+ w_iter = 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,9 +22,9 @@
def test_emptyiter(self):
w_list = self.space.newlist([])
- w_iter = iobj.W_SeqIterObject(self.space, w_list)
+ w_iter = W_SeqIterObject(self.space, w_list)
self.assertRaises(NoValue, self.space.next, w_iter)
self.assertRaises(NoValue, self.space.next, w_iter)
if __name__ == '__main__':
- unittest.main()
+ testsupport.main()
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 Sat Jun 7 20:26:03 2003
@@ -1,35 +1,33 @@
-from __future__ import nested_scopes
-import unittest, sys
+#from __future__ import nested_scopes
import testsupport
-from pypy.interpreter import unittest_w
-from pypy.objspace.std import listobject as lobj
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.listobject import W_ListObject
+from pypy.objspace.std.objspace import NoValue
-class TestW_ListObject(unittest_w.TestCase_w):
+class TestW_ListObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
def test_is_true(self):
w = self.space.wrap
- w_list = lobj.W_ListObject(self.space, [])
+ w_list = W_ListObject(self.space, [])
self.assertEqual(self.space.is_true(w_list), False)
- w_list = lobj.W_ListObject(self.space, [w(5)])
+ w_list = W_ListObject(self.space, [w(5)])
self.assertEqual(self.space.is_true(w_list), True)
- w_list = lobj.W_ListObject(self.space, [w(5), w(3)])
+ w_list = 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 = lobj.W_ListObject(self.space, [])
+ w_list = W_ListObject(self.space, [])
self.assertEqual_w(self.space.len(w_list), w(0))
- w_list = lobj.W_ListObject(self.space, [w(5)])
+ w_list = W_ListObject(self.space, [w(5)])
self.assertEqual_w(self.space.len(w_list), w(1))
- w_list = lobj.W_ListObject(self.space, [w(5), w(3), w(99)]*111)
+ w_list = 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,8 +35,8 @@
w = self.space.wrap
arg = w(2)
n = 3
- w_lis = lobj.W_ListObject(self.space, [arg])
- w_lis3 = lobj.W_ListObject(self.space, [arg]*n)
+ w_lis = W_ListObject(self.space, [arg])
+ w_lis3 = W_ListObject(self.space, [arg]*n)
w_res = self.space.mul(w_lis, w(n))
self.assertEqual_w(w_lis3, w_res)
# commute
@@ -47,7 +45,7 @@
def test_getitem(self):
w = self.space.wrap
- w_list = lobj.W_ListObject(self.space, [w(5), w(3)])
+ w_list = 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))
@@ -61,7 +59,7 @@
def test_iter(self):
w = self.space.wrap
- w_list = lobj.W_ListObject(self.space, [w(5), w(3), w(99)])
+ w_list = 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))
@@ -71,24 +69,25 @@
def test_add(self):
w = self.space.wrap
- w_list0 = lobj.W_ListObject(self.space, [])
- w_list1 = lobj.W_ListObject(self.space, [w(5), w(3), w(99)])
- w_list2 = lobj.W_ListObject(self.space, [w(-7)] * 111)
+ w_list0 = W_ListObject(self.space, [])
+ w_list1 = W_ListObject(self.space, [w(5), w(3), w(99)])
+ w_list2 = W_ListObject(self.space, [w(-7)] * 111)
self.assertEqual_w(self.space.add(w_list1, w_list1),
- lobj.W_ListObject(self.space, [w(5), w(3), w(99),
+ 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),
- lobj.W_ListObject(self.space, [w(5), w(3), w(99)] +
+ 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)
def test_getslice(self):
+ # this takes aaagggeeesss!!!
w = self.space.wrap
def test1(testlist, start, stop, step, expected):
w_slice = self.space.newslice(w(start), w(stop), w(step))
- w_list = lobj.W_ListObject(self.space, [w(i) for i in testlist])
+ w_list = 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)
@@ -106,9 +105,9 @@
def test_setitem(self):
w = self.space.wrap
- w_list = lobj.W_ListObject(self.space, [w(5), w(3)])
- w_exp1 = lobj.W_ListObject(self.space, [w(5), w(7)])
- w_exp2 = lobj.W_ListObject(self.space, [w(8), w(7)])
+ w_list = W_ListObject(self.space, [w(5), w(3)])
+ w_exp1 = W_ListObject(self.space, [w(5), w(7)])
+ w_exp2 = W_ListObject(self.space, [w(8), w(7)])
self.space.setitem(w_list, w(1), w(7))
self.assertEqual_w(w_exp1, w_list)
self.space.setitem(w_list, w(-2), w(8))
@@ -120,4 +119,4 @@
if __name__ == '__main__':
- unittest.main()
+ testsupport.main()
Modified: pypy/trunk/src/pypy/objspace/std/test/test_moduleobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_moduleobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_moduleobject.py Sat Jun 7 20:26:03 2003
@@ -1,21 +1,18 @@
-import unittest, sys
import testsupport
-from pypy.interpreter import unittest_w
-from pypy.objspace.std import moduleobject as mobj
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.moduleobject import W_ModuleObject
-class TestW_ModuleObject(unittest_w.TestCase_w):
+class TestW_ModuleObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
def test_name(self):
space = self.space
- w_m = mobj.W_ModuleObject(space, space.wrap('somename'))
+ w_m = W_ModuleObject(space, space.wrap('somename'))
self.assertEqual_w(space.getattr(w_m, space.wrap('__name__')),
space.wrap('somename'))
@@ -23,7 +20,7 @@
space = self.space
w_x = space.wrap(123)
w_yy = space.w_True
- w_m = mobj.W_ModuleObject(space, space.wrap('somename'))
+ w_m = W_ModuleObject(space, space.wrap('somename'))
space.setattr(w_m, space.wrap('x'), w_x)
space.setattr(w_m, space.wrap('yy'), w_yy)
self.assertEqual_w(space.getattr(w_m, space.wrap('x')), w_x)
@@ -34,4 +31,4 @@
self.assertEqual_w(space.getattr(w_m, space.wrap('yy')), w_yy)
if __name__ == '__main__':
- unittest.main()
+ testsupport.main()
Modified: pypy/trunk/src/pypy/objspace/std/test/test_noneobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_noneobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_noneobject.py Sat Jun 7 20:26:03 2003
@@ -1,11 +1,10 @@
import testsupport
-from pypy.objspace.std.objspace import StdObjSpace
class TestW_NoneObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
Modified: pypy/trunk/src/pypy/objspace/std/test/test_restricted_int.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_restricted_int.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_restricted_int.py Sat Jun 7 20:26:03 2003
@@ -1,4 +1,4 @@
-import unittest, sys
+import unittest
import testsupport
from pypy.objspace.std.restricted_int import *
Modified: pypy/trunk/src/pypy/objspace/std/test/test_sliceobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_sliceobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_sliceobject.py Sat Jun 7 20:26:03 2003
@@ -1,10 +1,9 @@
import testsupport
-from pypy.objspace.std import StdObjSpace
class TestW_SliceObject(testsupport.TestCase):
def setUp(self):
- self.space = testsupport.objspace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
@@ -24,13 +23,11 @@
w_slice = space.newslice(w_None, w_None, w(-1))
self.equal_indices(w_slice.indices(w(6)), (5, -1, -1, 6))
- def XXXtest_indices_fail(self):
- """ usual exception problems """
+ def test_indices_fail(self):
space = self.space
w = space.wrap
w_None = space.w_None
w_slice = space.newslice(w_None, w_None, w(0))
- self.equal_indices(w_slice.indices(w(6)), (5, -1, -1, 6))
self.assertRaises_w(space.w_ValueError,
w_slice.indices, w(10))
Modified: pypy/trunk/src/pypy/objspace/std/test/test_stdobjspace.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_stdobjspace.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_stdobjspace.py Sat Jun 7 20:26:03 2003
@@ -1,11 +1,9 @@
import testsupport
-from pypy.objspace.std import StdObjSpace
-
class TestW_StdObjSpace(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
@@ -15,6 +13,10 @@
self.space.wrap,
self.space.wrap(0))
+ def hopeful_test_exceptions(self):
+ self.apptest("self.failUnless(issubclass(ArithmeticError, Exception))")
+ self.apptest("self.failIf(issubclass(ArithmeticError, KeyError))")
+
if __name__ == '__main__':
testsupport.main()
Modified: pypy/trunk/src/pypy/objspace/std/test/test_stringobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_stringobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_stringobject.py Sat Jun 7 20:26:03 2003
@@ -1,8 +1,8 @@
import testsupport
-import pypy.objspace.std.stringobject as so
+from pypy.objspace.std import stringobject
-from pypy.objspace.std.stringobject import string_richcompare, W_StringObject, EQ, LT, GT, NE, LE, GE
-from pypy.objspace.std.objspace import StdObjSpace
+from pypy.objspace.std.stringobject import \
+ string_richcompare, W_StringObject, EQ, LT, GT, NE, LE, GE
class TestW_StringObject(testsupport.TestCase):
@@ -23,16 +23,23 @@
while strs[1:]:
str1 = strs.pop()
for op in ops:
- orf = getattr(str1, '__%s__' % op.lower()) #original python function
- pypyconst = getattr(so, op)
+ #original python function
+ orf = getattr(str1, '__%s__' % op.lower())
+ pypyconst = getattr(stringobject, op)
for str2 in strs:
if orf(str2):
- self.failUnless_w(string_richcompare(space, w(str1), w(str2), pypyconst))
+ self.failUnless_w(
+ string_richcompare(space,
+ w(str1),
+ w(str2),
+ pypyconst))
else:
- self.failIf_w(string_richcompare(space, w(str1), w(str2), pypyconst))
+ self.failIf_w(
+ string_richcompare(space,
+ w(str1),
+ w(str2),
+ pypyconst))
-
-
def test_equality(self):
w = self.space.wrap
self.assertEqual_w(w('abc'), w('abc'))
@@ -103,7 +110,5 @@
w_slice = space.newslice(w(1), w_None, w(2))
self.assertEqual_w(space.getitem(w_str, w_slice), w('el'))
-
-
if __name__ == '__main__':
testsupport.main()
Modified: pypy/trunk/src/pypy/objspace/std/test/test_tupleobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_tupleobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_tupleobject.py Sat Jun 7 20:26:03 2003
@@ -1,40 +1,38 @@
-from __future__ import nested_scopes
-import unittest, sys
+#from __future__ import nested_scopes
import testsupport
-from pypy.interpreter import unittest_w
-from pypy.objspace.std import tupleobject as tobj
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.tupleobject import W_TupleObject
+from pypy.objspace.std.objspace import NoValue
-class TestW_TupleObject(unittest_w.TestCase_w):
+class TestW_TupleObject(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
def test_is_true(self):
w = self.space.wrap
- w_tuple = tobj.W_TupleObject(self.space, [])
+ w_tuple = W_TupleObject(self.space, [])
self.assertEqual(self.space.is_true(w_tuple), False)
- w_tuple = tobj.W_TupleObject(self.space, [w(5)])
+ w_tuple = W_TupleObject(self.space, [w(5)])
self.assertEqual(self.space.is_true(w_tuple), True)
- w_tuple = tobj.W_TupleObject(self.space, [w(5), w(3)])
+ w_tuple = W_TupleObject(self.space, [w(5), w(3)])
self.assertEqual(self.space.is_true(w_tuple), True)
def test_len(self):
w = self.space.wrap
- w_tuple = tobj.W_TupleObject(self.space, [])
+ w_tuple = W_TupleObject(self.space, [])
self.assertEqual_w(self.space.len(w_tuple), w(0))
- w_tuple = tobj.W_TupleObject(self.space, [w(5)])
+ w_tuple = W_TupleObject(self.space, [w(5)])
self.assertEqual_w(self.space.len(w_tuple), w(1))
- w_tuple = tobj.W_TupleObject(self.space, [w(5), w(3), w(99)]*111)
+ w_tuple = W_TupleObject(self.space, [w(5), w(3), w(99)]*111)
self.assertEqual_w(self.space.len(w_tuple), w(333))
def test_getitem(self):
w = self.space.wrap
- w_tuple = tobj.W_TupleObject(self.space, [w(5), w(3)])
+ w_tuple = W_TupleObject(self.space, [w(5), w(3)])
self.assertEqual_w(self.space.getitem(w_tuple, w(0)), w(5))
self.assertEqual_w(self.space.getitem(w_tuple, w(1)), w(3))
self.assertEqual_w(self.space.getitem(w_tuple, w(-2)), w(5))
@@ -48,7 +46,7 @@
def test_iter(self):
w = self.space.wrap
- w_tuple = tobj.W_TupleObject(self.space, [w(5), w(3), w(99)])
+ w_tuple = W_TupleObject(self.space, [w(5), w(3), w(99)])
w_iter = self.space.iter(w_tuple)
self.assertEqual_w(self.space.next(w_iter), w(5))
self.assertEqual_w(self.space.next(w_iter), w(3))
@@ -58,7 +56,7 @@
def test_contains(self):
w = self.space.wrap
- w_tuple = tobj.W_TupleObject(self.space, [w(5), w(3), w(99)])
+ w_tuple = W_TupleObject(self.space, [w(5), w(3), w(99)])
self.assertEqual_w(self.space.contains(w_tuple, w(5)),
self.space.w_True)
self.assertEqual_w(self.space.contains(w_tuple, w(99)),
@@ -70,15 +68,15 @@
def test_add(self):
w = self.space.wrap
- w_tuple0 = tobj.W_TupleObject(self.space, [])
- w_tuple1 = tobj.W_TupleObject(self.space, [w(5), w(3), w(99)])
- w_tuple2 = tobj.W_TupleObject(self.space, [w(-7)] * 111)
+ w_tuple0 = W_TupleObject(self.space, [])
+ w_tuple1 = W_TupleObject(self.space, [w(5), w(3), w(99)])
+ w_tuple2 = W_TupleObject(self.space, [w(-7)] * 111)
self.assertEqual_w(self.space.add(w_tuple1, w_tuple1),
- tobj.W_TupleObject(self.space, [w(5), w(3), w(99),
- w(5), w(3), w(99)]))
+ W_TupleObject(self.space, [w(5), w(3), w(99),
+ w(5), w(3), w(99)]))
self.assertEqual_w(self.space.add(w_tuple1, w_tuple2),
- tobj.W_TupleObject(self.space, [w(5), w(3), w(99)] +
- [w(-7)] * 111))
+ W_TupleObject(self.space,
+ [w(5), w(3), w(99)] + [w(-7)] * 111))
self.assertEqual_w(self.space.add(w_tuple1, w_tuple0), w_tuple1)
self.assertEqual_w(self.space.add(w_tuple0, w_tuple2), w_tuple2)
@@ -87,8 +85,8 @@
w = self.space.wrap
arg = w(2)
n = 3
- w_tup = tobj.W_TupleObject(self.space, [arg])
- w_tup3 = tobj.W_TupleObject(self.space, [arg]*n)
+ w_tup = W_TupleObject(self.space, [arg])
+ w_tup3 = W_TupleObject(self.space, [arg]*n)
w_res = self.space.mul(w_tup, w(n))
self.assertEqual_w(w_tup3, w_res)
# commute
@@ -100,7 +98,7 @@
def test1(testtuple, start, stop, step, expected):
w_slice = self.space.newslice(w(start), w(stop), w(step))
- w_tuple = tobj.W_TupleObject(self.space, [w(i) for i in testtuple])
+ w_tuple = W_TupleObject(self.space, [w(i) for i in testtuple])
w_result = self.space.getitem(w_tuple, w_slice)
self.assertEqual(self.space.unwrap(w_result), expected)
@@ -117,4 +115,4 @@
test1((5,7,1,4), -5, 11, 2, (5, 1))
if __name__ == '__main__':
- unittest.main()
+ testsupport.main()
Modified: pypy/trunk/src/pypy/objspace/std/test/test_typeobject.py
==============================================================================
--- pypy/trunk/src/pypy/objspace/std/test/test_typeobject.py (original)
+++ pypy/trunk/src/pypy/objspace/std/test/test_typeobject.py Sat Jun 7 20:26:03 2003
@@ -1,14 +1,10 @@
-import unittest, sys
import testsupport
-from pypy.interpreter import unittest_w
-from pypy.objspace.std import typeobject as tobj
-from pypy.objspace.std.objspace import *
+from pypy.objspace.std.typeobject import PyMultimethodCode
-
-class TestPyMultimethodCode(unittest_w.TestCase_w):
+class TestPyMultimethodCode(testsupport.TestCase):
def setUp(self):
- self.space = StdObjSpace()
+ self.space = testsupport.stdobjspace()
def tearDown(self):
pass
@@ -16,8 +12,8 @@
def test_int_sub(self):
w = self.space.wrap
for i in range(2):
- meth = tobj.PyMultimethodCode(self.space.sub.multimethod,
- i, self.space.w_int)
+ meth = PyMultimethodCode(self.space.sub.multimethod,
+ i, self.space.w_int)
self.assertEqual(meth.slice().is_empty(), False)
# test int.__sub__ and int.__rsub__
self.assertEqual_w(meth.eval_code(self.space, None,
@@ -32,16 +28,16 @@
def test_empty_inplace_add(self):
for i in range(2):
- meth = tobj.PyMultimethodCode(self.space.inplace_add.multimethod,
- i, self.space.w_int)
+ meth = PyMultimethodCode(self.space.inplace_add.multimethod,
+ i, self.space.w_int)
self.assertEqual(meth.slice().is_empty(), True)
def test_float_sub(self):
w = self.space.wrap
w(1.5) # force floatobject imported
for i in range(2):
- meth = tobj.PyMultimethodCode(self.space.sub.multimethod,
- i, self.space.w_float)
+ meth = PyMultimethodCode(self.space.sub.multimethod,
+ i, self.space.w_float)
self.assertEqual(meth.slice().is_empty(), False)
# test float.__sub__ and float.__rsub__
@@ -59,4 +55,4 @@
if __name__ == '__main__':
- unittest.main()
+ testsupport.main()
More information about the Pypy-commit
mailing list