[pypy-svn] r8197 - in pypy/branch/src-pytest/pypy: . objspace/std/test tool
pedronis at codespeak.net
pedronis at codespeak.net
Mon Jan 10 17:19:40 CET 2005
Author: pedronis
Date: Mon Jan 10 17:19:39 2005
New Revision: 8197
Modified:
pypy/branch/src-pytest/pypy/conftest.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_boolobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_dictobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_dictproxy.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_instmethobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_iterobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_listobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_multimethod.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_noneobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_restricted_int.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_sliceobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_stdobjspace.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_stringformat.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_stringobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_strutil.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_tupleobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_typeobject.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_unicodestring.py
pypy/branch/src-pytest/pypy/objspace/std/test/test_userobject.py
pypy/branch/src-pytest/pypy/tool/fiximport.py
Log:
- conftest sticks py.test.raises as raises in tests module global
namespace.
- ported objspace/std/test tests
Modified: pypy/branch/src-pytest/pypy/conftest.py
==============================================================================
--- pypy/branch/src-pytest/pypy/conftest.py (original)
+++ pypy/branch/src-pytest/pypy/conftest.py Mon Jan 10 17:19:39 2005
@@ -83,10 +83,12 @@
class PyPyItem(py.test.Item):
# All PyPy test items catch and display OperationErrors specially.
- #def setup_module(self, mod):
+ def setup_module(self, mod):
# if hasattr(mod, 'objspacename'):
# mod.space = getttestobjspace(mod.objspacename)
- # super(PyPyItem, self).setup_module(mod)
+ # stick py.test raise in module globals
+ mod.raises = py.test.raises
+ super(PyPyItem, self).setup_module(mod)
def setup_class(self, cls):
name = getattr(cls, 'objspacename', None)
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_boolobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_boolobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_boolobject.py Mon Jan 10 17:19:39 2005
@@ -1,42 +1,33 @@
import autopath
-from pypy.tool import testit
-class TestW_BoolObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
+class TestW_BoolObject:
+
+ def setup_method(self,method):
self.true = self.space.w_True
self.false = self.space.w_False
self.wrap = self.space.wrap
- def tearDown(self):
- pass
-
def test_repr(self):
- self.assertEqual_w(self.space.repr(self.true), self.wrap("True"))
- self.assertEqual_w(self.space.repr(self.false), self.wrap("False"))
+ assert self.space.eq_w(self.space.repr(self.true), self.wrap("True"))
+ assert self.space.eq_w(self.space.repr(self.false), self.wrap("False"))
def test_true(self):
- self.failUnless_w(self.true)
+ assert self.space.is_true(self.true)
def test_false(self):
- self.failIf_w(self.false)
+ assert not self.space.is_true(self.false)
-class AppBoolTest(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
-
+class AppTestAppBoolTest:
def test_bool_callable(self):
- self.assertEquals(True, bool(1))
- self.assertEquals(False, bool(0))
- self.assertEquals(False, bool())
+ assert True == bool(1)
+ assert False == bool(0)
+ assert False == bool()
def test_bool_string(self):
- self.assertEquals("True", str(True))
- self.assertEquals("False", str(False))
- self.assertEquals("True", repr(True))
- self.assertEquals("False", repr(False))
-
-if __name__ == '__main__':
- testit.main()
+ assert "True" == str(True)
+ assert "False" == str(False)
+ assert "True" == repr(True)
+ assert "False" == repr(False)
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_dictobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_dictobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_dictobject.py Mon Jan 10 17:19:39 2005
@@ -1,29 +1,24 @@
import autopath
-from pypy.tool import testit
from pypy.objspace.std.dictobject import W_DictObject
-class TestW_DictObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
-
- def tearDown(self):
- pass
+class TestW_DictObject:
def test_empty(self):
space = self.space
d = W_DictObject(space, [])
- self.failIf_w(d)
+ assert not self.space.is_true(d)
def test_nonempty(self):
space = self.space
wNone = space.w_None
d = W_DictObject(space, [(wNone, wNone)])
- self.failUnless(space.is_true(d))
+ assert space.is_true(d)
i = space.getitem(d, wNone)
equal = space.eq(i, wNone)
- self.failUnless(space.is_true(equal))
+ assert space.is_true(equal)
def test_setitem(self):
space = self.space
@@ -32,7 +27,7 @@
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)
+ assert self.space.eq_w(wback,wone)
def test_delitem(self):
space = self.space
@@ -42,13 +37,13 @@
(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.assertRaises_w(self.space.w_KeyError,
+ assert self.space.eq_w(space.getitem(d,space.wrap('zero')),space.wrap(0))
+ assert self.space.eq_w(space.getitem(d,space.wrap('two')),space.wrap(2))
+ self.space.raises_w(self.space.w_KeyError,
space.getitem,d,space.wrap('one'))
def test_wrap_dict(self):
- self.assert_(isinstance(self.space.wrap({}), W_DictObject))
+ assert isinstance(self.space.wrap({}), W_DictObject)
def test_dict_compare(self):
@@ -56,13 +51,13 @@
w0, w1, w2, w3 = map(w, range(4))
wd1 = self.space.newdict([(w0, w1), (w2, w3)])
wd2 = self.space.newdict([(w2, w3), (w0, w1)])
- self.assertEqual_w(wd1, wd2)
+ assert self.space.eq_w(wd1, wd2)
wd3 = self.space.newdict([(w2, w2), (w0, w1)])
- self.assertNotEqual_w(wd1, wd3)
+ assert not self.space.eq_w(wd1, wd3)
wd4 = self.space.newdict([(w3, w3), (w0, w1)])
- self.assertNotEqual_w(wd1, wd4)
+ assert not self.space.eq_w(wd1, wd4)
wd5 = self.space.newdict([(w3, w3)])
- self.assertNotEqual_w(wd1, wd4)
+ assert not self.space.eq_w(wd1, wd4)
def test_dict_call(self):
space = self.space
@@ -73,16 +68,16 @@
def deepwrap(lp):
return [[w(a),w(b)] for a,b in lp]
d = mydict()
- self.assertEqual_w(d, w({}))
+ assert self.space.eq_w(d, w({}))
args = w(([['a',2],[23,45]],))
d = mydict(args)
- self.assertEqual_w(d, wd(deepwrap([['a',2],[23,45]])))
+ assert self.space.eq_w(d, wd(deepwrap([['a',2],[23,45]])))
d = mydict(args, w({'a':33, 'b':44}))
- self.assertEqual_w(d, wd(deepwrap([['a',33],['b',44],[23,45]])))
+ assert self.space.eq_w(d, wd(deepwrap([['a',33],['b',44],[23,45]])))
d = mydict(w_kwds=w({'a':33, 'b':44}))
- self.assertEqual_w(d, wd(deepwrap([['a',33],['b',44]])))
- self.assertRaises_w(space.w_TypeError, mydict, w((23,)))
- self.assertRaises_w(space.w_ValueError, mydict, w(([[1,2,3]],)))
+ assert self.space.eq_w(d, wd(deepwrap([['a',33],['b',44]])))
+ self.space.raises_w(space.w_TypeError, mydict, w((23,)))
+ self.space.raises_w(space.w_ValueError, mydict, w(([[1,2,3]],)))
def test_dict_pop(self):
space = self.space
@@ -94,19 +89,19 @@
dd = mydict(w_kwds=w({"1":2, "3":4})) # means d.copy()
pop = space.getattr(dd, w("pop"))
result = space.call_function(pop, w("1"))
- self.assertEqual_w(result, w(2))
- self.assertEqual_w(space.len(dd), w(1))
+ assert self.space.eq_w(result, w(2))
+ assert self.space.eq_w(space.len(dd), w(1))
dd = mydict(w_kwds=w({"1":2, "3":4})) # means d.copy()
pop = space.getattr(dd, w("pop"))
result = space.call_function(pop, w("1"), w(44))
- self.assertEqual_w(result, w(2))
- self.assertEqual_w(space.len(dd), w(1))
+ assert self.space.eq_w(result, w(2))
+ assert self.space.eq_w(space.len(dd), w(1))
result = space.call_function(pop, w("1"), w(44))
- self.assertEqual_w(result, w(44))
- self.assertEqual_w(space.len(dd), w(1))
+ assert self.space.eq_w(result, w(44))
+ assert self.space.eq_w(space.len(dd), w(1))
- self.assertRaises_w(space.w_KeyError, space.call_function, pop, w(33))
+ self.space.raises_w(space.w_KeyError, space.call_function, pop, w(33))
def test_get(self):
space = self.space
@@ -115,142 +110,139 @@
return space.call(space.w_dict, w_args, w_kwds)
d = mydict(w_kwds=w({"1":2, "3":4}))
get = space.getattr(d, w("get"))
- self.assertEqual_w(space.call_function(get, w("1")), w(2))
- self.assertEqual_w(space.call_function(get, w("1"), w(44)), w(2))
- self.assertEqual_w(space.call_function(get, w("33")), w(None))
- self.assertEqual_w(space.call_function(get, w("33"), w(44)), w(44))
+ assert self.space.eq_w(space.call_function(get, w("1")), w(2))
+ assert self.space.eq_w(space.call_function(get, w("1"), w(44)), w(2))
+ assert self.space.eq_w(space.call_function(get, w("33")), w(None))
+ assert self.space.eq_w(space.call_function(get, w("33"), w(44)), w(44))
-class Test_DictObject(testit.AppTestCase):
+class AppTest_DictObject:
- def setUp(self):
- self.space = testit.objspace('std')
-
def test_equality(self):
d = {1:2}
f = {1:2}
- self.assert_(d == f)
- self.assert_(d != {1:3})
+ assert d == f
+ assert d != {1:3}
def test_clear(self):
d = {1:2, 3:4}
d.clear()
- self.assertEqual(len(d), 0)
+ assert len(d) == 0
def test_copy(self):
d = {1:2, 3:4}
dd = d.copy()
- self.assertEqual(d, dd)
- self.failIf(d is dd)
+ assert d == dd
+ assert not d is dd
def tooslow_test_get(self):
d = {1:2, 3:4}
- self.assertEqual(d.get(1), 2)
- self.assertEqual(d.get(1,44), 2)
- self.assertEqual(d.get(33), None)
- self.assertEqual(d.get(33,44), 44)
+ assert d.get(1) == 2
+ assert d.get(1,44) == 2
+ assert d.get(33) == None
+ assert d.get(33,44) == 44
def tooslow_test_pop(self):
d = {1:2, 3:4}
dd = d.copy()
result = dd.pop(1)
- self.assertEqual(result, 2)
- self.assertEqual(len(dd), 1)
+ assert result == 2
+ assert len(dd) == 1
dd = d.copy()
result = dd.pop(1, 44)
- self.assertEqual(result, 2)
- self.assertEqual(len(dd), 1)
+ assert result == 2
+ assert len(dd) == 1
result = dd.pop(1, 44)
- self.assertEqual(result, 44)
- self.assertEqual(len(dd), 1)
- self.assertRaises(KeyError, dd.pop, 33)
+ assert result == 44
+ assert len(dd) == 1
+ raises(KeyError, dd.pop, 33)
def test_has_key(self):
d = {1:2, 3:4}
- self.failUnless(d.has_key(1))
- self.failIf(d.has_key(33))
+ assert d.has_key(1)
+ assert not d.has_key(33)
def test_items(self):
d = {1:2, 3:4}
its = d.items()
its.sort()
- self.assertEqual(its, [(1,2),(3,4)])
+ assert its == [(1,2),(3,4)]
def test_iteritems(self):
d = {1:2, 3:4}
dd = d.copy()
for k, v in d.iteritems():
- self.assertEqual(v, dd[k])
+ assert v == dd[k]
del dd[k]
- self.failIf(dd)
+ assert not dd
def test_iterkeys(self):
d = {1:2, 3:4}
dd = d.copy()
for k in d.iterkeys():
del dd[k]
- self.failIf(dd)
+ assert not dd
def test_itervalues(self):
d = {1:2, 3:4}
values = []
for k in d.itervalues():
values.append(k)
- self.assertEqual(values, d.values())
+ assert values == d.values()
def test_keys(self):
d = {1:2, 3:4}
kys = d.keys()
kys.sort()
- self.assertEqual(kys, [1,3])
+ assert kys == [1,3]
def test_popitem(self):
d = {1:2, 3:4}
it = d.popitem()
- self.assertEqual(len(d), 1)
- self.failUnless(it==(1,2) or it==(3,4))
+ assert len(d) == 1
+ assert it==(1,2) or it==(3,4)
it1 = d.popitem()
- self.assertEqual(len(d), 0)
- self.failUnless((it!=it1) and (it1==(1,2) or it1==(3,4)))
+ assert len(d) == 0
+ assert (it!=it1) and (it1==(1,2) or it1==(3,4))
def test_setdefault(self):
d = {1:2, 3:4}
dd = d.copy()
x = dd.setdefault(1, 99)
- self.assertEqual(d, dd)
- self.assertEqual(x, 2)
+ assert d == dd
+ assert x == 2
x = dd.setdefault(33, 99)
d[33] = 99
- self.assertEqual(d, dd)
- self.assertEqual(x, 99)
+ assert d == dd
+ assert x == 99
def test_update(self):
d = {1:2, 3:4}
dd = d.copy()
d.update({})
- self.assertEqual(d, dd)
+ assert d == dd
d.update({3:5, 6:7})
- self.assertEqual(d, {1:2, 3:5, 6:7})
+ assert d == {1:2, 3:5, 6:7}
def test_values(self):
d = {1:2, 3:4}
vals = d.values()
vals.sort()
- self.assertEqual(vals, [2,4])
+ assert vals == [2,4]
def test_eq(self):
d1 = {1:2, 3:4}
d2 = {1:2, 3:4}
d3 = {1:2}
bool = d1 == d2
- self.assertEqual(bool, True)
+ assert bool == True
bool = d1 == d3
- self.assertEqual(bool, False)
+ assert bool == False
bool = d1 != d2
- self.assertEqual(bool, False)
+ assert bool == False
bool = d1 != d3
- self.assertEqual(bool, True)
+ assert bool == True
def test_lt(self):
d1 = {1:2, 3:4}
@@ -258,36 +250,36 @@
d3 = {1:2, 3:5}
d4 = {1:2}
bool = d1 < d2
- self.assertEqual(bool, False)
+ assert bool == False
bool = d1 < d3
- self.assertEqual(bool, True)
+ assert bool == True
bool = d1 < d4
- self.assertEqual(bool, False)
+ assert bool == False
def test_str_repr(self):
- self.assertEqual('{}', str({}))
- self.assertEqual('{1: 2}', str({1: 2}))
- self.assertEqual("{'ba': 'bo'}", str({'ba': 'bo'}))
+ assert '{}' == str({})
+ assert '{1: 2}' == str({1: 2})
+ assert "{'ba': 'bo'}" == str({'ba': 'bo'})
# NOTE: the string repr depends on hash values of 1 and 'ba'!!!
ok_reprs = ["{1: 2, 'ba': 'bo'}", "{'ba': 'bo', 1: 2}"]
- self.assert_(str({1: 2, 'ba': 'bo'}) in ok_reprs)
- self.assertEqual('{}', repr({}))
- self.assertEqual('{1: 2}', repr({1: 2}))
- self.assertEqual("{'ba': 'bo'}", repr({'ba': 'bo'}))
- self.assert_(str({1: 2, 'ba': 'bo'}) in ok_reprs)
+ assert str({1: 2, 'ba': 'bo'}) in ok_reprs
+ assert '{}' == repr({})
+ assert '{1: 2}' == repr({1: 2})
+ assert "{'ba': 'bo'}" == repr({'ba': 'bo'})
+ assert str({1: 2, 'ba': 'bo'}) in ok_reprs
def test_new(self):
d = dict()
- self.assertEqual(d, {})
+ assert d == {}
args = [['a',2], [23,45]]
d = dict(args)
- self.assertEqual(d, {'a':2, 23:45})
+ assert d == {'a':2, 23:45}
d = dict(args, a=33, b=44)
- self.assertEqual(d, {'a':33, 'b':44, 23:45})
+ assert d == {'a':33, 'b':44, 23:45}
d = dict(a=33, b=44)
- self.assertEqual(d, {'a':33, 'b':44})
+ assert d == {'a':33, 'b':44}
d = dict({'a':33, 'b':44})
- self.assertEqual(d, {'a':33, 'b':44})
+ assert d == {'a':33, 'b':44}
try: d = dict(23)
except (TypeError, ValueError): pass
else: self.fail("dict(23) should raise!")
@@ -296,10 +288,10 @@
else: self.fail("dict([[1,2,3]]) should raise!")
def test_fromkeys(self):
- self.assertEquals({}.fromkeys([1, 2], 1), {1: 1, 2: 1})
- self.assertEquals({}.fromkeys([1, 2]), {1: None, 2: None})
- self.assertEquals({}.fromkeys([]), {})
- self.assertEquals({1: 0, 2: 0, 3: 0}.fromkeys([1, '1'], 'j'),
+ assert {}.fromkeys([1, 2], 1) == {1: 1, 2: 1}
+ assert {}.fromkeys([1, 2]) == {1: None, 2: None}
+ assert {}.fromkeys([]) == {}
+ assert {1: 0, 2: 0, 3: 0}.fromkeys([1, '1'], 'j') == (
{1: 'j', '1': 'j'})
# the minimal 'space' needed to use a W_DictObject
@@ -317,14 +309,11 @@
from pypy.objspace.std.dictobject import getitem__Dict_ANY, setitem__Dict_ANY_ANY
-class TestDictImplementation(testit.TestCase):
+class TestDictImplementation:
- def setUp(self):
+ def setup_method(self,method):
self.space = FakeSpace()
- def tearDown(self):
- pass
-
def test_stressdict(self):
from random import randint
d = W_DictObject(self.space, [])
@@ -335,8 +324,4 @@
setitem__Dict_ANY_ANY(self.space, d, x, i)
pydict[x] = i
for x in pydict:
- self.assertEqual(pydict[x], getitem__Dict_ANY(self.space, d, x))
-
-
-if __name__ == '__main__':
- testit.main()
+ assert pydict[x] == getitem__Dict_ANY(self.space, d, x)
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_dictproxy.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_dictproxy.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_dictproxy.py Mon Jan 10 17:19:39 2005
@@ -1,25 +1,20 @@
import autopath
-from pypy.tool import testit
-class TestUserObject(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
+objspacename = 'std'
+class AppTestUserObject:
def test_dictproxy(self):
class NotEmpty:
a = 1
- self.assertEquals(isinstance(NotEmpty.__dict__, dict), False)
- self.assert_('a' in NotEmpty.__dict__)
- self.assert_('a' in NotEmpty.__dict__.keys())
- self.assert_('b' not in NotEmpty.__dict__)
- self.assert_(isinstance(NotEmpty.__dict__.copy(), dict))
- self.assert_(NotEmpty.__dict__ == NotEmpty.__dict__.copy())
+ assert isinstance(NotEmpty.__dict__, dict) == False
+ assert 'a' in NotEmpty.__dict__
+ assert 'a' in NotEmpty.__dict__.keys()
+ assert 'b' not in NotEmpty.__dict__
+ assert isinstance(NotEmpty.__dict__.copy(), dict)
+ assert NotEmpty.__dict__ == NotEmpty.__dict__.copy()
try:
NotEmpty.__dict__['b'] = 1
except:
pass
else:
raise AssertionError, 'this should not have been writable'
-
-if __name__ == '__main__':
- testit.main()
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_instmethobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_instmethobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_instmethobject.py Mon Jan 10 17:19:39 2005
@@ -1,37 +1,32 @@
import autopath
-from pypy.tool import testit
# NB. instmethobject.py has been removed,
# but the following tests still make sense
-class TestInstMethObjectApp(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
+objspacename = 'std'
+class AppTestInstMethObjectApp:
def test_callBound(self):
boundMethod = [1,2,3].__len__
- self.assertEquals(boundMethod(), 3)
- self.assertRaises(TypeError, boundMethod, 333)
+ assert boundMethod() == 3
+ raises(TypeError, boundMethod, 333)
def test_callUnbound(self):
unboundMethod = list.__len__
- self.assertEquals(unboundMethod([1,2,3]), 3)
- self.assertRaises(TypeError, unboundMethod)
- self.assertRaises(TypeError, unboundMethod, 333)
- self.assertRaises(TypeError, unboundMethod, [1,2,3], 333)
+ assert unboundMethod([1,2,3]) == 3
+ raises(TypeError, unboundMethod)
+ raises(TypeError, unboundMethod, 333)
+ raises(TypeError, unboundMethod, [1,2,3], 333)
def test_getBound(self):
def f(l,x): return l[x+1]
bound = f.__get__('abcdef')
- self.assertEquals(bound(1), 'c')
- self.assertRaises(TypeError, bound)
- self.assertRaises(TypeError, bound, 2, 3)
+ assert bound(1) == 'c'
+ raises(TypeError, bound)
+ raises(TypeError, bound, 2, 3)
def test_getUnbound(self):
def f(l,x): return l[x+1]
unbound = f.__get__(None, str)
- self.assertEquals(unbound('abcdef', 2), 'd')
- self.assertRaises(TypeError, unbound)
- self.assertRaises(TypeError, unbound, 4)
- self.assertRaises(TypeError, unbound, 4, 5)
-
-if __name__ == '__main__':
- testit.main()
+ assert unbound('abcdef', 2) == 'd'
+ raises(TypeError, unbound)
+ raises(TypeError, unbound, 4)
+ raises(TypeError, unbound, 4, 5)
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_iterobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_iterobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_iterobject.py Mon Jan 10 17:19:39 2005
@@ -1,26 +1,21 @@
import autopath
from pypy.objspace.std.iterobject import W_SeqIterObject
from pypy.interpreter.error import OperationError
-from pypy.tool import testit
-class TestW_IterObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
-
- def tearDown(self):
- pass
+class TestW_IterObject:
def body3(self, w_iter):
w = self.space.wrap
- 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))
+ assert self.space.eq_w(self.space.next(w_iter), w(5))
+ assert self.space.eq_w(self.space.next(w_iter), w(3))
+ assert self.space.eq_w(self.space.next(w_iter), w(99))
self.body0(w_iter)
def body0(self, w_iter):
- self.assertRaises(OperationError, self.space.next, w_iter)
- self.assertRaises(OperationError, self.space.next, w_iter)
+ raises(OperationError, self.space.next, w_iter)
+ raises(OperationError, self.space.next, w_iter)
def test_iter(self):
w = self.space.wrap
@@ -44,31 +39,24 @@
w_iter = self.space.iter(w_list)
self.body0(w_iter)
-class TestW_IterObjectApp(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
-
+class AppTestW_IterObjectApp:
def test_user_iter(self):
class C:
def next(self):
raise StopIteration
def __iter__(self):
return self
- self.assertEquals(list(C()), [])
+ assert list(C()) == []
def test_iter_getitem(self):
class C:
def __getitem__(self, i):
return range(2)[i]
- self.assertEquals(list(C()), range(2))
+ assert list(C()) == range(2)
def test_iter_fail_noseq(self):
class C:
pass
- self.assertRaises(TypeError,
+ raises(TypeError,
iter,
C())
-
-
-if __name__ == '__main__':
- testit.main()
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_listobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_listobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_listobject.py Mon Jan 10 17:19:39 2005
@@ -2,69 +2,64 @@
import autopath
from pypy.objspace.std.listobject import W_ListObject
from pypy.interpreter.error import OperationError
-from pypy.tool import testit
-class TestW_ListObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
-
- def tearDown(self):
- pass
+class TestW_ListObject:
def test_is_true(self):
w = self.space.wrap
w_list = W_ListObject(self.space, [])
- self.assertEqual(self.space.is_true(w_list), False)
+ assert self.space.is_true(w_list) == False
w_list = W_ListObject(self.space, [w(5)])
- self.assertEqual(self.space.is_true(w_list), True)
+ assert self.space.is_true(w_list) == True
w_list = W_ListObject(self.space, [w(5), w(3)])
- self.assertEqual(self.space.is_true(w_list), True)
+ assert self.space.is_true(w_list) == True
def test_len(self):
w = self.space.wrap
w_list = W_ListObject(self.space, [])
- self.assertEqual_w(self.space.len(w_list), w(0))
+ assert self.space.eq_w(self.space.len(w_list), w(0))
w_list = W_ListObject(self.space, [w(5)])
- self.assertEqual_w(self.space.len(w_list), w(1))
+ assert self.space.eq_w(self.space.len(w_list), w(1))
w_list = W_ListObject(self.space, [w(5), w(3), w(99)]*111)
- self.assertEqual_w(self.space.len(w_list), w(333))
+ assert self.space.eq_w(self.space.len(w_list), w(333))
def test_getitem(self):
w = self.space.wrap
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))
- self.assertEqual_w(self.space.getitem(w_list, w(-1)), w(3))
- self.assertRaises_w(self.space.w_IndexError,
+ assert self.space.eq_w(self.space.getitem(w_list, w(0)), w(5))
+ assert self.space.eq_w(self.space.getitem(w_list, w(1)), w(3))
+ assert self.space.eq_w(self.space.getitem(w_list, w(-2)), w(5))
+ assert self.space.eq_w(self.space.getitem(w_list, w(-1)), w(3))
+ self.space.raises_w(self.space.w_IndexError,
self.space.getitem, w_list, w(2))
- self.assertRaises_w(self.space.w_IndexError,
+ self.space.raises_w(self.space.w_IndexError,
self.space.getitem, w_list, w(42))
- self.assertRaises_w(self.space.w_IndexError,
+ self.space.raises_w(self.space.w_IndexError,
self.space.getitem, w_list, w(-3))
def test_iter(self):
w = self.space.wrap
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))
- self.assertEqual_w(self.space.next(w_iter), w(99))
- self.assertRaises(OperationError, self.space.next, w_iter)
- self.assertRaises(OperationError, self.space.next, w_iter)
+ assert self.space.eq_w(self.space.next(w_iter), w(5))
+ assert self.space.eq_w(self.space.next(w_iter), w(3))
+ assert self.space.eq_w(self.space.next(w_iter), w(99))
+ raises(OperationError, self.space.next, w_iter)
+ raises(OperationError, self.space.next, w_iter)
def test_contains(self):
w = self.space.wrap
w_list = W_ListObject(self.space, [w(5), w(3), w(99)])
- self.assertEqual_w(self.space.contains(w_list, w(5)),
+ assert self.space.eq_w(self.space.contains(w_list, w(5)),
self.space.w_True)
- self.assertEqual_w(self.space.contains(w_list, w(99)),
+ assert self.space.eq_w(self.space.contains(w_list, w(99)),
self.space.w_True)
- self.assertEqual_w(self.space.contains(w_list, w(11)),
+ assert self.space.eq_w(self.space.contains(w_list, w(11)),
self.space.w_False)
- self.assertEqual_w(self.space.contains(w_list, w_list),
+ assert self.space.eq_w(self.space.contains(w_list, w_list),
self.space.w_False)
def test_getslice(self):
@@ -74,7 +69,7 @@
w_slice = self.space.newslice(w(start), w(stop), w(step))
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)
+ assert self.space.unwrap(w_result) == expected
for testlist in [[], [5,3,99]]:
for start in [-2, 0, 1, 10]:
@@ -96,7 +91,7 @@
w_lhslist = W_ListObject(self.space, [w(i) for i in lhslist])
w_rhslist = W_ListObject(self.space, [w(i) for i in rhslist])
self.space.setitem(w_lhslist, w_slice, w_rhslist)
- self.assertEqual(self.space.unwrap(w_lhslist), expected)
+ assert self.space.unwrap(w_lhslist) == expected
test1([5,7,1,4], 1, 3, [9,8], [5,9,8,4])
@@ -111,14 +106,14 @@
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),
+ assert self.space.eq_w(self.space.add(w_list1, w_list1),
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),
+ assert self.space.eq_w(self.space.add(w_list1, w_list2),
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)
+ assert self.space.eq_w(self.space.add(w_list1, w_list0), w_list1)
+ assert self.space.eq_w(self.space.add(w_list0, w_list2), w_list2)
def test_mul(self):
# only testing right mul at the moment
@@ -128,10 +123,10 @@
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)
+ assert self.space.eq_w(w_lis3, w_res)
# commute
w_res = self.space.mul(w(n), w_lis)
- self.assertEqual_w(w_lis3, w_res)
+ assert self.space.eq_w(w_lis3, w_res)
def test_setitem(self):
w = self.space.wrap
@@ -139,12 +134,12 @@
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)
+ assert self.space.eq_w(w_exp1, w_list)
self.space.setitem(w_list, w(-2), w(8))
- self.assertEqual_w(w_exp2, w_list)
- self.assertRaises_w(self.space.w_IndexError,
+ assert self.space.eq_w(w_exp2, w_list)
+ self.space.raises_w(self.space.w_IndexError,
self.space.setitem, w_list, w(2), w(5))
- self.assertRaises_w(self.space.w_IndexError,
+ self.space.raises_w(self.space.w_IndexError,
self.space.setitem, w_list, w(-3), w(5))
def test_eq(self):
@@ -155,15 +150,15 @@
w_list2 = W_ListObject(self.space, [w(5), w(3), w(99)])
w_list3 = W_ListObject(self.space, [w(5), w(3), w(99), w(-1)])
- self.assertEqual_w(self.space.eq(w_list0, w_list1),
+ assert self.space.eq_w(self.space.eq(w_list0, w_list1),
self.space.w_False)
- self.assertEqual_w(self.space.eq(w_list1, w_list0),
+ assert self.space.eq_w(self.space.eq(w_list1, w_list0),
self.space.w_False)
- self.assertEqual_w(self.space.eq(w_list1, w_list1),
+ assert self.space.eq_w(self.space.eq(w_list1, w_list1),
self.space.w_True)
- self.assertEqual_w(self.space.eq(w_list1, w_list2),
+ assert self.space.eq_w(self.space.eq(w_list1, w_list2),
self.space.w_True)
- self.assertEqual_w(self.space.eq(w_list2, w_list3),
+ assert self.space.eq_w(self.space.eq(w_list2, w_list3),
self.space.w_False)
def test_ne(self):
w = self.space.wrap
@@ -173,15 +168,15 @@
w_list2 = W_ListObject(self.space, [w(5), w(3), w(99)])
w_list3 = W_ListObject(self.space, [w(5), w(3), w(99), w(-1)])
- self.assertEqual_w(self.space.ne(w_list0, w_list1),
+ assert self.space.eq_w(self.space.ne(w_list0, w_list1),
self.space.w_True)
- self.assertEqual_w(self.space.ne(w_list1, w_list0),
+ assert self.space.eq_w(self.space.ne(w_list1, w_list0),
self.space.w_True)
- self.assertEqual_w(self.space.ne(w_list1, w_list1),
+ assert self.space.eq_w(self.space.ne(w_list1, w_list1),
self.space.w_False)
- self.assertEqual_w(self.space.ne(w_list1, w_list2),
+ assert self.space.eq_w(self.space.ne(w_list1, w_list2),
self.space.w_False)
- self.assertEqual_w(self.space.ne(w_list2, w_list3),
+ assert self.space.eq_w(self.space.ne(w_list2, w_list3),
self.space.w_True)
def test_lt(self):
w = self.space.wrap
@@ -192,17 +187,17 @@
w_list3 = W_ListObject(self.space, [w(5), w(3), w(99), w(-1)])
w_list4 = W_ListObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.lt(w_list0, w_list1),
+ assert self.space.eq_w(self.space.lt(w_list0, w_list1),
self.space.w_True)
- self.assertEqual_w(self.space.lt(w_list1, w_list0),
+ assert self.space.eq_w(self.space.lt(w_list1, w_list0),
self.space.w_False)
- self.assertEqual_w(self.space.lt(w_list1, w_list1),
+ assert self.space.eq_w(self.space.lt(w_list1, w_list1),
self.space.w_False)
- self.assertEqual_w(self.space.lt(w_list1, w_list2),
+ assert self.space.eq_w(self.space.lt(w_list1, w_list2),
self.space.w_False)
- self.assertEqual_w(self.space.lt(w_list2, w_list3),
+ assert self.space.eq_w(self.space.lt(w_list2, w_list3),
self.space.w_True)
- self.assertEqual_w(self.space.lt(w_list4, w_list3),
+ assert self.space.eq_w(self.space.lt(w_list4, w_list3),
self.space.w_True)
def test_ge(self):
@@ -214,17 +209,17 @@
w_list3 = W_ListObject(self.space, [w(5), w(3), w(99), w(-1)])
w_list4 = W_ListObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.ge(w_list0, w_list1),
+ assert self.space.eq_w(self.space.ge(w_list0, w_list1),
self.space.w_False)
- self.assertEqual_w(self.space.ge(w_list1, w_list0),
+ assert self.space.eq_w(self.space.ge(w_list1, w_list0),
self.space.w_True)
- self.assertEqual_w(self.space.ge(w_list1, w_list1),
+ assert self.space.eq_w(self.space.ge(w_list1, w_list1),
self.space.w_True)
- self.assertEqual_w(self.space.ge(w_list1, w_list2),
+ assert self.space.eq_w(self.space.ge(w_list1, w_list2),
self.space.w_True)
- self.assertEqual_w(self.space.ge(w_list2, w_list3),
+ assert self.space.eq_w(self.space.ge(w_list2, w_list3),
self.space.w_False)
- self.assertEqual_w(self.space.ge(w_list4, w_list3),
+ assert self.space.eq_w(self.space.ge(w_list4, w_list3),
self.space.w_False)
def test_gt(self):
@@ -236,17 +231,17 @@
w_list3 = W_ListObject(self.space, [w(5), w(3), w(99), w(-1)])
w_list4 = W_ListObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.gt(w_list0, w_list1),
+ assert self.space.eq_w(self.space.gt(w_list0, w_list1),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_list1, w_list0),
+ assert self.space.eq_w(self.space.gt(w_list1, w_list0),
self.space.w_True)
- self.assertEqual_w(self.space.gt(w_list1, w_list1),
+ assert self.space.eq_w(self.space.gt(w_list1, w_list1),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_list1, w_list2),
+ assert self.space.eq_w(self.space.gt(w_list1, w_list2),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_list2, w_list3),
+ assert self.space.eq_w(self.space.gt(w_list2, w_list3),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_list4, w_list3),
+ assert self.space.eq_w(self.space.gt(w_list4, w_list3),
self.space.w_False)
def test_le(self):
@@ -258,92 +253,86 @@
w_list3 = W_ListObject(self.space, [w(5), w(3), w(99), w(-1)])
w_list4 = W_ListObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.le(w_list0, w_list1),
+ assert self.space.eq_w(self.space.le(w_list0, w_list1),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_list1, w_list0),
+ assert self.space.eq_w(self.space.le(w_list1, w_list0),
self.space.w_False)
- self.assertEqual_w(self.space.le(w_list1, w_list1),
+ assert self.space.eq_w(self.space.le(w_list1, w_list1),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_list1, w_list2),
+ assert self.space.eq_w(self.space.le(w_list1, w_list2),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_list2, w_list3),
+ assert self.space.eq_w(self.space.le(w_list2, w_list3),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_list4, w_list3),
+ assert self.space.eq_w(self.space.le(w_list4, w_list3),
self.space.w_True)
-class AppTestW_ListObject(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
-
+class AppTestW_ListObject:
def test_explicit_new_init(self):
l = l0 = list.__new__(list)
l.__init__([1,2])
- self.assert_(l is l0)
- self.assertEquals(l,[1,2])
+ assert l is l0
+ assert l ==[1,2]
list.__init__(l,[1,2,3])
- self.assert_(l is l0)
- self.assertEquals(l,[1,2,3])
+ assert l is l0
+ assert l ==[1,2,3]
def test_extend_list(self):
l = l0 = [1]
l.extend([2])
- self.assert_(l is l0)
- self.assertEquals(l, [1,2])
+ assert l is l0
+ assert l == [1,2]
def test_extend_tuple(self):
l = l0 = [1]
l.extend((2,))
- self.assert_(l is l0)
- self.assertEquals(l, [1,2])
+ assert l is l0
+ assert l == [1,2]
def test_sort(self):
l = l0 = [1, 5, 3, 0]
l.sort()
- self.assert_(l is l0)
- self.assertEquals(l, [0, 1, 3, 5])
+ assert l is l0
+ assert l == [0, 1, 3, 5]
l = l0 = []
l.sort()
- self.assert_(l is l0)
- self.assertEquals(l, [])
+ assert l is l0
+ assert l == []
l = l0 = [1]
l.sort()
- self.assert_(l is l0)
- self.assertEquals(l, [1])
+ assert l is l0
+ assert l == [1]
def test_sort_cmp(self):
def lencmp(a,b): return cmp(len(a), len(b))
l = [ 'a', 'fiver', 'tre', '' ]
l.sort(lencmp)
- self.assertEquals(l, ['', 'a', 'tre', 'fiver'])
+ assert l == ['', 'a', 'tre', 'fiver']
l = []
l.sort(lencmp)
- self.assertEquals(l, [])
+ assert l == []
l = [ 'a' ]
l.sort(lencmp)
- self.assertEquals(l, [ 'a' ])
+ assert l == [ 'a' ]
def test_extended_slice(self):
l = range(10)
del l[::2]
- self.assertEquals(l,[1,3,5,7,9])
+ assert l ==[1,3,5,7,9]
l[-2::-1] = l[:-1]
- self.assertEquals(l,[7,5,3,1,9])
+ assert l ==[7,5,3,1,9]
del l[-1:2:-1]
- self.assertEquals(l,[7,5,3])
+ assert l ==[7,5,3]
del l[:2]
- self.assertEquals(l,[3])
+ assert l ==[3]
def test_delall(self):
l = l0 = [1,2,3]
del l[:]
- self.assert_(l is l0)
- self.assertEquals(l, [])
+ assert l is l0
+ assert l == []
def test_iadd(self):
l = l0 = [1,2,3]
l += [4,5]
- self.assert_(l is l0)
- self.assertEquals(l, [1,2,3,4,5])
-
-if __name__ == '__main__':
- testit.main()
+ assert l is l0
+ assert l == [1,2,3,4,5]
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_multimethod.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_multimethod.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_multimethod.py Mon Jan 10 17:19:39 2005
@@ -1,11 +1,12 @@
import autopath
from pypy.objspace.std.multimethod import *
-from pypy.tool import testit
BoundMultiMethod.ASSERT_BASE_TYPE = object
+objspacename = 'std'
+
class X:
def __init__(self, value):
self.value = value
@@ -90,60 +91,55 @@
return x
-class TestMultiMethod(testit.TestCase):
- def setUp(self):
+class TestMultiMethod:
+ def setup_method(self,method):
# only run when testing stdobjectspace
- #XXX removed: testit.objspace('std')
+ #XXX removed: self.space
self.space = FakeObjSpace()
def test_non_delegate(self):
space = self.space
r = space.add(X(2), X(5))
- self.assertEquals(repr(r), "('add_x_x', <X 2>, <X 5>)")
+ assert repr(r) == "('add_x_x', <X 2>, <X 5>)"
r = space.add(X(3), Y(4))
- self.assertEquals(repr(r), "('add_x_y', <X 3>, <Y 4>)")
+ assert repr(r) == "('add_x_y', <X 3>, <Y 4>)"
r = space.add(Y(0), Y(20))
- self.assertEquals(repr(r), "('add_y_y', <Y 0>, <Y 20>)")
+ assert repr(r) == "('add_y_y', <Y 0>, <Y 20>)"
r = space.add(w(-3), w([7,6,5]))
- self.assertEquals(repr(r), "('add_int_any', -3, [7, 6, 5])")
+ assert repr(r) == "('add_int_any', -3, [7, 6, 5])"
r = space.add(w(5), w("test"))
- self.assertEquals(repr(r), "('add_int_string', 5, 'test')")
+ assert repr(r) == "('add_int_string', 5, 'test')"
r = space.add(w("x"), w("y"))
- self.assertEquals(repr(r), "('add_string_string', 'x', 'y')")
+ assert repr(r) == "('add_string_string', 'x', 'y')"
def test_delegate_y_to_x(self):
space = self.space
r = space.add(Y(-1), X(7))
- self.assertEquals(repr(r), "('add_x_x', <X <Y -1>>, <X 7>)")
+ assert repr(r) == "('add_x_x', <X <Y -1>>, <X 7>)"
r = space.add(Y(1), X(7))
- self.assertEquals(repr(r), "('add_x_x', <X <Y 1>>, <X 7>)")
+ assert repr(r) == "('add_x_x', <X <Y 1>>, <X 7>)"
r = space.add(X(-3), Y(20))
- self.assertEquals(repr(r), "('add_x_x', <X -3>, <X <Y 20>>)")
+ assert repr(r) == "('add_x_x', <X -3>, <X <Y 20>>)"
def test_no_operation_defined(self):
space = self.space
- self.assertRaises(OperationError, space.add, w([3]), w(4))
- self.assertRaises(OperationError, space.add, w(3.0), w('bla'))
- #self.assertRaises(OperationError, space.add, X(0), w("spam"))
- #self.assertRaises(OperationError, space.add, Y(666), w("egg"))
+ raises(OperationError, space.add, w([3]), w(4))
+ raises(OperationError, space.add, w(3.0), w('bla'))
+ #raises(OperationError, space.add, X(0), w("spam"))
+ #raises(OperationError, space.add, Y(666), w("egg"))
def test_delegate_x_to_str(self):
space = self.space
r = space.add(X(42), w("spam"))
- self.assertEquals(repr(r), "('add_string_string', '!42', 'spam')")
+ assert repr(r) == "('add_string_string', '!42', 'spam')"
r = space.add(Y(20), w("egg"))
- self.assertEquals(repr(r), "('add_string_string', '!<Y 20>', 'egg')")
-
-
-
-if __name__ == '__main__':
- testit.main()
+ assert repr(r) == "('add_string_string', '!<Y 20>', 'egg')"
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_noneobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_noneobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_noneobject.py Mon Jan 10 17:19:39 2005
@@ -1,25 +1,16 @@
import autopath
-from pypy.tool import testit
-class TestW_NoneObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
-
- def tearDown(self):
- pass
+class TestW_NoneObject:
def test_equality(self):
- self.assertEqual_w(self.space.w_None, self.space.w_None)
+ assert self.space.eq_w(self.space.w_None, self.space.w_None)
def test_inequality(self):
neresult = self.space.ne(self.space.w_None, self.space.w_None)
- self.failIf_w(neresult)
+ assert not self.space.is_true(neresult)
def test_false(self):
- self.failIf_w(self.space.w_None)
-
-
-if __name__ == '__main__':
- testit.main()
+ assert not self.space.is_true(self.space.w_None)
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_restricted_int.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_restricted_int.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_restricted_int.py Mon Jan 10 17:19:39 2005
@@ -1,18 +1,16 @@
import unittest
import autopath
-from pypy.tool import testit
from pypy.objspace.std.restricted_int import *
import sys
maxint_mask = (sys.maxint*2 + 1)
-class Test_r_int(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- space = testit.objspace('std')
+class Test_r_int:
- def tearDown(self):
- pass
+ def setup_method(self,method):
+ space = self.space
def test__add__(self):
self.binary_test(lambda x, y: x + y)
@@ -21,8 +19,8 @@
def test__mul__(self):
self.binary_test(lambda x, y: x * y)
x = 3; y = [2]
- self.assertEquals(x*y, r_int(x)*y)
- self.assertEquals(y*x, y*r_int(x))
+ assert x*y == r_int(x)*y
+ assert y*x == y*r_int(x)
def test__div__(self):
self.binary_test(lambda x, y: x // y)
def test__mod__(self):
@@ -53,7 +51,7 @@
for arg in (-10, -1, 0, 3, 12345):
res = f(arg)
cmp = f(r_int(arg))
- self.assertEquals(res, cmp)
+ assert res == cmp
def binary_test(self, f, rargs = None):
if not rargs:
@@ -64,15 +62,12 @@
res = f(larg, rarg)
left, right = types
cmp = f(left(larg), right(rarg))
- self.assertEquals(res, cmp)
+ assert res == cmp
-class Test_r_uint(testit.TestCase):
+class Test_r_uint:
- def setUp(self):
- space = testit.objspace('std')
-
- def tearDown(self):
- pass
+ def setup_method(self,method):
+ space = self.space
def test__add__(self):
self.binary_test(lambda x, y: x + y)
@@ -81,8 +76,8 @@
def test__mul__(self):
self.binary_test(lambda x, y: x * y)
x = 3; y = [2]
- self.assertEquals(x*y, r_uint(x)*y)
- self.assertEquals(y*x, y*r_uint(x))
+ assert x*y == r_uint(x)*y
+ assert y*x == y*r_uint(x)
def test__div__(self):
self.binary_test(lambda x, y: x // y)
def test__mod__(self):
@@ -114,7 +109,7 @@
for arg in (0, 3, 12345):
res = f(arg) & maxint_mask
cmp = f(r_uint(arg))
- self.assertEquals(res, cmp)
+ assert res == cmp
def binary_test(self, f, rargs = None):
mask = maxint_mask
@@ -130,7 +125,4 @@
res = res[0] & mask, res[1] & mask
else:
res = res & mask
- self.assertEquals(res, cmp)
-
-if __name__ == '__main__':
- testit.main()
+ assert res == cmp
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_sliceobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_sliceobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_sliceobject.py Mon Jan 10 17:19:39 2005
@@ -1,18 +1,13 @@
import autopath
-from pypy.tool import testit
-class TestW_SliceObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
-
- def tearDown(self):
- pass
+class TestW_SliceObject:
def equal_indices(self, got, expected):
- self.assertEqual(len(got), len(expected))
+ assert len(got) == len(expected)
for g, e in zip(got, expected):
- self.assertEqual(g, e)
+ assert g == e
def test_indices(self):
from pypy.objspace.std import slicetype
@@ -32,31 +27,25 @@
w = space.wrap
w_None = space.w_None
w_slice = space.newslice(w_None, w_None, w(0))
- self.assertRaises_w(space.w_ValueError,
+ self.space.raises_w(space.w_ValueError,
slicetype.indices3, space, w_slice, 10)
-class Test_SliceObject(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
-
+class AppTest_SliceObject:
def test_new(self):
def cmp_slice(sl1, sl2):
for attr in "start", "stop", "step":
if getattr(sl1, attr) != getattr(sl2, attr):
return False
return True
- self.assertRaises(TypeError, slice)
- self.assertRaises(TypeError, slice, 1, 2, 3, 4)
- self.failUnless(cmp_slice(slice(23), slice(None, 23, None)))
- self.failUnless(cmp_slice(slice(23, 45), slice(23, 45, None)))
+ raises(TypeError, slice)
+ raises(TypeError, slice, 1, 2, 3, 4)
+ assert cmp_slice(slice(23), slice(None, 23, None))
+ assert cmp_slice(slice(23, 45), slice(23, 45, None))
def test_indices(self):
- self.assertEqual(slice(4,11,2).indices(28), (4, 11, 2))
- self.assertEqual(slice(4,11,2).indices(8), (4, 8, 2))
- self.assertEqual(slice(4,11,2).indices(2), (2, 2, 2))
- self.assertEqual(slice(11,4,-2).indices(28), (11, 4, -2))
- self.assertEqual(slice(11,4,-2).indices(8), (7, 4, -2))
- self.assertEqual(slice(11,4,-2).indices(2), (1, 2, -2))
-
-if __name__ == '__main__':
- testit.main()
+ assert slice(4,11,2).indices(28) == (4, 11, 2)
+ assert slice(4,11,2).indices(8) == (4, 8, 2)
+ assert slice(4,11,2).indices(2) == (2, 2, 2)
+ assert slice(11,4,-2).indices(28) == (11, 4, -2)
+ assert slice(11,4,-2).indices(8) == (7, 4, -2)
+ assert slice(11,4,-2).indices(2) == (1, 2, -2)
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_stdobjspace.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_stdobjspace.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_stdobjspace.py Mon Jan 10 17:19:39 2005
@@ -1,23 +1,14 @@
import autopath
-from pypy.tool import testit
-class TestW_StdObjSpace(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
-
- def tearDown(self):
- pass
+class TestW_StdObjSpace:
def test_wrap_wrap(self):
- self.assertRaises(TypeError,
+ raises(TypeError,
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__':
- testit.main()
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_stringformat.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_stringformat.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_stringformat.py Mon Jan 10 17:19:39 2005
@@ -1,83 +1,84 @@
import autopath
-from pypy.tool import testit
-class TestStringObjectWithDict(testit.AppTestCase):
+objspacename = 'std'
+
+class AppTestStringObjectWithDict:
def test_format_item(self):
d = {'i': 23}
- self.assertEquals('a23b', 'a%(i)sb' % d)
- self.assertEquals('23b', '%(i)sb' % d)
- self.assertEquals('a23', 'a%(i)s' % d)
- self.assertEquals('23', '%(i)s' % d)
+ assert 'a23b' == 'a%(i)sb' % d
+ assert '23b' == '%(i)sb' % d
+ assert 'a23' == 'a%(i)s' % d
+ assert '23' == '%(i)s' % d
def test_format_two_items(self):
d = {'i': 23, 'j': 42}
- self.assertEquals('a23b42c', 'a%(i)sb%(j)sc' % d)
- self.assertEquals('a23b23c', 'a%(i)sb%(i)sc' % d)
+ assert 'a23b42c' == 'a%(i)sb%(j)sc' % d
+ assert 'a23b23c' == 'a%(i)sb%(i)sc' % d
def test_format_percent(self):
- self.assertEquals('a%b', 'a%%b' % {})
+ assert 'a%b' == 'a%%b' % {}
def test_format_empty_key(self):
d = {'':42}
- self.assertEquals('42', '%()s' % d)
+ assert '42' == '%()s' % d
def test_format_wrong_char(self):
d = {'i': 23}
- self.assertRaises(ValueError, 'a%(i)Zb'.__mod__, d)
+ raises(ValueError, 'a%(i)Zb'.__mod__, d)
def test_format_missing(self):
d = {'i': 23}
- self.assertRaises(KeyError, 'a%(x)sb'.__mod__, d)
+ raises(KeyError, 'a%(x)sb'.__mod__, d)
-class TestStringObject(testit.AppTestCase):
+class AppTestStringObject:
def test_format_item(self):
- self.assertEquals('a23b', 'a%sb' % 23)
- self.assertEquals('23b', '%sb' % 23)
- self.assertEquals('a23', 'a%s' % 23)
- self.assertEquals('23', '%s' % 23)
+ assert 'a23b' == 'a%sb' % 23
+ assert '23b' == '%sb' % 23
+ assert 'a23' == 'a%s' % 23
+ assert '23' == '%s' % 23
def test_format_percent(self):
- self.assertEquals('a%b', 'a%%b' % ())
- self.assertEquals('%b', '%%b' % ())
- self.assertEquals('a%', 'a%%' % ())
- self.assertEquals('%', '%%' % ())
+ assert 'a%b' == 'a%%b' % ()
+ assert '%b' == '%%b' % ()
+ assert 'a%' == 'a%%' % ()
+ assert '%' == '%%' % ()
def test_format_too_much(self):
- self.assertRaises(TypeError, '%s%s'.__mod__, ())
- self.assertRaises(TypeError, '%s%s'.__mod__, (23,))
+ raises(TypeError, '%s%s'.__mod__, ())
+ raises(TypeError, '%s%s'.__mod__, (23,))
def test_format_not_enough(self):
- self.assertRaises(TypeError, '%s%s'.__mod__, (23,)*3)
- self.assertRaises(TypeError, '%s%s'.__mod__, (23,)*4)
+ raises(TypeError, '%s%s'.__mod__, (23,)*3)
+ raises(TypeError, '%s%s'.__mod__, (23,)*4)
def test_format_string(self):
- self.assertEquals('23', '%s' % '23')
- self.assertEquals("'23'", '%r' % '23')
- self.assertRaises(TypeError, '%d'.__mod__, "23")
+ assert '23' == '%s' % '23'
+ assert "'23'" == '%r' % '23'
+ raises(TypeError, '%d'.__mod__, "23")
def test_format_float(self):
- self.assertEquals('23', '%d' % 23.456)
- self.assertEquals('17', '%x' % 23.456)
- self.assertEquals('23.456', '%s' % 23.456)
+ assert '23' == '%d' % 23.456
+ assert '17' == '%x' % 23.456
+ assert '23.456' == '%s' % 23.456
# for 'r' use a float that has an exact decimal rep:
- self.assertEquals('23.125', '%r' % 23.125)
+ assert '23.125' == '%r' % 23.125
def test_format_int(self):
- self.assertEquals('23', '%d' % 23)
- self.assertEquals('17', '%x' % 23)
- self.assertEquals('0x17', '%#x' % 23)
- self.assertEquals('23', '%s' % 23)
- self.assertEquals('23', '%r' % 23)
+ assert '23' == '%d' % 23
+ assert '17' == '%x' % 23
+ assert '0x17' == '%#x' % 23
+ assert '23' == '%s' % 23
+ assert '23' == '%r' % 23
def test_format_list(self):
- self.assertEquals('<[1, 2]>', '<%s>' % [1,2])
- self.assertEquals('<[1, 2]-[3, 4]>', '<%s-%s>' % ([1,2], [3,4]))
+ assert '<[1, 2]>' == '<%s>' % [1,2]
+ assert '<[1, 2]-[3, 4]>' == '<%s-%s>' % ([1,2], [3,4])
def test_format_tuple(self):
- self.assertEquals('<(1, 2)>', '<%s>' % ((1,2),))
- self.assertEquals('<(1, 2)-(3, 4)>', '<%s-%s>' % ((1,2), (3,4)))
+ assert '<(1, 2)>' == '<%s>' % ((1,2),)
+ assert '<(1, 2)-(3, 4)>' == '<%s-%s>' % ((1,2), (3,4))
def test_format_dict(self):
@@ -92,55 +93,52 @@
# It is what CPython *does*, however. All software sucks.
- self.assertEquals('<{1: 2}>', '<%s>' % {1:2})
- self.assertEquals('<{1: 2}-{3: 4}>', '<%s-%s>' % ({1:2}, {3:4}))
+ assert '<{1: 2}>' == '<%s>' % {1:2}
+ assert '<{1: 2}-{3: 4}>' == '<%s-%s>' % ({1:2}, {3:4})
def test_format_wrong_char(self):
- self.assertRaises(ValueError, 'a%Zb'.__mod__, ((23,),))
+ raises(ValueError, 'a%Zb'.__mod__, ((23,),))
def test_incomplete_format(self):
- self.assertRaises(ValueError, '%'.__mod__, ((23,),))
+ raises(ValueError, '%'.__mod__, ((23,),))
-class TestWidthPrec(testit.AppTestCase):
+class AppTestWidthPrec:
def test_width(self):
- self.assertEquals("%3s" %'a', ' a')
- self.assertEquals("%-3s"%'a', 'a ')
+ assert "%3s" %'a' == ' a'
+ assert "%-3s"%'a' == 'a '
def test_prec_string(self):
- self.assertEquals("%.3s"%'a', 'a')
- self.assertEquals("%.3s"%'abcde', 'abc')
+ assert "%.3s"%'a' == 'a'
+ assert "%.3s"%'abcde' == 'abc'
def test_prec_width_string(self):
- self.assertEquals("%5.3s" %'a', ' a')
- self.assertEquals("%5.3s" %'abcde', ' abc')
- self.assertEquals("%-5.3s"%'a', 'a ')
- self.assertEquals("%-5.3s"%'abcde', 'abc ')
+ assert "%5.3s" %'a' == ' a'
+ assert "%5.3s" %'abcde' == ' abc'
+ assert "%-5.3s"%'a' == 'a '
+ assert "%-5.3s"%'abcde' == 'abc '
def test_zero_pad(self):
- self.assertEquals("%02d"%1, "01")
- self.assertEquals("%05d"%1, "00001")
- self.assertEquals("%-05d"%1, "1 ")
- self.assertEquals("%04f"%2.25, "2.250000")
- self.assertEquals("%05g"%2.25, "02.25")
- self.assertEquals("%-05g"%2.25,"2.25 ")
- self.assertEquals("%05s"%2.25, " 2.25")
+ assert "%02d"%1 == "01"
+ assert "%05d"%1 == "00001"
+ assert "%-05d"%1 == "1 "
+ assert "%04f"%2.25 == "2.250000"
+ assert "%05g"%2.25 == "02.25"
+ assert "%-05g"%2.25 =="2.25 "
+ assert "%05s"%2.25 == " 2.25"
def test_star_width(self):
- self.assertEquals("%*s" %( 5, 'abc'), ' abc')
- self.assertEquals("%*s" %(-5, 'abc'), 'abc ')
- self.assertEquals("%-*s"%( 5, 'abc'), 'abc ')
- self.assertEquals("%-*s"%(-5, 'abc'), 'abc ')
+ assert "%*s" %( 5, 'abc') == ' abc'
+ assert "%*s" %(-5, 'abc') == 'abc '
+ assert "%-*s"%( 5, 'abc') == 'abc '
+ assert "%-*s"%(-5, 'abc') == 'abc '
def test_star_prec(self):
- self.assertEquals("%.*s"%( 3, 'abc'), 'abc')
- self.assertEquals("%.*s"%( 3, 'abcde'), 'abc')
- self.assertEquals("%.*s"%(-3, 'abc'), '')
+ assert "%.*s"%( 3, 'abc') == 'abc'
+ assert "%.*s"%( 3, 'abcde') == 'abc'
+ assert "%.*s"%(-3, 'abc') == ''
def test_star_width_prec(self):
- self.assertEquals("%*.*s"%( 5, 3, 'abc'), ' abc')
- self.assertEquals("%*.*s"%( 5, 3, 'abcde'), ' abc')
- self.assertEquals("%*.*s"%(-5, 3, 'abcde'), 'abc ')
-
-if __name__ == '__main__':
- testit.main()
+ assert "%*.*s"%( 5, 3, 'abc') == ' abc'
+ assert "%*.*s"%( 5, 3, 'abcde') == ' abc'
+ assert "%*.*s"%(-5, 3, 'abcde') == 'abc '
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_stringobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_stringobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_stringobject.py Mon Jan 10 17:19:39 2005
@@ -1,15 +1,13 @@
import autopath
-from pypy.tool import testit
from pypy.objspace.std import stringobject
from pypy.objspace.std.stringobject import W_StringObject
-class TestW_StringObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
+class TestW_StringObject:
- def tearDown(self):
+ def teardown_method(self,method):
pass
## def test_order_rich(self):
@@ -41,29 +39,29 @@
def test_equality(self):
w = self.space.wrap
- self.assertEqual_w(w('abc'), w('abc'))
- self.assertNotEqual_w(w('abc'), w('def'))
+ assert self.space.eq_w(w('abc'), w('abc'))
+ assert not self.space.eq_w(w('abc'), w('def'))
def test_order_cmp(self):
space = self.space
w = space.wrap
- self.failUnless_w(space.lt(w('a'), w('b')))
- self.failUnless_w(space.lt(w('a'), w('ab')))
- self.failUnless_w(space.le(w('a'), w('a')))
- self.failUnless_w(space.gt(w('a'), w('')))
+ assert self.space.is_true(space.lt(w('a'), w('b')))
+ assert self.space.is_true(space.lt(w('a'), w('ab')))
+ assert self.space.is_true(space.le(w('a'), w('a')))
+ assert self.space.is_true(space.gt(w('a'), w('')))
def test_truth(self):
w = self.space.wrap
- self.failUnless_w(w('non-empty'))
- self.failIf_w(w(''))
+ assert self.space.is_true(w('non-empty'))
+ assert not self.space.is_true(w(''))
def test_getitem(self):
space = self.space
w = space.wrap
w_str = w('abc')
- self.assertEqual_w(space.getitem(w_str, w(0)), w('a'))
- self.assertEqual_w(space.getitem(w_str, w(-1)), w('c'))
- self.assertRaises_w(space.w_IndexError,
+ assert self.space.eq_w(space.getitem(w_str, w(0)), w('a'))
+ assert self.space.eq_w(space.getitem(w_str, w(-1)), w('c'))
+ self.space.raises_w(space.w_IndexError,
space.getitem,
w_str,
w(3))
@@ -74,22 +72,22 @@
w_str = w('abc')
w_slice = space.newslice(w(0), w(0), None)
- self.assertEqual_w(space.getitem(w_str, w_slice), w(''))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w(''))
w_slice = space.newslice(w(0), w(1), None)
- self.assertEqual_w(space.getitem(w_str, w_slice), w('a'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('a'))
w_slice = space.newslice(w(0), w(10), None)
- self.assertEqual_w(space.getitem(w_str, w_slice), w('abc'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('abc'))
w_slice = space.newslice(space.w_None, space.w_None, None)
- self.assertEqual_w(space.getitem(w_str, w_slice), w('abc'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('abc'))
w_slice = space.newslice(space.w_None, w(-1), None)
- self.assertEqual_w(space.getitem(w_str, w_slice), w('ab'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('ab'))
w_slice = space.newslice(w(-1), space.w_None, None)
- self.assertEqual_w(space.getitem(w_str, w_slice), w('c'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('c'))
def test_extended_slice(self):
space = self.space
@@ -102,233 +100,230 @@
w_str = w('hello')
w_slice = space.newslice(w_None, w_None, w(1))
- self.assertEqual_w(space.getitem(w_str, w_slice), w('hello'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('hello'))
w_slice = space.newslice(w_None, w_None, w(-1))
- self.assertEqual_w(space.getitem(w_str, w_slice), w('olleh'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('olleh'))
w_slice = space.newslice(w_None, w_None, w(2))
- self.assertEqual_w(space.getitem(w_str, w_slice), w('hlo'))
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('hlo'))
w_slice = space.newslice(w(1), w_None, w(2))
- self.assertEqual_w(space.getitem(w_str, w_slice), w('el'))
-
-class TestStringObject(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
+ assert self.space.eq_w(space.getitem(w_str, w_slice), w('el'))
+class AppTestStringObject:
def test_format_wrongchar(self):
- self.assertRaises(ValueError, 'a%Zb'.__mod__, ((23,),))
+ raises(ValueError, 'a%Zb'.__mod__, ((23,),))
def test_split(self):
- self.assertEquals("".split(), [])
- self.assertEquals("a".split(), ['a'])
- self.assertEquals(" a ".split(), ['a'])
- self.assertEquals("a b c".split(), ['a','b','c'])
- self.assertEquals('this is the split function'.split(), ['this', 'is', 'the', 'split', 'function'])
- self.assertEquals('a|b|c|d'.split('|'), ['a', 'b', 'c', 'd'])
- self.assertEquals('a|b|c|d'.split('|', 2), ['a', 'b', 'c|d'])
- self.assertEquals('a b c d'.split(None, 1), ['a', 'b c d'])
- self.assertEquals('a b c d'.split(None, 2), ['a', 'b', 'c d'])
- self.assertEquals('a b c d'.split(None, 3), ['a', 'b', 'c', 'd'])
- self.assertEquals('a b c d'.split(None, 4), ['a', 'b', 'c', 'd'])
- self.assertEquals('a b c d'.split(None, 0), ['a b c d'])
- self.assertEquals('a b c d'.split(None, 2), ['a', 'b', 'c d'])
- self.assertEquals('a b c d '.split(), ['a', 'b', 'c', 'd'])
- self.assertEquals('a//b//c//d'.split('//'), ['a', 'b', 'c', 'd'])
- self.assertEquals('endcase test'.split('test'), ['endcase ', ''])
+ assert "".split() == []
+ assert "a".split() == ['a']
+ assert " a ".split() == ['a']
+ assert "a b c".split() == ['a','b','c']
+ assert 'this is the split function'.split() == ['this', 'is', 'the', 'split', 'function']
+ assert 'a|b|c|d'.split('|') == ['a', 'b', 'c', 'd']
+ assert 'a|b|c|d'.split('|', 2) == ['a', 'b', 'c|d']
+ assert 'a b c d'.split(None, 1) == ['a', 'b c d']
+ assert 'a b c d'.split(None, 2) == ['a', 'b', 'c d']
+ assert 'a b c d'.split(None, 3) == ['a', 'b', 'c', 'd']
+ assert 'a b c d'.split(None, 4) == ['a', 'b', 'c', 'd']
+ assert 'a b c d'.split(None, 0) == ['a b c d']
+ assert 'a b c d'.split(None, 2) == ['a', 'b', 'c d']
+ assert 'a b c d '.split() == ['a', 'b', 'c', 'd']
+ assert 'a//b//c//d'.split('//') == ['a', 'b', 'c', 'd']
+ assert 'endcase test'.split('test') == ['endcase ', '']
def test_split_splitchar(self):
- self.assertEquals("/a/b/c".split('/'), ['','a','b','c'])
+ assert "/a/b/c".split('/') == ['','a','b','c']
def test_title(self):
- self.assertEquals("brown fox".title(), "Brown Fox")
- self.assertEquals("!brown fox".title(), "!Brown Fox")
- self.assertEquals("bROWN fOX".title(), "Brown Fox")
- self.assertEquals("Brown Fox".title(), "Brown Fox")
- self.assertEquals("bro!wn fox".title(), "Bro!Wn Fox")
+ assert "brown fox".title() == "Brown Fox"
+ assert "!brown fox".title() == "!Brown Fox"
+ assert "bROWN fOX".title() == "Brown Fox"
+ assert "Brown Fox".title() == "Brown Fox"
+ assert "bro!wn fox".title() == "Bro!Wn Fox"
def test_istitle(self):
- self.assertEquals("brown fox".istitle(), False)
- self.assertEquals("!brown fox".istitle(), False)
- self.assertEquals("bROWN fOX".istitle(), False)
- self.assertEquals("Brown Fox".istitle(), True)
- self.assertEquals("bro!wn fox".istitle(), False)
- self.assertEquals("Bro!wn fox".istitle(), False)
- self.assertEquals("!brown Fox".istitle(), False)
- self.assertEquals("!Brown Fox".istitle(), True)
- self.assertEquals("Brow&&&&N Fox".istitle(), True)
- self.assertEquals("!Brow&&&&n Fox".istitle(), False)
+ assert "brown fox".istitle() == False
+ assert "!brown fox".istitle() == False
+ assert "bROWN fOX".istitle() == False
+ assert "Brown Fox".istitle() == True
+ assert "bro!wn fox".istitle() == False
+ assert "Bro!wn fox".istitle() == False
+ assert "!brown Fox".istitle() == False
+ assert "!Brown Fox".istitle() == True
+ assert "Brow&&&&N Fox".istitle() == True
+ assert "!Brow&&&&n Fox".istitle() == False
def test_capitalize(self):
- self.assertEquals("brown fox".capitalize(), "Brown fox")
- self.assertEquals(' hello '.capitalize(), ' hello ')
- self.assertEquals('Hello '.capitalize(), 'Hello ')
- self.assertEquals('hello '.capitalize(), 'Hello ')
- self.assertEquals('aaaa'.capitalize(), 'Aaaa')
- self.assertEquals('AaAa'.capitalize(), 'Aaaa')
+ assert "brown fox".capitalize() == "Brown fox"
+ assert ' hello '.capitalize() == ' hello '
+ assert 'Hello '.capitalize() == 'Hello '
+ assert 'hello '.capitalize() == 'Hello '
+ assert 'aaaa'.capitalize() == 'Aaaa'
+ assert 'AaAa'.capitalize() == 'Aaaa'
def test_rjust(self):
s = "abc"
- self.assertEquals(s.rjust(2), s)
- self.assertEquals(s.rjust(3), s)
- self.assertEquals(s.rjust(4), " " + s)
- self.assertEquals(s.rjust(5), " " + s)
- self.assertEquals('abc'.rjust(10), ' abc')
- self.assertEquals('abc'.rjust(6), ' abc')
- self.assertEquals('abc'.rjust(3), 'abc')
- self.assertEquals('abc'.rjust(2), 'abc')
+ assert s.rjust(2) == s
+ assert s.rjust(3) == s
+ assert s.rjust(4) == " " + s
+ assert s.rjust(5) == " " + s
+ assert 'abc'.rjust(10) == ' abc'
+ assert 'abc'.rjust(6) == ' abc'
+ assert 'abc'.rjust(3) == 'abc'
+ assert 'abc'.rjust(2) == 'abc'
def test_ljust(self):
s = "abc"
- self.assertEquals(s.ljust(2), s)
- self.assertEquals(s.ljust(3), s)
- self.assertEquals(s.ljust(4), s + " ")
- self.assertEquals(s.ljust(5), s + " ")
- self.assertEquals('abc'.ljust(10), 'abc ')
- self.assertEquals('abc'.ljust(6), 'abc ')
- self.assertEquals('abc'.ljust(3), 'abc')
- self.assertEquals('abc'.ljust(2), 'abc')
+ assert s.ljust(2) == s
+ assert s.ljust(3) == s
+ assert s.ljust(4) == s + " "
+ assert s.ljust(5) == s + " "
+ assert 'abc'.ljust(10) == 'abc '
+ assert 'abc'.ljust(6) == 'abc '
+ assert 'abc'.ljust(3) == 'abc'
+ assert 'abc'.ljust(2) == 'abc'
def test_replace(self):
- self.assertEquals('one!two!three!'.replace('!', '@', 1), 'one at two!three!')
- self.assertEquals('one!two!three!'.replace('!', ''), 'onetwothree')
- self.assertEquals('one!two!three!'.replace('!', '@', 2), 'one at two@three!')
- self.assertEquals('one!two!three!'.replace('!', '@', 3), 'one at two@three@')
- self.assertEquals('one!two!three!'.replace('!', '@', 4), 'one at two@three@')
- self.assertEquals('one!two!three!'.replace('!', '@', 0), 'one!two!three!')
- self.assertEquals('one!two!three!'.replace('!', '@'), 'one at two@three@')
- self.assertEquals('one!two!three!'.replace('x', '@'), 'one!two!three!')
- self.assertEquals('one!two!three!'.replace('x', '@', 2), 'one!two!three!')
- self.assertEquals('abc'.replace('', '-'), '-a-b-c-')
- self.assertEquals('abc'.replace('', '-', 3), '-a-b-c')
- self.assertEquals('abc'.replace('', '-', 0), 'abc')
- self.assertEquals(''.replace('', ''), '')
- self.assertEquals('abc'.replace('ab', '--', 0), 'abc')
- self.assertEquals('abc'.replace('xy', '--'), 'abc')
- self.assertEquals('123'.replace('123', ''), '')
- self.assertEquals('123123'.replace('123', ''), '')
- self.assertEquals('123x123'.replace('123', ''), 'x')
+ assert 'one!two!three!'.replace('!', '@', 1) == 'one at two!three!'
+ assert 'one!two!three!'.replace('!', '') == 'onetwothree'
+ assert 'one!two!three!'.replace('!', '@', 2) == 'one at two@three!'
+ assert 'one!two!three!'.replace('!', '@', 3) == 'one at two@three@'
+ assert 'one!two!three!'.replace('!', '@', 4) == 'one at two@three@'
+ assert 'one!two!three!'.replace('!', '@', 0) == 'one!two!three!'
+ assert 'one!two!three!'.replace('!', '@') == 'one at two@three@'
+ assert 'one!two!three!'.replace('x', '@') == 'one!two!three!'
+ assert 'one!two!three!'.replace('x', '@', 2) == 'one!two!three!'
+ assert 'abc'.replace('', '-') == '-a-b-c-'
+ assert 'abc'.replace('', '-', 3) == '-a-b-c'
+ assert 'abc'.replace('', '-', 0) == 'abc'
+ assert ''.replace('', '') == ''
+ assert 'abc'.replace('ab', '--', 0) == 'abc'
+ assert 'abc'.replace('xy', '--') == 'abc'
+ assert '123'.replace('123', '') == ''
+ assert '123123'.replace('123', '') == ''
+ assert '123x123'.replace('123', '') == 'x'
def test_strip(self):
s = " a b "
- self.assertEquals(s.strip(), "a b")
- self.assertEquals(s.rstrip(), " a b")
- self.assertEquals(s.lstrip(), "a b ")
- self.assertEquals('xyzzyhelloxyzzy'.strip('xyz'), 'hello')
- self.assertEquals('xyzzyhelloxyzzy'.lstrip('xyz'), 'helloxyzzy')
- self.assertEquals('xyzzyhelloxyzzy'.rstrip('xyz'), 'xyzzyhello')
+ assert s.strip() == "a b"
+ assert s.rstrip() == " a b"
+ assert s.lstrip() == "a b "
+ assert 'xyzzyhelloxyzzy'.strip('xyz') == 'hello'
+ assert 'xyzzyhelloxyzzy'.lstrip('xyz') == 'helloxyzzy'
+ assert 'xyzzyhelloxyzzy'.rstrip('xyz') == 'xyzzyhello'
def test_zfill(self):
- self.assertEquals('123'.zfill(2), '123')
- self.assertEquals('123'.zfill(3), '123')
- self.assertEquals('123'.zfill(4), '0123')
- self.assertEquals('+123'.zfill(3), '+123')
- self.assertEquals('+123'.zfill(4), '+123')
- self.assertEquals('+123'.zfill(5), '+0123')
- self.assertEquals('-123'.zfill(3), '-123')
- self.assertEquals('-123'.zfill(4), '-123')
- self.assertEquals('-123'.zfill(5), '-0123')
- self.assertEquals(''.zfill(3), '000')
- self.assertEquals('34'.zfill(1), '34')
- self.assertEquals('34'.zfill(4), '0034')
+ assert '123'.zfill(2) == '123'
+ assert '123'.zfill(3) == '123'
+ assert '123'.zfill(4) == '0123'
+ assert '+123'.zfill(3) == '+123'
+ assert '+123'.zfill(4) == '+123'
+ assert '+123'.zfill(5) == '+0123'
+ assert '-123'.zfill(3) == '-123'
+ assert '-123'.zfill(4) == '-123'
+ assert '-123'.zfill(5) == '-0123'
+ assert ''.zfill(3) == '000'
+ assert '34'.zfill(1) == '34'
+ assert '34'.zfill(4) == '0034'
def test_center(self):
s="a b"
- self.assertEquals(s.center(0), "a b")
- self.assertEquals(s.center(1), "a b")
- self.assertEquals(s.center(2), "a b")
- self.assertEquals(s.center(3), "a b")
- self.assertEquals(s.center(4), "a b ")
- self.assertEquals(s.center(5), " a b ")
- self.assertEquals(s.center(6), " a b ")
- self.assertEquals(s.center(7), " a b ")
- self.assertEquals(s.center(8), " a b ")
- self.assertEquals(s.center(9), " a b ")
- self.assertEquals('abc'.center(10), ' abc ')
- self.assertEquals('abc'.center(6), ' abc ')
- self.assertEquals('abc'.center(3), 'abc')
- self.assertEquals('abc'.center(2), 'abc')
+ assert s.center(0) == "a b"
+ assert s.center(1) == "a b"
+ assert s.center(2) == "a b"
+ assert s.center(3) == "a b"
+ assert s.center(4) == "a b "
+ assert s.center(5) == " a b "
+ assert s.center(6) == " a b "
+ assert s.center(7) == " a b "
+ assert s.center(8) == " a b "
+ assert s.center(9) == " a b "
+ assert 'abc'.center(10) == ' abc '
+ assert 'abc'.center(6) == ' abc '
+ assert 'abc'.center(3) == 'abc'
+ assert 'abc'.center(2) == 'abc'
def test_count(self):
- self.assertEquals("".count("x"),0)
- self.assertEquals("".count(""),1)
- self.assertEquals("Python".count(""),7)
- self.assertEquals("ab aaba".count("ab"),2)
- self.assertEquals('aaa'.count('a'), 3)
- self.assertEquals('aaa'.count('b'), 0)
- self.assertEquals('aaa'.count('a', -1), 1)
- self.assertEquals('aaa'.count('a', -10), 3)
- self.assertEquals('aaa'.count('a', 0, -1), 2)
- self.assertEquals('aaa'.count('a', 0, -10), 0)
+ assert "".count("x") ==0
+ assert "".count("") ==1
+ assert "Python".count("") ==7
+ assert "ab aaba".count("ab") ==2
+ assert 'aaa'.count('a') == 3
+ assert 'aaa'.count('b') == 0
+ assert 'aaa'.count('a', -1) == 1
+ assert 'aaa'.count('a', -10) == 3
+ assert 'aaa'.count('a', 0, -1) == 2
+ assert 'aaa'.count('a', 0, -10) == 0
def test_startswith(self):
- self.assertEquals('ab'.startswith('ab'), 1)
- self.assertEquals('ab'.startswith('a'), 1)
- self.assertEquals('ab'.startswith(''), 1)
- self.assertEquals('x'.startswith('a'), 0)
- self.assertEquals('x'.startswith('x'), 1)
- self.assertEquals(''.startswith(''), 1)
- self.assertEquals(''.startswith('a'), 0)
- self.assertEquals('x'.startswith('xx'), 0)
- self.assertEquals('y'.startswith('xx'), 0)
+ assert 'ab'.startswith('ab') == 1
+ assert 'ab'.startswith('a') == 1
+ assert 'ab'.startswith('') == 1
+ assert 'x'.startswith('a') == 0
+ assert 'x'.startswith('x') == 1
+ assert ''.startswith('') == 1
+ assert ''.startswith('a') == 0
+ assert 'x'.startswith('xx') == 0
+ assert 'y'.startswith('xx') == 0
def test_endswith(self):
- self.assertEquals('ab'.endswith('ab'), 1)
- self.assertEquals('ab'.endswith('b'), 1)
- self.assertEquals('ab'.endswith(''), 1)
- self.assertEquals('x'.endswith('a'), 0)
- self.assertEquals('x'.endswith('x'), 1)
- self.assertEquals(''.endswith(''), 1)
- self.assertEquals(''.endswith('a'), 0)
- self.assertEquals('x'.endswith('xx'), 0)
- self.assertEquals('y'.endswith('xx'), 0)
+ assert 'ab'.endswith('ab') == 1
+ assert 'ab'.endswith('b') == 1
+ assert 'ab'.endswith('') == 1
+ assert 'x'.endswith('a') == 0
+ assert 'x'.endswith('x') == 1
+ assert ''.endswith('') == 1
+ assert ''.endswith('a') == 0
+ assert 'x'.endswith('xx') == 0
+ assert 'y'.endswith('xx') == 0
def test_expandtabs(self):
- self.assertEquals('abc\rab\tdef\ng\thi'.expandtabs(), 'abc\rab def\ng hi')
- self.assertEquals('abc\rab\tdef\ng\thi'.expandtabs(8), 'abc\rab def\ng hi')
- self.assertEquals('abc\rab\tdef\ng\thi'.expandtabs(4), 'abc\rab def\ng hi')
- self.assertEquals('abc\r\nab\tdef\ng\thi'.expandtabs(4), 'abc\r\nab def\ng hi')
- self.assertEquals('abc\rab\tdef\ng\thi'.expandtabs(), 'abc\rab def\ng hi')
- self.assertEquals('abc\rab\tdef\ng\thi'.expandtabs(8), 'abc\rab def\ng hi')
- self.assertEquals('abc\r\nab\r\ndef\ng\r\nhi'.expandtabs(4), 'abc\r\nab\r\ndef\ng\r\nhi')
+ assert 'abc\rab\tdef\ng\thi'.expandtabs() == 'abc\rab def\ng hi'
+ assert 'abc\rab\tdef\ng\thi'.expandtabs(8) == 'abc\rab def\ng hi'
+ assert 'abc\rab\tdef\ng\thi'.expandtabs(4) == 'abc\rab def\ng hi'
+ assert 'abc\r\nab\tdef\ng\thi'.expandtabs(4) == 'abc\r\nab def\ng hi'
+ assert 'abc\rab\tdef\ng\thi'.expandtabs() == 'abc\rab def\ng hi'
+ assert 'abc\rab\tdef\ng\thi'.expandtabs(8) == 'abc\rab def\ng hi'
+ assert 'abc\r\nab\r\ndef\ng\r\nhi'.expandtabs(4) == 'abc\r\nab\r\ndef\ng\r\nhi'
s = 'xy\t'
- self.assertEquals(s.expandtabs(),'xy ')
+ assert s.expandtabs() =='xy '
s = '\txy\t'
- self.assertEquals(s.expandtabs(),' xy ')
- self.assertEquals(s.expandtabs(1),' xy ')
- self.assertEquals(s.expandtabs(2),' xy ')
- self.assertEquals(s.expandtabs(3),' xy ')
+ assert s.expandtabs() ==' xy '
+ assert s.expandtabs(1) ==' xy '
+ assert s.expandtabs(2) ==' xy '
+ assert s.expandtabs(3) ==' xy '
- self.assertEquals('xy'.expandtabs(),'xy')
- self.assertEquals(''.expandtabs(),'')
+ assert 'xy'.expandtabs() =='xy'
+ assert ''.expandtabs() ==''
def test_splitlines(self):
s="ab\nab\n \n x\n\n\n"
- self.assertEquals(s.splitlines(),['ab', 'ab', ' ', ' x', '', ''])
- self.assertEquals(s.splitlines(),s.splitlines(0))
- self.assertEquals(s.splitlines(1),['ab\n', 'ab\n', ' \n', ' x\n', '\n', '\n'])
+ assert s.splitlines() ==['ab', 'ab', ' ', ' x', '', '']
+ assert s.splitlines() ==s.splitlines(0)
+ assert s.splitlines(1) ==['ab\n', 'ab\n', ' \n', ' x\n', '\n', '\n']
s="\none\n\two\nthree\n\n"
- self.assertEquals(s.splitlines(),['', 'one', '\two', 'three', ''])
- self.assertEquals(s.splitlines(1),['\n', 'one\n', '\two\n', 'three\n', '\n'])
+ assert s.splitlines() ==['', 'one', '\two', 'three', '']
+ assert s.splitlines(1) ==['\n', 'one\n', '\two\n', 'three\n', '\n']
def test_find(self):
- self.assertEquals('abcdefghiabc'.find('abc'), 0)
- self.assertEquals('abcdefghiabc'.find('abc', 1), 9)
- self.assertEquals('abcdefghiabc'.find('def', 4), -1)
+ assert 'abcdefghiabc'.find('abc') == 0
+ assert 'abcdefghiabc'.find('abc', 1) == 9
+ assert 'abcdefghiabc'.find('def', 4) == -1
def test_index(self):
- self.assertEquals('abcdefghiabc'.index(''), 0)
- self.assertEquals('abcdefghiabc'.index('def'), 3)
- self.assertEquals('abcdefghiabc'.index('abc'), 0)
- self.assertEquals('abcdefghiabc'.index('abc', 1), 9)
+ assert 'abcdefghiabc'.index('') == 0
+ assert 'abcdefghiabc'.index('def') == 3
+ assert 'abcdefghiabc'.index('abc') == 0
+ assert 'abcdefghiabc'.index('abc', 1) == 9
#XXX it comes UnicodeError
#self.assertRaises(ValueError, 'abcdefghiabc'.index('hib'))
#self.assertRaises(ValueError, 'abcdefghiab'.index('abc', 1))
@@ -336,16 +331,16 @@
#self.assertRaises(ValueError, 'abcdefghi'.index('ghi', -1))
def test_rfind(self):
- self.assertEquals('abcdefghiabc'.rfind('abc'), 9)
- self.assertEquals('abcdefghiabc'.rfind(''), 12)
- self.assertEquals('abcdefghiabc'.rfind('abcd'), 0)
- self.assertEquals('abcdefghiabc'.rfind('abcz'), -1)
+ assert 'abcdefghiabc'.rfind('abc') == 9
+ assert 'abcdefghiabc'.rfind('') == 12
+ assert 'abcdefghiabc'.rfind('abcd') == 0
+ assert 'abcdefghiabc'.rfind('abcz') == -1
def test_rindex(self):
- self.assertEquals('abcdefghiabc'.rindex(''), 12)
- self.assertEquals('abcdefghiabc'.rindex('def'), 3)
- self.assertEquals('abcdefghiabc'.rindex('abc'), 9)
- self.assertEquals('abcdefghiabc'.rindex('abc', 0, -1), 0)
+ assert 'abcdefghiabc'.rindex('') == 12
+ assert 'abcdefghiabc'.rindex('def') == 3
+ assert 'abcdefghiabc'.rindex('abc') == 9
+ assert 'abcdefghiabc'.rindex('abc', 0, -1) == 0
#XXX it comes UnicodeError
#self.assertRaises(ValueError, 'abcdefghiabc'.rindex('hib'))
#self.assertRaises(ValueError, 'defghiabc'.rindex('def', 1))
@@ -355,79 +350,79 @@
def test_split_maxsplit(self):
- self.assertEquals("/a/b/c".split('/', 2), ['','a','b/c'])
- self.assertEquals("a/b/c".split("/"), ['a', 'b', 'c'])
- self.assertEquals(" a ".split(None, 0), ['a '])
- self.assertEquals(" a ".split(None, 1), ['a'])
- self.assertEquals(" a a ".split(" ", 0), [' a a '])
- self.assertEquals(" a a ".split(" ", 1), ['', 'a a '])
+ assert "/a/b/c".split('/', 2) == ['','a','b/c']
+ assert "a/b/c".split("/") == ['a', 'b', 'c']
+ assert " a ".split(None, 0) == ['a ']
+ assert " a ".split(None, 1) == ['a']
+ assert " a a ".split(" ", 0) == [' a a ']
+ assert " a a ".split(" ", 1) == ['', 'a a ']
def test_join(self):
- self.assertEquals(", ".join(['a', 'b', 'c']), "a, b, c")
- self.assertEquals("".join([]), "")
- self.assertEquals("-".join(['a', 'b']), 'a-b')
- self.assertRaises(TypeError, ''.join, 1)
- self.assertRaises(TypeError, ''.join, [1])
- self.assertRaises(TypeError, ''.join, [[1]])
+ assert ", ".join(['a', 'b', 'c']) == "a, b, c"
+ assert "".join([]) == ""
+ assert "-".join(['a', 'b']) == 'a-b'
+ raises(TypeError, ''.join, 1)
+ raises(TypeError, ''.join, [1])
+ raises(TypeError, ''.join, [[1]])
def test_lower(self):
- self.assertEquals("aaa AAA".lower(), "aaa aaa")
- self.assertEquals("".lower(), "")
+ assert "aaa AAA".lower() == "aaa aaa"
+ assert "".lower() == ""
def test_upper(self):
- self.assertEquals("aaa AAA".upper(), "AAA AAA")
- self.assertEquals("".upper(), "")
+ assert "aaa AAA".upper() == "AAA AAA"
+ assert "".upper() == ""
def test_isalnum(self):
- self.assertEquals("".isalnum(), False)
- self.assertEquals("!Bro12345w&&&&n Fox".isalnum(), False)
- self.assertEquals("125 Brown Foxes".isalnum(), False)
- self.assertEquals("125BrownFoxes".isalnum(), True)
+ assert "".isalnum() == False
+ assert "!Bro12345w&&&&n Fox".isalnum() == False
+ assert "125 Brown Foxes".isalnum() == False
+ assert "125BrownFoxes".isalnum() == True
def test_isalpha(self):
- self.assertEquals("".isalpha(), False)
- self.assertEquals("!Bro12345w&&&&nFox".isalpha(), False)
- self.assertEquals("Brown Foxes".isalpha(), False)
- self.assertEquals("125".isalpha(), False)
+ assert "".isalpha() == False
+ assert "!Bro12345w&&&&nFox".isalpha() == False
+ assert "Brown Foxes".isalpha() == False
+ assert "125".isalpha() == False
def test_isdigit(self):
- self.assertEquals("".isdigit(), False)
- self.assertEquals("!Bro12345w&&&&nFox".isdigit(), False)
- self.assertEquals("Brown Foxes".isdigit(), False)
- self.assertEquals("125".isdigit(), True)
+ assert "".isdigit() == False
+ assert "!Bro12345w&&&&nFox".isdigit() == False
+ assert "Brown Foxes".isdigit() == False
+ assert "125".isdigit() == True
def test_isspace(self):
- self.assertEquals("".isspace(), False)
- self.assertEquals("!Bro12345w&&&&nFox".isspace(), False)
- self.assertEquals(" ".isspace(), True)
- self.assertEquals("\t\t\b\b\n".isspace(), False)
- self.assertEquals("\t\t".isspace(), True)
- self.assertEquals("\t\t\r\r\n".isspace(), True)
+ assert "".isspace() == False
+ assert "!Bro12345w&&&&nFox".isspace() == False
+ assert " ".isspace() == True
+ assert "\t\t\b\b\n".isspace() == False
+ assert "\t\t".isspace() == True
+ assert "\t\t\r\r\n".isspace() == True
def test_islower(self):
- self.assertEquals("".islower(), False)
- self.assertEquals(" ".islower(), False)
- self.assertEquals("\t\t\b\b\n".islower(), False)
- self.assertEquals("b".islower(), True)
- self.assertEquals("bbb".islower(), True)
- self.assertEquals("!bbb".islower(), False)
- self.assertEquals("BBB".islower(), False)
- self.assertEquals("bbbBBB".islower(), False)
+ assert "".islower() == False
+ assert " ".islower() == False
+ assert "\t\t\b\b\n".islower() == False
+ assert "b".islower() == True
+ assert "bbb".islower() == True
+ assert "!bbb".islower() == False
+ assert "BBB".islower() == False
+ assert "bbbBBB".islower() == False
def test_isupper(self):
- self.assertEquals("".isupper(), False)
- self.assertEquals(" ".isupper(), False)
- self.assertEquals("\t\t\b\b\n".isupper(), False)
- self.assertEquals("B".isupper(), True)
- self.assertEquals("BBB".isupper(), True)
- self.assertEquals("!BBB".isupper(), False)
- self.assertEquals("bbb".isupper(), False)
- self.assertEquals("BBBbbb".isupper(), False)
+ assert "".isupper() == False
+ assert " ".isupper() == False
+ assert "\t\t\b\b\n".isupper() == False
+ assert "B".isupper() == True
+ assert "BBB".isupper() == True
+ assert "!BBB".isupper() == False
+ assert "bbb".isupper() == False
+ assert "BBBbbb".isupper() == False
def test_swapcase(self):
- self.assertEquals("aaa AAA 111".swapcase(), "AAA aaa 111")
- self.assertEquals("".swapcase(), "")
+ assert "aaa AAA 111".swapcase() == "AAA aaa 111"
+ assert "".swapcase() == ""
def test_translate(self):
def maketrans(origin, image):
@@ -441,12 +436,12 @@
return tbl
table = maketrans('abc', 'xyz')
- self.assertEquals('xyzxyz', 'xyzabcdef'.translate(table, 'def'))
+ assert 'xyzxyz' == 'xyzabcdef'.translate(table, 'def')
table = maketrans('a', 'A')
- self.assertEquals('Abc', 'abc'.translate(table))
- self.assertEquals('xyz', 'xyz'.translate(table))
- self.assertEquals('yz', 'xyz'.translate(table, 'x'))
+ assert 'Abc' == 'abc'.translate(table)
+ assert 'xyz' == 'xyz'.translate(table)
+ assert 'yz' == 'xyz'.translate(table, 'x')
#self.assertRaises(ValueError, 'xyz'.translate('too short', 'strip'))
#self.assertRaises(ValueError, 'xyz'.translate('too short'))
@@ -455,34 +450,30 @@
l=[]
for i in iter("42"):
l.append(i)
- self.assertEquals(l, ['4','2'])
+ assert l == ['4','2']
def test_repr(self):
- self.assertEquals(repr("") ,"''")
- self.assertEquals(repr("a") ,"'a'")
- self.assertEquals(repr("'") ,'"\'"')
- self.assertEquals(repr("\'") ,"\"\'\"")
- self.assertEquals(repr("\"") ,'\'"\'')
- self.assertEquals(repr("\t") ,"'\\t'")
- self.assertEquals(repr("\\") ,"'\\\\'")
- self.assertEquals(repr('') ,"''")
- self.assertEquals(repr('a') ,"'a'")
- self.assertEquals(repr('"') ,"'\"'")
- self.assertEquals(repr('\'') ,'"\'"')
- self.assertEquals(repr('\"') ,"'\"'")
- self.assertEquals(repr('\t') ,"'\\t'")
- self.assertEquals(repr('\\') ,"'\\\\'")
- self.assertEquals(repr("'''\"") ,'\'\\\'\\\'\\\'"\'')
- self.assertEquals(repr(chr(19)) ,"'\\x13'")
- self.assertEquals(repr(chr(2)) ,"'\\x02'")
+ assert repr("") =="''"
+ assert repr("a") =="'a'"
+ assert repr("'") =='"\'"'
+ assert repr("\'") =="\"\'\""
+ assert repr("\"") =='\'"\''
+ assert repr("\t") =="'\\t'"
+ assert repr("\\") =="'\\\\'"
+ assert repr('') =="''"
+ assert repr('a') =="'a'"
+ assert repr('"') =="'\"'"
+ assert repr('\'') =='"\'"'
+ assert repr('\"') =="'\"'"
+ assert repr('\t') =="'\\t'"
+ assert repr('\\') =="'\\\\'"
+ assert repr("'''\"") =='\'\\\'\\\'\\\'"\''
+ assert repr(chr(19)) =="'\\x13'"
+ assert repr(chr(2)) =="'\\x02'"
def test_contains(self):
- self.failUnless('' in 'abc')
- self.failUnless('a' in 'abc')
- self.failUnless('ab' in 'abc')
- self.failIf('d' in 'abc')
- self.assertRaises(TypeError, 'a'.__contains__, 1)
-
-
-if __name__ == '__main__':
- testit.main()
+ assert '' in 'abc'
+ assert 'a' in 'abc'
+ assert 'ab' in 'abc'
+ assert not 'd' in 'abc'
+ raises(TypeError, 'a'.__contains__, 1)
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_strutil.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_strutil.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_strutil.py Mon Jan 10 17:19:39 2005
@@ -1,8 +1,9 @@
import autopath
-from pypy.tool import testit
from pypy.objspace.std.strutil import *
-class TestStrUtil(testit.TestCase):
+objspacename = 'std'
+
+class TestStrUtil:
def test_string_to_int(self):
cases = [('0', 0),
@@ -21,8 +22,8 @@
(' -123456789 ', -123456789),
]
for s, expected in cases:
- self.assertEquals(string_to_int(s), expected)
- self.assertEquals(string_to_long(s), expected)
+ assert string_to_int(s) == expected
+ assert string_to_long(s) == expected
def test_string_to_int_base(self):
cases = [('111', 2, 7),
@@ -50,12 +51,12 @@
('0X', 16, 0), # " "
]
for s, base, expected in cases:
- self.assertEquals(string_to_int(s, base), expected)
- self.assertEquals(string_to_int('+'+s, base), expected)
- self.assertEquals(string_to_int('-'+s, base), -expected)
- self.assertEquals(string_to_int(s+'\n', base), expected)
- self.assertEquals(string_to_int(' +'+s, base), expected)
- self.assertEquals(string_to_int('-'+s+' ', base), -expected)
+ assert string_to_int(s, base) == expected
+ assert string_to_int('+'+s, base) == expected
+ assert string_to_int('-'+s, base) == -expected
+ assert string_to_int(s+'\n', base) == expected
+ assert string_to_int(' +'+s, base) == expected
+ assert string_to_int('-'+s+' ', base) == -expected
def test_string_to_int_error(self):
cases = ['0x123', # must use base 0 or 16
@@ -75,11 +76,11 @@
'@',
]
for s in cases:
- self.assertRaises(ValueError, string_to_int, s)
- self.assertRaises(ValueError, string_to_int, ' '+s)
- self.assertRaises(ValueError, string_to_int, s+' ')
- self.assertRaises(ValueError, string_to_int, '+'+s)
- self.assertRaises(ValueError, string_to_int, '-'+s)
+ raises(ValueError, string_to_int, s)
+ raises(ValueError, string_to_int, ' '+s)
+ raises(ValueError, string_to_int, s+' ')
+ raises(ValueError, string_to_int, '+'+s)
+ raises(ValueError, string_to_int, '-'+s)
def test_string_to_int_base_error(self):
cases = [('1', 1),
@@ -97,21 +98,18 @@
('12.3', 16),
]
for s, base in cases:
- self.assertRaises(ValueError, string_to_int, s, base)
- self.assertRaises(ValueError, string_to_int, ' '+s, base)
- self.assertRaises(ValueError, string_to_int, s+' ', base)
- self.assertRaises(ValueError, string_to_int, '+'+s, base)
- self.assertRaises(ValueError, string_to_int, '-'+s, base)
+ raises(ValueError, string_to_int, s, base)
+ raises(ValueError, string_to_int, ' '+s, base)
+ raises(ValueError, string_to_int, s+' ', base)
+ raises(ValueError, string_to_int, '+'+s, base)
+ raises(ValueError, string_to_int, '-'+s, base)
def test_string_to_long(self):
- self.assertEquals(string_to_long('123L'), 123)
- self.assertEquals(string_to_long('123L '), 123)
- self.assertRaises(ValueError, string_to_long, 'L')
- self.assertRaises(ValueError, string_to_long, 'L ')
- self.assertEquals(string_to_long('123L', 4), 27)
- self.assertEquals(string_to_long('123L', 30), 27000 + 1800 + 90 + 21)
- self.assertEquals(string_to_long('123L', 22), 10648 + 968 + 66 + 21)
- self.assertEquals(string_to_long('123L', 21), 441 + 42 + 3)
-
-if __name__ == '__main__':
- testit.main()
+ assert string_to_long('123L') == 123
+ assert string_to_long('123L ') == 123
+ raises(ValueError, string_to_long, 'L')
+ raises(ValueError, string_to_long, 'L ')
+ assert string_to_long('123L', 4) == 27
+ assert string_to_long('123L', 30) == 27000 + 1800 + 90 + 21
+ assert string_to_long('123L', 22) == 10648 + 968 + 66 + 21
+ assert string_to_long('123L', 21) == 441 + 42 + 3
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_tupleobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_tupleobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_tupleobject.py Mon Jan 10 17:19:39 2005
@@ -1,70 +1,65 @@
#from __future__ import nested_scopes
import autopath
-from pypy.tool import testit
from pypy.objspace.std.tupleobject import W_TupleObject
from pypy.interpreter.error import OperationError
-class TestW_TupleObject(testit.TestCase):
+objspacename = 'std'
- def setUp(self):
- self.space = testit.objspace('std')
-
- def tearDown(self):
- pass
+class TestW_TupleObject:
def test_is_true(self):
w = self.space.wrap
w_tuple = W_TupleObject(self.space, [])
- self.assertEqual(self.space.is_true(w_tuple), False)
+ assert self.space.is_true(w_tuple) == False
w_tuple = W_TupleObject(self.space, [w(5)])
- self.assertEqual(self.space.is_true(w_tuple), True)
+ assert self.space.is_true(w_tuple) == True
w_tuple = W_TupleObject(self.space, [w(5), w(3)])
- self.assertEqual(self.space.is_true(w_tuple), True)
+ assert self.space.is_true(w_tuple) == True
def test_len(self):
w = self.space.wrap
w_tuple = W_TupleObject(self.space, [])
- self.assertEqual_w(self.space.len(w_tuple), w(0))
+ assert self.space.eq_w(self.space.len(w_tuple), w(0))
w_tuple = W_TupleObject(self.space, [w(5)])
- self.assertEqual_w(self.space.len(w_tuple), w(1))
+ assert self.space.eq_w(self.space.len(w_tuple), w(1))
w_tuple = W_TupleObject(self.space, [w(5), w(3), w(99)]*111)
- self.assertEqual_w(self.space.len(w_tuple), w(333))
+ assert self.space.eq_w(self.space.len(w_tuple), w(333))
def test_getitem(self):
w = self.space.wrap
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))
- self.assertEqual_w(self.space.getitem(w_tuple, w(-1)), w(3))
- self.assertRaises_w(self.space.w_IndexError,
+ assert self.space.eq_w(self.space.getitem(w_tuple, w(0)), w(5))
+ assert self.space.eq_w(self.space.getitem(w_tuple, w(1)), w(3))
+ assert self.space.eq_w(self.space.getitem(w_tuple, w(-2)), w(5))
+ assert self.space.eq_w(self.space.getitem(w_tuple, w(-1)), w(3))
+ self.space.raises_w(self.space.w_IndexError,
self.space.getitem, w_tuple, w(2))
- self.assertRaises_w(self.space.w_IndexError,
+ self.space.raises_w(self.space.w_IndexError,
self.space.getitem, w_tuple, w(42))
- self.assertRaises_w(self.space.w_IndexError,
+ self.space.raises_w(self.space.w_IndexError,
self.space.getitem, w_tuple, w(-3))
def test_iter(self):
w = self.space.wrap
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))
- self.assertEqual_w(self.space.next(w_iter), w(99))
- self.assertRaises(OperationError, self.space.next, w_iter)
- self.assertRaises(OperationError, self.space.next, w_iter)
+ assert self.space.eq_w(self.space.next(w_iter), w(5))
+ assert self.space.eq_w(self.space.next(w_iter), w(3))
+ assert self.space.eq_w(self.space.next(w_iter), w(99))
+ raises(OperationError, self.space.next, w_iter)
+ raises(OperationError, self.space.next, w_iter)
def test_contains(self):
w = self.space.wrap
w_tuple = W_TupleObject(self.space, [w(5), w(3), w(99)])
- self.assertEqual_w(self.space.contains(w_tuple, w(5)),
+ assert self.space.eq_w(self.space.contains(w_tuple, w(5)),
self.space.w_True)
- self.assertEqual_w(self.space.contains(w_tuple, w(99)),
+ assert self.space.eq_w(self.space.contains(w_tuple, w(99)),
self.space.w_True)
- self.assertEqual_w(self.space.contains(w_tuple, w(11)),
+ assert self.space.eq_w(self.space.contains(w_tuple, w(11)),
self.space.w_False)
- self.assertEqual_w(self.space.contains(w_tuple, w_tuple),
+ assert self.space.eq_w(self.space.contains(w_tuple, w_tuple),
self.space.w_False)
def test_add(self):
@@ -72,14 +67,14 @@
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),
+ assert self.space.eq_w(self.space.add(w_tuple1, w_tuple1),
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),
+ assert self.space.eq_w(self.space.add(w_tuple1, w_tuple2),
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)
+ assert self.space.eq_w(self.space.add(w_tuple1, w_tuple0), w_tuple1)
+ assert self.space.eq_w(self.space.add(w_tuple0, w_tuple2), w_tuple2)
def test_mul(self):
# only testing right mul at the moment
@@ -89,10 +84,10 @@
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)
+ assert self.space.eq_w(w_tup3, w_res)
# commute
w_res = self.space.mul(w(n), w_tup)
- self.assertEqual_w(w_tup3, w_res)
+ assert self.space.eq_w(w_tup3, w_res)
def test_getslice(self):
w = self.space.wrap
@@ -101,7 +96,7 @@
w_slice = self.space.newslice(w(start), w(stop), w(step))
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)
+ assert self.space.unwrap(w_result) == expected
for testtuple in [(), (5,3,99), tuple(range(5,555,10))]:
for start in [-2, -1, 0, 1, 10]:
@@ -123,15 +118,15 @@
w_tuple2 = W_TupleObject(self.space, [w(5), w(3), w(99)])
w_tuple3 = W_TupleObject(self.space, [w(5), w(3), w(99), w(-1)])
- self.assertEqual_w(self.space.eq(w_tuple0, w_tuple1),
+ assert self.space.eq_w(self.space.eq(w_tuple0, w_tuple1),
self.space.w_False)
- self.assertEqual_w(self.space.eq(w_tuple1, w_tuple0),
+ assert self.space.eq_w(self.space.eq(w_tuple1, w_tuple0),
self.space.w_False)
- self.assertEqual_w(self.space.eq(w_tuple1, w_tuple1),
+ assert self.space.eq_w(self.space.eq(w_tuple1, w_tuple1),
self.space.w_True)
- self.assertEqual_w(self.space.eq(w_tuple1, w_tuple2),
+ assert self.space.eq_w(self.space.eq(w_tuple1, w_tuple2),
self.space.w_True)
- self.assertEqual_w(self.space.eq(w_tuple2, w_tuple3),
+ assert self.space.eq_w(self.space.eq(w_tuple2, w_tuple3),
self.space.w_False)
def test_ne(self):
w = self.space.wrap
@@ -141,15 +136,15 @@
w_tuple2 = W_TupleObject(self.space, [w(5), w(3), w(99)])
w_tuple3 = W_TupleObject(self.space, [w(5), w(3), w(99), w(-1)])
- self.assertEqual_w(self.space.ne(w_tuple0, w_tuple1),
+ assert self.space.eq_w(self.space.ne(w_tuple0, w_tuple1),
self.space.w_True)
- self.assertEqual_w(self.space.ne(w_tuple1, w_tuple0),
+ assert self.space.eq_w(self.space.ne(w_tuple1, w_tuple0),
self.space.w_True)
- self.assertEqual_w(self.space.ne(w_tuple1, w_tuple1),
+ assert self.space.eq_w(self.space.ne(w_tuple1, w_tuple1),
self.space.w_False)
- self.assertEqual_w(self.space.ne(w_tuple1, w_tuple2),
+ assert self.space.eq_w(self.space.ne(w_tuple1, w_tuple2),
self.space.w_False)
- self.assertEqual_w(self.space.ne(w_tuple2, w_tuple3),
+ assert self.space.eq_w(self.space.ne(w_tuple2, w_tuple3),
self.space.w_True)
def test_lt(self):
w = self.space.wrap
@@ -160,17 +155,17 @@
w_tuple3 = W_TupleObject(self.space, [w(5), w(3), w(99), w(-1)])
w_tuple4 = W_TupleObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.lt(w_tuple0, w_tuple1),
+ assert self.space.eq_w(self.space.lt(w_tuple0, w_tuple1),
self.space.w_True)
- self.assertEqual_w(self.space.lt(w_tuple1, w_tuple0),
+ assert self.space.eq_w(self.space.lt(w_tuple1, w_tuple0),
self.space.w_False)
- self.assertEqual_w(self.space.lt(w_tuple1, w_tuple1),
+ assert self.space.eq_w(self.space.lt(w_tuple1, w_tuple1),
self.space.w_False)
- self.assertEqual_w(self.space.lt(w_tuple1, w_tuple2),
+ assert self.space.eq_w(self.space.lt(w_tuple1, w_tuple2),
self.space.w_False)
- self.assertEqual_w(self.space.lt(w_tuple2, w_tuple3),
+ assert self.space.eq_w(self.space.lt(w_tuple2, w_tuple3),
self.space.w_True)
- self.assertEqual_w(self.space.lt(w_tuple4, w_tuple3),
+ assert self.space.eq_w(self.space.lt(w_tuple4, w_tuple3),
self.space.w_True)
def test_ge(self):
@@ -182,17 +177,17 @@
w_tuple3 = W_TupleObject(self.space, [w(5), w(3), w(99), w(-1)])
w_tuple4 = W_TupleObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.ge(w_tuple0, w_tuple1),
+ assert self.space.eq_w(self.space.ge(w_tuple0, w_tuple1),
self.space.w_False)
- self.assertEqual_w(self.space.ge(w_tuple1, w_tuple0),
+ assert self.space.eq_w(self.space.ge(w_tuple1, w_tuple0),
self.space.w_True)
- self.assertEqual_w(self.space.ge(w_tuple1, w_tuple1),
+ assert self.space.eq_w(self.space.ge(w_tuple1, w_tuple1),
self.space.w_True)
- self.assertEqual_w(self.space.ge(w_tuple1, w_tuple2),
+ assert self.space.eq_w(self.space.ge(w_tuple1, w_tuple2),
self.space.w_True)
- self.assertEqual_w(self.space.ge(w_tuple2, w_tuple3),
+ assert self.space.eq_w(self.space.ge(w_tuple2, w_tuple3),
self.space.w_False)
- self.assertEqual_w(self.space.ge(w_tuple4, w_tuple3),
+ assert self.space.eq_w(self.space.ge(w_tuple4, w_tuple3),
self.space.w_False)
def test_gt(self):
@@ -204,17 +199,17 @@
w_tuple3 = W_TupleObject(self.space, [w(5), w(3), w(99), w(-1)])
w_tuple4 = W_TupleObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.gt(w_tuple0, w_tuple1),
+ assert self.space.eq_w(self.space.gt(w_tuple0, w_tuple1),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_tuple1, w_tuple0),
+ assert self.space.eq_w(self.space.gt(w_tuple1, w_tuple0),
self.space.w_True)
- self.assertEqual_w(self.space.gt(w_tuple1, w_tuple1),
+ assert self.space.eq_w(self.space.gt(w_tuple1, w_tuple1),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_tuple1, w_tuple2),
+ assert self.space.eq_w(self.space.gt(w_tuple1, w_tuple2),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_tuple2, w_tuple3),
+ assert self.space.eq_w(self.space.gt(w_tuple2, w_tuple3),
self.space.w_False)
- self.assertEqual_w(self.space.gt(w_tuple4, w_tuple3),
+ assert self.space.eq_w(self.space.gt(w_tuple4, w_tuple3),
self.space.w_False)
def test_le(self):
@@ -226,18 +221,15 @@
w_tuple3 = W_TupleObject(self.space, [w(5), w(3), w(99), w(-1)])
w_tuple4 = W_TupleObject(self.space, [w(5), w(3), w(9), w(-1)])
- self.assertEqual_w(self.space.le(w_tuple0, w_tuple1),
+ assert self.space.eq_w(self.space.le(w_tuple0, w_tuple1),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_tuple1, w_tuple0),
+ assert self.space.eq_w(self.space.le(w_tuple1, w_tuple0),
self.space.w_False)
- self.assertEqual_w(self.space.le(w_tuple1, w_tuple1),
+ assert self.space.eq_w(self.space.le(w_tuple1, w_tuple1),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_tuple1, w_tuple2),
+ assert self.space.eq_w(self.space.le(w_tuple1, w_tuple2),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_tuple2, w_tuple3),
+ assert self.space.eq_w(self.space.le(w_tuple2, w_tuple3),
self.space.w_True)
- self.assertEqual_w(self.space.le(w_tuple4, w_tuple3),
+ assert self.space.eq_w(self.space.le(w_tuple4, w_tuple3),
self.space.w_True)
-
-if __name__ == '__main__':
- testit.main()
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_typeobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_typeobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_typeobject.py Mon Jan 10 17:19:39 2005
@@ -1,5 +1,4 @@
import autopath
-from pypy.tool import testit
##class TestSpecialMultimethodCode(testit.TestCase):
@@ -53,41 +52,40 @@
## w({'x1': 5.5, 'x2': 7})),
## w(-1.5))
-class TestTypeObject(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
+objspacename = 'std'
+class AppTestTypeObject:
def test_bases(self):
- self.assertEquals(int.__bases__, (object,))
+ assert int.__bases__ == (object,)
class X: pass
- self.assertEquals(X.__bases__, (object,))
+ assert X.__bases__ == (object,)
class Y(X): pass
- self.assertEquals(Y.__bases__, (X,))
+ assert Y.__bases__ == (X,)
class Z(Y,X): pass
- self.assertEquals(Z.__bases__, (Y, X))
+ assert Z.__bases__ == (Y, X)
def test_builtin_add(self):
x = 5
- self.assertEquals(x.__add__(6), 11)
+ assert x.__add__(6) == 11
x = 3.5
- self.assertEquals(x.__add__(2), 5.5)
- self.assertEquals(x.__add__(2.0), 5.5)
+ assert x.__add__(2) == 5.5
+ assert x.__add__(2.0) == 5.5
def test_builtin_call(self):
def f(*args):
return args
- self.assertEquals(f.__call__(), ())
- self.assertEquals(f.__call__(5), (5,))
- self.assertEquals(f.__call__("hello", "world"), ("hello", "world"))
+ assert f.__call__() == ()
+ assert f.__call__(5) == (5,)
+ assert f.__call__("hello", "world") == ("hello", "world")
def test_builtin_call_kwds(self):
def f(*args, **kwds):
return args, kwds
- self.assertEquals(f.__call__(), ((), {}))
- self.assertEquals(f.__call__("hello", "world"), (("hello", "world"), {}))
- self.assertEquals(f.__call__(5, bla=6), ((5,), {"bla": 6}))
- self.assertEquals(f.__call__(a=1, b=2, c=3), ((), {"a": 1, "b": 2,
- "c": 3}))
+ assert f.__call__() == ((), {})
+ assert f.__call__("hello", "world") == (("hello", "world"), {})
+ assert f.__call__(5, bla=6) == ((5,), {"bla": 6})
+ assert f.__call__(a=1, b=2, c=3) == ((), {"a": 1, "b": 2,
+ "c": 3})
def test_multipleinheritance_fail(self):
try:
@@ -105,15 +103,15 @@
class HasOuterMetaclass(object):
__metaclass__ = OuterMetaClass
- self.assertEquals(type(HasOuterMetaclass), OuterMetaClass)
- self.assertEquals(type(HasOuterMetaclass), HasOuterMetaclass.__metaclass__)
+ assert type(HasOuterMetaclass) == OuterMetaClass
+ assert type(HasOuterMetaclass) == HasOuterMetaclass.__metaclass__
def test_inner_metaclass(self):
class HasInnerMetaclass(object):
class __metaclass__(type):
pass
- self.assertEquals(type(HasInnerMetaclass), HasInnerMetaclass.__metaclass__)
+ assert type(HasInnerMetaclass) == HasInnerMetaclass.__metaclass__
def test_implicit_metaclass(self):
global __metaclass__
@@ -130,7 +128,7 @@
pass
try:
- self.assertEquals(type(HasImplicitMetaclass), __metaclass__)
+ assert type(HasImplicitMetaclass) == __metaclass__
finally:
if has_old_metaclass:
__metaclass__ = old_metaclass
@@ -148,20 +146,20 @@
def mro(self):
return [self, object]
- self.assertEquals(B_mro.__bases__, (A_mro,))
- self.assertEquals(B_mro.__mro__, (B_mro, object))
- self.assertEquals(B_mro.mro(), [B_mro, object])
- self.assertEquals(B_mro.b, 1)
- self.assertEquals(B_mro().b, 1)
- self.assertEquals(getattr(B_mro, 'a', None), None)
- self.assertEquals(getattr(B_mro(), 'a', None), None)
+ assert B_mro.__bases__ == (A_mro,)
+ assert B_mro.__mro__ == (B_mro, object)
+ assert B_mro.mro() == [B_mro, object]
+ assert B_mro.b == 1
+ assert B_mro().b == 1
+ assert getattr(B_mro, 'a', None) == None
+ assert getattr(B_mro(), 'a', None) == None
def test_nodoc(self):
class NoDoc(object):
pass
try:
- self.assertEquals(NoDoc.__doc__, None)
+ assert NoDoc.__doc__ == None
except AttributeError:
raise AssertionError, "__doc__ missing!"
@@ -169,13 +167,13 @@
class ExplicitDoc(object):
__doc__ = 'foo'
- self.assertEquals(ExplicitDoc.__doc__, 'foo')
+ assert ExplicitDoc.__doc__ == 'foo'
def test_implicitdoc(self):
class ImplicitDoc(object):
"foo"
- self.assertEquals(ImplicitDoc.__doc__, 'foo')
+ assert ImplicitDoc.__doc__ == 'foo'
def test_immutabledoc(self):
class ImmutableDoc(object):
@@ -192,8 +190,4 @@
else:
raise AssertionError, '__doc__ should not be writable'
- self.assertEquals(ImmutableDoc.__doc__, 'foo')
-
-
-if __name__ == '__main__':
- testit.main()
+ assert ImmutableDoc.__doc__ == 'foo'
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_unicodestring.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_unicodestring.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_unicodestring.py Mon Jan 10 17:19:39 2005
@@ -2,45 +2,39 @@
# really implement unicode yet).
import autopath, sys
-from pypy.tool import testit
-class TestUnicodeStringStdOnly(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
+objspacename = 'std'
+class AppTestUnicodeStringStdOnly:
def test_compares(self):
- self.assertEqual(u'a', 'a')
- self.assertEqual('a', u'a')
- self.assertNotEqual(u'a', 'b')
- self.assertNotEqual('a', u'b')
+ assert u'a' == 'a'
+ assert 'a' == u'a'
+ assert not u'a' == 'b' # xxx u'a' != 'b' fails
+ assert not 'a' == u'b'# xxx 'a' != u'b' fails
-class TestUnicodeString(testit.AppTestCase):
+class AppTestUnicodeString:
def test_addition(self):
def check(a, b):
- self.assertEqual(a, b)
- self.assertEqual(type(a), type(b))
+ assert a == b
+ assert type(a) == type(b)
check(u'a' + 'b', u'ab')
check('a' + u'b', u'ab')
def test_join(self):
def check(a, b):
- self.assertEqual(a, b)
- self.assertEqual(type(a), type(b))
+ assert a == b
+ assert type(a) == type(b)
check(', '.join([u'a']), u'a')
check(', '.join(['a', u'b']), u'a, b')
check(u', '.join(['a', 'b']), u'a, b')
if sys.version_info >= (2,3):
def test_contains_ex(self):
- self.failUnless(u'' in 'abc')
- self.failUnless(u'bc' in 'abc')
- self.failUnless('bc' in 'abc')
+ assert u'' in 'abc'
+ assert u'bc' in 'abc'
+ assert 'bc' in 'abc'
def test_contains(self):
- self.failUnless(u'a' in 'abc')
- self.failUnless('a' in u'abc')
-
-
-if __name__ == '__main__':
- testit.main()
+ assert u'a' in 'abc'
+ assert 'a' in u'abc'
Modified: pypy/branch/src-pytest/pypy/objspace/std/test/test_userobject.py
==============================================================================
--- pypy/branch/src-pytest/pypy/objspace/std/test/test_userobject.py (original)
+++ pypy/branch/src-pytest/pypy/objspace/std/test/test_userobject.py Mon Jan 10 17:19:39 2005
@@ -1,30 +1,28 @@
import autopath
-from pypy.tool import testit
-class TestUserObject(testit.AppTestCase):
- def setUp(self):
- self.space = testit.objspace('std')
+objspacename = 'std'
+class AppTestUserObject:
def test_emptyclass(self):
class empty: pass
inst = empty()
- self.failUnless(isinstance(inst, empty))
+ assert isinstance(inst, empty)
inst.attr=23
- self.assertEquals(inst.attr,23)
+ assert inst.attr ==23
def test_method(self):
class A:
def f(self, v):
return v*42
a = A()
- self.assertEquals(a.f('?'), '??????????????????????????????????????????')
+ assert a.f('?') == '??????????????????????????????????????????'
def test_unboundmethod(self):
class A:
def f(self, v):
return v*17
a = A()
- self.assertEquals(A.f(a, '!'), '!!!!!!!!!!!!!!!!!')
+ assert A.f(a, '!') == '!!!!!!!!!!!!!!!!!'
def test_subclassing(self):
for base in tuple, list, dict, str, int, float:
@@ -36,17 +34,17 @@
if base is not dict: # XXX must be fixed
raise
else:
- self.failUnless(isinstance(stuff, base))
+ assert isinstance(stuff, base)
def test_subclasstuple(self):
class subclass(tuple): pass
stuff = subclass()
- self.failUnless(isinstance(stuff, tuple))
+ assert isinstance(stuff, tuple)
stuff.attr = 23
- self.assertEquals(stuff.attr,23)
- self.assertEquals(len(stuff),0)
+ assert stuff.attr ==23
+ assert len(stuff) ==0
result = stuff + (1,2,3)
- self.assertEquals(len(result),3)
+ assert len(result) ==3
def test_subsubclass(self):
class base:
@@ -54,9 +52,9 @@
class derived(base):
derivedattr = 34
inst = derived()
- self.failUnless(isinstance(inst, base))
- self.assertEquals(inst.baseattr,12)
- self.assertEquals(inst.derivedattr,34)
+ assert isinstance(inst, base)
+ assert inst.baseattr ==12
+ assert inst.derivedattr ==34
def test_descr_get(self):
class C:
@@ -64,7 +62,7 @@
def __get__(self, ob, cls=None):
return 42
prop = desc()
- self.assertEquals(C().prop, 42)
+ assert C().prop == 42
def test_descr_set(self):
class C:
@@ -74,7 +72,7 @@
prop = desc()
c = C()
c.prop = 32
- self.assertEquals(c.wibble, 32)
+ assert c.wibble == 32
def test_descr_delete(self):
class C:
@@ -86,63 +84,60 @@
prop = desc()
c = C()
del c.prop
- self.assertEquals(c.wibble, 22)
+ assert c.wibble == 22
def test_class_setattr(self):
class C:
pass
C.a = 1
- self.assert_(hasattr(C, 'a'))
- self.assertEquals(C.a, 1)
+ assert hasattr(C, 'a')
+ assert C.a == 1
def test_add(self):
class C:
def __add__(self, other):
return self, other
c1 = C()
- self.assertEquals(c1+3, (c1, 3))
+ assert c1+3 == (c1, 3)
def test_call(self):
class C:
def __call__(self, *args):
return args
c1 = C()
- self.assertEquals(c1(), ())
- self.assertEquals(c1(5), (5,))
- self.assertEquals(c1("hello", "world"), ("hello", "world"))
+ assert c1() == ()
+ assert c1(5) == (5,)
+ assert c1("hello", "world") == ("hello", "world")
def test_getattribute(self):
class C:
def __getattribute__(self, name):
return '->' + name
c1 = C()
- self.assertEquals(c1.a, '->a')
+ assert c1.a == '->a'
c1.a = 5
- self.assertEquals(c1.a, '->a')
+ assert c1.a == '->a'
def test_getattr(self):
class C:
def __getattr__(self, name):
return '->' + name
c1 = C()
- self.assertEquals(c1.a, '->a')
+ assert c1.a == '->a'
c1.a = 5
- self.assertEquals(c1.a, 5)
+ assert c1.a == 5
def test_dict(self):
class A(object):
pass
class B(A):
pass
- self.failIf('__dict__' in object.__dict__)
- self.assert_('__dict__' in A.__dict__)
- self.failIf('__dict__' in B.__dict__)
+ assert not '__dict__' in object.__dict__
+ assert '__dict__' in A.__dict__
+ assert not '__dict__' in B.__dict__
a = A()
a.x = 5
- self.assertEquals(a.__dict__, {'x': 5})
+ assert a.__dict__ == {'x': 5}
a.__dict__ = {'y': 6}
- self.assertEquals(a.y, 6)
- self.failIf(hasattr(a, 'x'))
-
-if __name__ == '__main__':
- testit.main()
+ assert a.y == 6
+ assert not hasattr(a, 'x')
Modified: pypy/branch/src-pytest/pypy/tool/fiximport.py
==============================================================================
--- pypy/branch/src-pytest/pypy/tool/fiximport.py (original)
+++ pypy/branch/src-pytest/pypy/tool/fiximport.py Mon Jan 10 17:19:39 2005
@@ -43,8 +43,8 @@
return base_indent,lines
pass_re = re.compile(r"^\s*pass\s*$")
-getobjspace_re = r"testit\.objspace\((.*)\)"
-setspace_re = r"self\.space\s*=\s*"
+getobjspace_re = re.compile(r"testit\.objspace\((.*)\)")
+setspace_re = re.compile(r"self\.space\s*=\s*")
def up_down_port(lines):
npass = 0
@@ -97,6 +97,9 @@
global_objspacename = False
confused = False
+
+ import_autopath_lineno = -1
+
while True:
if pushback:
line = pushback.pop()
@@ -168,6 +171,8 @@
else:
print ' * ignored class', rest
line = 'class ' + rest + '\n'
+ if line.rstrip() == "import autopath":
+ import_autopath_lineno = len(lines)
lines.append(line)
f.close()
More information about the Pypy-commit
mailing list