def test_common_attributes(self):

builtin_type_instances = [None, object(), big(1), "Hello", [0,1], {"a":0}, 0]

builtin_hashable_type_instances = [None, object(), 1, "Hello"]

builtin_types = [type(None), object, int, str, list, dict]

for i in builtin_type_instances:

# Read-only attribute

self.assertRaises(AttributeError, i.__delattr__, "__doc__")

# Non-existent attribute

self.assertRaises(AttributeError, i.__delattr__, "foo")

# Modifying __class__ causes a TypeError

self.assertRaises(TypeError, i.__delattr__, "__class__")

# Read-only attribute

self.assertRaises(TypeError, i.__setattr__, "__doc__")

# Non-existent attribute

self.assertRaises(AttributeError, i.__setattr__, "foo", "foovalue")

# Modifying __class__ causes a TypeError

self.assertRaises(TypeError, i.__setattr__, "__class__")

self.assertEqual(type(i), i.__getattribute__("__class__"))

# Non-existent attribute

self.assertRaises(AttributeError, i.__getattribute__, "foo")

if not i: # !!! Need to expose __reduce__ on all types

self.assertRaises(TypeError, i.__reduce__)

self.assertRaises(TypeError, i.__reduce_ex__)

for i in builtin_hashable_type_instances:

self.assertEqual(hash(i), i.__hash__())

for i in builtin_types:

# __init__ and __new__ are implemented by IronPython.Runtime.Operations.InstanceOps

# We do repr to ensure that we can map back the functions properly

repr(getattr(i, "__init__"))

repr(getattr(i, "__new__"))

def test_attrs(self):

class C:pass

C.v = 10

self.assertTrue(C.v == 10)

success = 0

try:

x = C.x

except AttributeError:

success = 1

self.assertTrue(success == 1)

def test_type_in(self):

self.assertEqual(type in (None, True, False, 1, {}, [], (), 1.0, big(1), (1+0j)), False)

def test_init_defaults(self):

class A:

def __init__(self, height=20, width=30):

self.area = height * width

a = A()

self.assertTrue(a.area == 600)

a = A(2,3)

self.assertTrue(a.area == 6)

a = A(2)

self.assertTrue(a.area == 60)

a = A(width = 2)

self.assertTrue(a.area == 40)

def test_getattr(self):

class C:

def __init__(self, name, flag):

self.f = open(name, flag)

def __getattr__(self, name):

return getattr(self.f, name)

tmpfile = "tmpfile_%d.txt" % os.getpid()

c=C(tmpfile, "w")

c.write("Hello\n")

c.close()

c=C(tmpfile, "r")

self.assertTrue(c.readline() == "Hello\n")

c.close()

try:

os.unlink(tmpfile)

except:

pass

# new-style

class C(object):

def __getattr__(self, name):

raise AttributeError(name)

# old-style

class D:

def __getattr__(self, name):

raise AttributeError(name)

# new-style __getattribute__

class E(object):

def __getattribute__(self, name):

if name == 'xyz':

raise AttributeError(name)

if name == 'x':

return 42

return object.__getattribute__(self, name)

# derived new-style type

class F(E):

pass

# verify that base class' __getattribute__ is called.

self.assertEqual(F().x, 42)

# exception shouldn't propagate out

for cls in [C, D, E, F]:

self.assertEqual(getattr(cls(), 'xyz', 'DNE'), 'DNE')

self.assertEqual(hasattr(cls(), 'xyz'), False)

# removing & adding back on __getattribute__ should work

class foo(object):

def __getattribute__(self, name): return 42

x = foo.__getattribute__

del foo.__getattribute__

self.assertRaises(AttributeError, getattr, foo(), 'x')

foo.__getattribute__ = x

self.assertEqual(foo().x, 42)

del foo.__getattribute__

self.assertRaises(AttributeError, getattr, foo(), 'x')

# check getattr when the property raises

class C(object):

def throw(self):

raise AttributeError

foo = property(throw)

self.assertEqual(getattr(C(), 'foo', 'abc'), 'abc')

def count_elem(self,d,n):

count = 0

for e in d:

if e == n:

count += 1

return count

def test_newstyle_oldstyle_dict(self):

"""Dictionary and new style classes"""

class class_n(object):

val1 = "Value"

def __init__(self):

self.val2 = self.val1

inst_n = class_n()

self.assertTrue(inst_n.val2 == "Value")

self.assertTrue(not 'val2' in dir(class_n))

self.assertTrue('val1' in dir(class_n))

self.assertTrue('val2' in dir(inst_n))

self.assertTrue('val1' in dir(inst_n))

self.assertTrue('val2' in inst_n.__dict__)

self.assertTrue(inst_n.__dict__['val2'] == "Value")

self.assertTrue(self.count_elem(dir(inst_n), "val1") == 1)

inst_n.val1 = 20

self.assertTrue(self.count_elem(dir(inst_n), "val1") == 1)

# old style classes:

class class_o:

val1 = "Value"

def __init__(self):

self.val2 = self.val1

inst_o = class_o()

self.assertTrue('val1' in dir(class_o))

self.assertTrue(not 'val2' in dir(class_o))

self.assertTrue('val1' in dir(inst_o))

self.assertTrue('val2' in dir(inst_o))

self.assertTrue('val2' in inst_o.__dict__)

self.assertTrue(inst_o.__dict__['val2'] == "Value")

self.assertTrue(self.count_elem(dir(inst_o), "val1") == 1)

inst_n.val1 = 20

self.assertTrue(self.count_elem(dir(inst_o), "val1") == 1)

self.assertTrue(isinstance(class_o, object))

self.assertTrue(isinstance(inst_o, object))

self.assertTrue(isinstance(None, object))

def test_misc(self):

class B: pass

class C(B):

def x(self):

return 'C.x'

def y(self):

return 'C.y'

class D:

def z(self):

return 'D.z'

c = C()

self.assertEqual(c.x(), "C.x")

self.assertEqual(c.y(), "C.y")

# verify repr and str on old-style class objects have the right format:

# bug# 795

self.assertEqual(str(C), "<class '{}{}.C'>".format(__name__, "" if is_cli else ".ClassTest.test_misc.<locals>"))

self.assertTrue(repr(C), str(C))

with self.assertRaises(AttributeError):

c.z()

self.assertEqual(C.__bases__, (B,))

C.__bases__ += (D,)

self.assertEqual(c.z(), "D.z")

class C:

def m(self):

return "IronPython"

def n(self, parm):

return parm

c = C()

y = c.m

y = c.n

y = C.m

y = C.n

self.assertTrue('__dict__' not in str.__dict__)

class E: pass

class F: pass

if is_cli:

F.__bases__ = (E,)

else:

with self.assertRaises(TypeError):

F.__bases__ = (E,)

def test_dir_in_init(self):

# both of these shouldn't throw

class DirInInit(object):

def __init__(self):

dir(self)

a = DirInInit()

def test_priv_class(self):

class _PrivClass(object):

def __Mangled(self):

pass

def __init__(self):

a = self.__Mangled

a = _PrivClass()

def test_inheritance_attrs_dir(self):

class foo:

def foofunc(self):

return "foofunc"

class bar(foo):

def barfunc(self):

return "barfunc"

class baz(bar, foo):

def bazfunc(self):

return "bazfunc"

self.assertIn('foofunc', dir(foo))

self.assertEqual(dir(foo).count('__doc__'), 1)

self.assertEqual(dir(foo).count('__module__'), 1)

self.assertEqual(len(dir(foo)) - len(dir(object)), 4)

self.assertIn('foofunc', dir(bar))

self.assertIn('barfunc', dir(bar))

self.assertEqual(dir(bar).count('__doc__'), 1)

self.assertEqual(dir(bar).count('__module__'), 1)

self.assertEqual(len(dir(bar)) - len(dir(object)), 5)

self.assertIn('foofunc', dir(baz))

self.assertIn('barfunc', dir(baz))

self.assertIn('bazfunc', dir(baz))

self.assertEqual(dir(baz).count('__doc__'), 1)

self.assertEqual(dir(baz).count('__module__'), 1)

self.assertEqual(len(dir(baz)) - len(dir(object)), 6)

bz = baz()

self.assertIn('foofunc', dir(bz))

self.assertIn('barfunc', dir(bz))

self.assertIn('bazfunc', dir(bz))

self.assertEqual(dir(bz).count('__doc__'), 1)

self.assertEqual(dir(bz).count('__module__'), 1)

self.assertEqual(len(dir(bz)) - len(dir(object)), 6)

bz.__module__ = "MODULE"

self.assertEqual(bz.__module__, "MODULE")

bz.__module__ = "SOMEOTHERMODULE"

self.assertEqual(bz.__module__, "SOMEOTHERMODULE")

bz.__module__ = 33

self.assertEqual(bz.__module__, 33)

bz.__module__ = [2, 3, 4]

self.assertEqual(bz.__module__, [2, 3, 4])

def test_oldstyle_setattr(self):

global called

class C:

def __setattr__(self, name, value):

global called

called = (self, name, value)

a = C()

a.abc = 'def'

self.assertEqual(called, (a, 'abc', 'def'))

del C.__setattr__

a.qrt = 'abc'

self.assertEqual(called, (a, 'abc', 'def'))

def setattr(self, name, value):

global called

called = (self, name, value)

C.__setattr__ = setattr

a.qrt = 'abc'

self.assertEqual(called, (a, 'qrt', 'abc'))

def test_oldstyle_getattr(self):

"""verify we don't access __getattr__ while creating an old

class C:

def __getattr__(self,name):

return globals()[name]

a = C()

def test_oldstyle_eq(self):

"""old style __eq__ shouldn't call __cmp__"""

class x: pass

inst = type(x())

global cmpCalled

cmpCalled = False

class C:

def __init__(self, value):

self.value = value

def __cmp__(self, other):

global cmpCalled

cmpCalled = True

return self.value - other.value

class D:

def __init__(self, value):

self.value = value

def __cmp__(self, other):

global cmpCalled

cmpCalled = True

return self.value - other.value

class C2(C): pass

class D2(D): pass

self.assertEqual(inst.__eq__(C(3.0), C(4.5)), NotImplemented)

self.assertEqual(inst.__eq__(C(3.0), C2(4.5)), NotImplemented)

self.assertEqual(inst.__eq__(C(3.0), D(4.5)), NotImplemented)

self.assertEqual(cmpCalled, False)

def test_raise_attrerror(self):

"""raising AttributeError from __getattr__ should be ok,

class A:

def __getattr__(self, name):

raise AttributeError('get outta here')

def __repr__(self):

return 'foo'

class B:

def __getattr__(self, name):

raise AttributeError('get outta here')

def __str__(self):

return 'foo'

self.assertEqual(str(A()), 'foo')

self.assertEqual(repr(A()), 'foo')

self.assertEqual(str(B()), 'foo')

self.assertIn('B object', repr(B()))

def test_exec_namespace(self):

class oldclasswithexec:

exec("def oldexecmethod(self): return 'result of oldexecmethod'")

self.assertTrue('oldexecmethod' in dir(oldclasswithexec))

self.assertEqual(oldclasswithexec().oldexecmethod(), 'result of oldexecmethod')

class newclasswithexec(object):

exec("def newexecmethod(self): return 'result of newexecmethod'")

self.assertTrue('newexecmethod' in dir(newclasswithexec))

self.assertEqual(newclasswithexec().newexecmethod(), 'result of newexecmethod')

def test_module_name(self):

global __name__

mod = sys.modules[__name__]

name = __name__

mod.__name__ = None

class C: pass

self.assertEqual(C.__module__, None)

def func1():

__name__ = "wrong"

class C: pass

return C()

def func2():

class C: pass

return C()

def func3():

global __name__

__name__ = "right"

class C: pass

return C()

self.assertEqual(func1().__module__, func2().__module__)

__name__ = "fake"

self.assertEqual(func1().__module__, "fake")

self.assertEqual(func3().__module__, "right")

mod.__name__ = name

def f(x): x.__module__

def g(x): getattr(x, '__module__')

import errno

for thing in "", 1, errno, big(1), 1+2j, (), [], {}:

self.assertEqual(getattr(thing, '__module__', 'does_not_exist'), 'does_not_exist')

self.assertEqual(hasattr(thing, '__module__'), False)

self.assertRaises(AttributeError, f, thing)

self.assertRaises(AttributeError, g, thing)

self.assertRaisesMessage(TypeError, "can't set function.__module__", type(type(f)).__dict__['__module__'].__set__, type(f), 42)

class x(object): pass

type(type(x())).__dict__['__module__'].__set__(x, 'fooz')

self.assertEqual(x.__module__, 'fooz')

self.assertRaisesMessage(TypeError, "can't delete x.__module__", type(type(x())).__dict__['__module__'].__delete__, x)

def test_check_dictionary(self):

"""tests to verify that Symbol dictionaries do the right thing in dynamic scenarios"""

class C(object):

def __init__(self): pass

# add a new attribute to the type...

C.newClassAttr = 'xyz'

self.assertEqual(C.newClassAttr, 'xyz')

# add non-string index into the class and instance dictionary

a = C()

a.__dict__[1] = '1'

if object in C.__bases__:

with self.assertRaises(TypeError):

C.__dict__[2] = '2'

self.assertEqual(2 in C.__dict__, False)

self.assertEqual(1 in a.__dict__, True)

with self.assertRaises(TypeError): # TypeError: unorderable types: str() < int()

dir(a)

self.assertEqual(repr(a.__dict__), "{1: '1'}")

# replace a class dictionary (containing non-string keys) w/ a normal dictionary

C.newTypeAttr = 1

self.assertEqual(hasattr(C, 'newTypeAttr'), True)

with self.assertRaises(AttributeError):

C.__dict__ = {}

# replace an instance dictionary (containing non-string keys) w/ a new one.

a.newInstanceAttr = 1

self.assertEqual(hasattr(a, 'newInstanceAttr'), True)

a.__dict__ = dict(a.__dict__)

self.assertEqual(hasattr(a, 'newInstanceAttr'), True)

a.abc = 'xyz'

self.assertEqual(hasattr(a, 'abc'), True)

self.assertEqual(getattr(a, 'abc'), 'xyz')

def test_call_type_call(self):

for stuff in [object, int, str, bool, float]:

self.assertEqual(type(type.__call__(stuff)), stuff)

self.assertEqual(type.__call__(int, 5), 5)

self.assertEqual(type.__call__(int), 0)

self.assertEqual(type.__call__(bool, True), True)

self.assertEqual(type.__call__(bool), False)

#User-defined old/new style classes

call_mapper = {}

class KNew0(object):

def __call__(self):

return 2

call_mapper[KNew0] = lambda: [type(KNew0()).__call__(KNew0())]

class KNew1(object):

def __call__(self, p):

return 2

call_mapper[KNew1] = lambda: [type(KNew1()).__call__(KNew1(), 3.14),

type(KNew1()).__call__(KNew1(), p=3.14),

type(KNew1()).__call__(KNew1(), **{"p":3.14}),

type(KNew1()).__call__(KNew1(), (1, 2, 3)),

]

class KNewArgs(object):

def __call__(self, *args):

return 2

call_mapper[KNewArgs] = lambda: [type(KNewArgs()).__call__(KNewArgs()) ]

class KNewKwargs(object):

def __call__(self, **kwargs):

return 2

call_mapper[KNewKwargs] = lambda: [type(KNewKwargs()).__call__(KNewKwargs())]

class KNewArgsKwargs(object):

def __call__(self, *args, **kwargs):

return 2

call_mapper[KNewArgsKwargs] = lambda: [type(KNewArgsKwargs()).__call__(KNewArgsKwargs())]

for K in list(call_mapper.keys()):

for ret_val in call_mapper[K]():

self.assertEqual(ret_val, 2)

def test_cp8246(self):

#...

class K(object):

def __call__(self):

return ((), {})

self.assertEqual(K()(), ((), {}))

#...

class K(object):

def __call__(self, **kwargs):

return ((), kwargs)

self.assertEqual(K()(), ((), {}))

self.assertEqual(K()(**{}), ((), {}))

self.assertEqual(K()(**{'a':None}), ((), {'a':None}))

#...

class K(object):

def __call__(self, *args):

return (args, {})

self.assertEqual(K()(), ((), {}))

self.assertEqual(K()(*()), ((), {}))

self.assertEqual(K()(*(None,)), ((None,), {}))

#...

class K(object):

def __call__(self, *args, **kwargs):

return (args, kwargs)

self.assertEqual(K()(), ((), {}))

self.assertEqual(K()(*()), ((), {}))

self.assertEqual(K()(**{}), ((), {}))

self.assertEqual(K()(*(), **{}), ((), {}))

self.assertEqual(K()(*(None,)), ((None,), {}))

self.assertEqual(K()(**{'a':None}), ((), {'a':None}))

self.assertEqual(K()(*(None,), **{'a':None}), ((None,), {'a':None}))

def test_mixed_inheritance(self):

"""inheritance from both old & new style classes..."""

class foo: pass

class bar(object): pass

class baz1(foo, bar): pass

class baz2(bar, foo): pass

self.assertEqual(baz1.__bases__, (foo, bar))

self.assertEqual(baz2.__bases__, (bar, foo))

class foo:

abc = 3

class bar(object):

def get_abc():

return 42

def set_abc():

pass

abc = property(fget=get_abc, fset=set_abc)

class baz(foo, bar): pass

self.assertEqual(baz().abc, 3)

def test_newstyle_unbound_inheritance(self):

"""verify calling unbound method w/ new-style class on subclass which

class foo:

def func(self): return self

class bar(foo):

def barfunc(self):

return foo.func(self)

a = bar()

self.assertEqual(a.barfunc(), a)

def test_mro(self):

"""mro (method resolution order) support"""

class A(object): pass

self.assertEqual(A.__mro__, (A, object))

class B(object): pass

self.assertEqual(B.__mro__, (B, object))

class C(B): pass

self.assertEqual(C.__mro__, (C, B, object))

class N(C,B,A): pass

self.assertEqual(N.__mro__, (N, C, B, A, object))

with self.assertRaises(TypeError, msg="impossible MRO created"):

class N(A, B,C): pass

with self.assertRaises(TypeError, msg="can't derive from the same base type twice"):

class N(A, A): pass

def test_mro_bases(self):

"""verify replacing base classes also updates MRO"""

class C(object):

def __getattribute__(self, name):

if(name == 'xyz'): return 'C'

return super(C, self).__getattribute__(name)

class C1(C):

def __getattribute__(self, name):

if(name == 'xyz'): return 'C1'

return super(C1, self).__getattribute__(name)

class A(object): pass

class B(object):

def __getattribute__(self, name):

if(name == 'xyz'): return 'B'

return super(B, self).__getattribute__(name)

a = C1()

self.assertEqual(a.xyz, 'C1')

C1.__bases__ = (A,B)

self.assertEqual(a.xyz, 'C1')

del(C1.__getattribute__)

self.assertEqual(a.xyz, 'B')

def test_dynamic_mro_bases(self):

class C(object):

pass

def __getattribute__(self, name):

if (name == 'xyz'):

return 'C'

return super(C, self).__getattribute__(name)

C.__getattribute__ = __getattribute__

class C1(C):

pass

def __getattribute__(self, name):

if (name == 'xyz'):

return 'C1'

return super(C1, self).__getattribute__(name)

C1.__getattribute__ = __getattribute__

class B(object):

pass

def __getattribute__(self, name):

if (name == 'xyz'):

return 'B'

return super(B, self).__getattribute__(name)

B.__getattribute__ = __getattribute__

C1.__bases__ = (B, )

self.assertEqual(C1().xyz, 'C1')

def test_builtin_mro(self):

"""int mro shouldn't include ValueType"""

self.assertEqual(int.__mro__, (int, object))

def test_mixed_inheritance_mro(self):

"""mixed inheritance from old-style & new-style classes"""

# we should use old-style MRO when inheriting w/ a single old-style class

class A: pass

class B(A): pass

class C(A): pass

class D(B, C):pass

class E(D): pass

# old-style MRO of D is D, B, A, C, which should

# be present in E's mro

self.assertEqual(E.__mro__, (E, D, B, C, A, object))

class F(B, C): pass

# but when inheriting from multiple old-style classes we switch

# to new-style MRO, and respect local ordering of classes in the MRO

self.assertEqual(F.__mro__, (F, B, C, A, object))

class G(B, C): pass

self.assertEqual(G.__mro__, (G, B, C, A, object))

class H(E): pass

self.assertEqual(H.__mro__, (H, E, D, B, C, A, object))

with self.assertRaises(TypeError):

class H(A,B,E): pass

class H(E,B,A): pass

self.assertEqual(H.__mro__, (H, E, D, B, C, A, object))

def test_depth_first_mro_mixed(self):

"""Verify given two large, independent class hierarchies

class A: pass

class B(A): pass

class C(A): pass

class D(B,C): pass

class E(D, object): pass

class G: pass

class H(G): pass

class I(G): pass

class K(H,I, object): pass

class L(K,E): pass

self.assertEqual(L.__mro__, (L, K, H, I, G, E, D, B, C, A, object))

def test_depth_first_mro(self):

"""w/o old-style"""

class A(object): pass

class B(A): pass

class C(A): pass

class D(B,C): pass

class E(D, object): pass

class G(object): pass

class H(G): pass

class I(G): pass

class K(H,I, object): pass

class L(K,E): pass

self.assertEqual(L.__mro__, (L, K, H, I, G, E, D, B, C, A, object))

def test_class_args(self):

class A1: pass

class A2: pass

class A3: pass

class B1(A1, *(A2, A3)): pass

self.assertEqual(B1.__mro__, (B1, A1, A2, A3, object))

clist = [A1, A2]

with self.assertRaisesMessage(TypeError, "duplicate base class A1"):

class B2(A1, *clist): pass

def foo(x): return x

class B3(foo(A1), clist[1], A3): pass

self.assertEqual(B3.__mro__, (B3, A1, A2, A3, object))

class B4(A1, *foo([A2, A3])): pass

self.assertEqual(B4.__mro__, (B4, A1, A2, A3, object))

with self.assertRaisesMessage(UnboundLocalError, "local variable 'A4' referenced before assignment"):

class B5(A1, *(A4,)): pass

class A4: pass

def test_newstyle_lookup(self):

"""new-style classes should only lookup methods from the class, not from the instance"""

class Strange(object):

def uselessMethod(self): pass

global obj

obj = Strange()

obj.__nonzero__ = lambda: False

self.assertEqual(bool(obj), True)

def twoargs(self, other):

global twoArgsCalled

twoArgsCalled = True

return self

def onearg(self):

return self

def onearg_str(self):

return 'abc'

class ForwardAndReverseTests:

testCases = [

#forward versions

('__add__', 'obj + obj'),

('__sub__', 'obj - obj'),

('__mul__', 'obj * obj'),

('__floordiv__', 'obj // obj'),

('__mod__', 'obj % obj'),

('__divmod__', 'divmod(obj,obj)'),

('__pow__', 'pow(obj, obj)'),

('__lshift__', 'obj << obj'),

('__rshift__', 'obj >> obj'),

('__and__', 'obj & obj'),

('__xor__', 'obj ^ obj'),

('__or__', 'obj | obj'),

# reverse versions

('__radd__', '1 + obj'),

('__rsub__', '1 - obj'),

('__rmul__', '1 * obj'),

('__rfloordiv__', '1 // obj'),

('__rmod__', '1 % obj'),

#('__rdivmod__', '1 % obj'), #bug 975

('__rpow__', 'pow(1, obj)'),

('__rlshift__', '1 << obj'),

('__rrshift__', '1 >> obj'),

('__rand__', '1 & obj'),

('__rxor__', '1 ^ obj'),

('__ror__', '1 | obj'),

]

@staticmethod

def NegativeTest(method, testCase):

setattr(obj, method, twoargs)

with self.assertRaises(TypeError):

eval(testCase)

delattr(obj, method)

@staticmethod

def PositiveTest(method, testCase):

setattr(Strange, method, twoargs)

self.assertEqual(eval(testCase), obj)

delattr(Strange, method)

class InPlaceTests:

# in-place versions require exec instead of eval

testCases = [

# inplace versions

('__iadd__', 'obj += obj'),

('__isub__', 'obj -= obj'),

('__imul__', 'obj *= obj'),

('__ifloordiv__', 'obj //= obj'),

('__imod__', 'obj %= obj'),

('__ipow__', 'obj **= obj'),

('__ilshift__', 'obj <<= obj'),

('__irshift__', 'obj >>= obj'),

('__iand__', 'obj &= obj'),

('__ixor__', 'obj ^= obj'),

('__ior__', 'obj |= obj'),

]

@staticmethod

def NegativeTest(method, testCase):

setattr(obj, method, twoargs)

with self.assertRaises(TypeError):

exec(testCase, globals(), locals())

delattr(obj, method)

@staticmethod

def PositiveTest(method, testCase):

setattr(Strange, method, twoargs)

global twoArgsCalled

twoArgsCalled = False

exec(testCase, globals(), locals())

self.assertEqual(twoArgsCalled, True)

delattr(Strange, method)

class SingleArgTests:

testCases = [

# one-argument versions

('__neg__', '-obj'),

('__pos__', '+obj'),

('__abs__', 'abs(obj)'),

('__invert__', '~obj'),

]

@staticmethod

def NegativeTest(method, testCase):

setattr(obj, method, onearg)

with self.assertRaises(TypeError):

eval(testCase)

delattr(obj, method)

@staticmethod

def PositiveTest(method, testCase):

setattr(Strange, method, onearg)

try:

self.assertEqual(eval(testCase), obj)

except TypeError:

self.assertTrue(method == '__oct__' or method == '__hex__')