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

unittest.TestCase.__init__(self, *args, **kwargs)

self.binops = {

'add': '+',

'sub': '-',

'mul': '*',

'matmul': '@',

'truediv': '/',

'floordiv': '//',

'divmod': 'divmod',

'pow': '**',

'lshift': '<<',

'rshift': '>>',

'and': '&',

'xor': '^',

'or': '|',

'cmp': 'cmp',

'lt': '<',

'le': '<=',

'eq': '==',

'ne': '!=',

'gt': '>',

'ge': '>=',

}

for name, expr in list(self.binops.items()):

if expr.islower():

expr = expr + "(a, b)"

else:

expr = 'a %s b' % expr

self.binops[name] = expr

self.unops = {

'pos': '+',

'neg': '-',

'abs': 'abs',

'invert': '~',

'int': 'int',

'float': 'float',

}

for name, expr in list(self.unops.items()):

if expr.islower():

expr = expr + "(a)"

else:

expr = '%s a' % expr

self.unops[name] = expr

def unop_test(self, a, res, expr="len(a)", meth="__len__"):

d = {'a': a}

self.assertEqual(eval(expr, d), res)

t = type(a)

m = getattr(t, meth)

# Find method in parent class

while meth not in t.__dict__:

t = t.__bases__[0]

# in some implementations (e.g. PyPy), 'm' can be a regular unbound

# method object; the getattr() below obtains its underlying function.

self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])

self.assertEqual(m(a), res)

bm = getattr(a, meth)

self.assertEqual(bm(), res)

def binop_test(self, a, b, res, expr="a+b", meth="__add__"):

d = {'a': a, 'b': b}

self.assertEqual(eval(expr, d), res)

t = type(a)

m = getattr(t, meth)

while meth not in t.__dict__:

t = t.__bases__[0]

# in some implementations (e.g. PyPy), 'm' can be a regular unbound

# method object; the getattr() below obtains its underlying function.

self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])

self.assertEqual(m(a, b), res)

bm = getattr(a, meth)

self.assertEqual(bm(b), res)

def sliceop_test(self, a, b, c, res, expr="a[b:c]", meth="__getitem__"):

d = {'a': a, 'b': b, 'c': c}

self.assertEqual(eval(expr, d), res)

t = type(a)

m = getattr(t, meth)

while meth not in t.__dict__:

t = t.__bases__[0]

# in some implementations (e.g. PyPy), 'm' can be a regular unbound

# method object; the getattr() below obtains its underlying function.

self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])

self.assertEqual(m(a, slice(b, c)), res)

bm = getattr(a, meth)

self.assertEqual(bm(slice(b, c)), res)

def setop_test(self, a, b, res, stmt="a+=b", meth="__iadd__"):

d = {'a': deepcopy(a), 'b': b}

exec(stmt, d)

self.assertEqual(d['a'], res)

t = type(a)

m = getattr(t, meth)

while meth not in t.__dict__:

t = t.__bases__[0]

# in some implementations (e.g. PyPy), 'm' can be a regular unbound

# method object; the getattr() below obtains its underlying function.

self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])

d['a'] = deepcopy(a)

m(d['a'], b)

self.assertEqual(d['a'], res)

d['a'] = deepcopy(a)

bm = getattr(d['a'], meth)

bm(b)

self.assertEqual(d['a'], res)

def set2op_test(self, a, b, c, res, stmt="a[b]=c", meth="__setitem__"):

d = {'a': deepcopy(a), 'b': b, 'c': c}

exec(stmt, d)

self.assertEqual(d['a'], res)

t = type(a)

m = getattr(t, meth)

while meth not in t.__dict__:

t = t.__bases__[0]

# in some implementations (e.g. PyPy), 'm' can be a regular unbound

# method object; the getattr() below obtains its underlying function.

self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])

d['a'] = deepcopy(a)

m(d['a'], b, c)

self.assertEqual(d['a'], res)

d['a'] = deepcopy(a)

bm = getattr(d['a'], meth)

bm(b, c)

self.assertEqual(d['a'], res)

def setsliceop_test(self, a, b, c, d, res, stmt="a[b:c]=d", meth="__setitem__"):

dictionary = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d}

exec(stmt, dictionary)

self.assertEqual(dictionary['a'], res)

t = type(a)

while meth not in t.__dict__:

t = t.__bases__[0]

m = getattr(t, meth)

# in some implementations (e.g. PyPy), 'm' can be a regular unbound

# method object; the getattr() below obtains its underlying function.

self.assertEqual(getattr(m, 'im_func', m), t.__dict__[meth])

dictionary['a'] = deepcopy(a)

m(dictionary['a'], slice(b, c), d)

self.assertEqual(dictionary['a'], res)

dictionary['a'] = deepcopy(a)

bm = getattr(dictionary['a'], meth)

bm(slice(b, c), d)

self.assertEqual(dictionary['a'], res)

def test_lists(self):

# Testing list operations...

# Asserts are within individual test methods

self.binop_test([1], [2], [1,2], "a+b", "__add__")

self.binop_test([1,2,3], 2, 1, "b in a", "__contains__")

self.binop_test([1,2,3], 4, 0, "b in a", "__contains__")

self.binop_test([1,2,3], 1, 2, "a[b]", "__getitem__")

self.sliceop_test([1,2,3], 0, 2, [1,2], "a[b:c]", "__getitem__")

self.setop_test([1], [2], [1,2], "a+=b", "__iadd__")

self.setop_test([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__")

self.unop_test([1,2,3], 3, "len(a)", "__len__")

self.binop_test([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__")

self.binop_test([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__")

self.set2op_test([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__")

self.setsliceop_test([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d",

"__setitem__")

def test_dicts(self):

# Testing dict operations...

self.binop_test({1:2,3:4}, 1, 1, "b in a", "__contains__")

self.binop_test({1:2,3:4}, 2, 0, "b in a", "__contains__")

self.binop_test({1:2,3:4}, 1, 2, "a[b]", "__getitem__")

d = {1:2, 3:4}

l1 = []

for i in list(d.keys()):

l1.append(i)

l = []

for i in iter(d):

l.append(i)

self.assertEqual(l, l1)

l = []

for i in d.__iter__():

l.append(i)

self.assertEqual(l, l1)

l = []

for i in dict.__iter__(d):

l.append(i)

self.assertEqual(l, l1)

d = {1:2, 3:4}

self.unop_test(d, 2, "len(a)", "__len__")

self.assertEqual(eval(repr(d), {}), d)

self.assertEqual(eval(d.__repr__(), {}), d)

self.set2op_test({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c",

"__setitem__")

# Tests for unary and binary operators

def number_operators(self, a, b, skip=[]):

dict = {'a': a, 'b': b}

for name, expr in self.binops.items():

if name not in skip:

name = "__%s__" % name

if hasattr(a, name):

res = eval(expr, dict)

self.binop_test(a, b, res, expr, name)

for name, expr in list(self.unops.items()):

if name not in skip:

name = "__%s__" % name

if hasattr(a, name):

res = eval(expr, dict)

self.unop_test(a, res, expr, name)

def test_ints(self):

# Testing int operations...

self.number_operators(100, 3)

# The following crashes in Python 2.2

self.assertEqual((1).__bool__(), 1)

self.assertEqual((0).__bool__(), 0)

# This returns 'NotImplemented' in Python 2.2

class C(int):

def __add__(self, other):

return NotImplemented

self.assertEqual(C(5), 5)

try:

C() + ""

except TypeError:

pass

else:

self.fail("NotImplemented should have caused TypeError")

def test_floats(self):

# Testing float operations...

self.number_operators(100.0, 3.0)

def test_complexes(self):

# Testing complex operations...

self.number_operators(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge',

'int', 'float',

'floordiv', 'divmod', 'mod'])

class Number(complex):

__slots__ = ['prec']

def __new__(cls, *args, **kwds):

result = complex.__new__(cls, *args)

result.prec = kwds.get('prec', 12)

return result

def __repr__(self):

prec = self.prec

if self.imag == 0.0:

return "%.*g" % (prec, self.real)

if self.real == 0.0:

return "%.*gj" % (prec, self.imag)

return "(%.*g+%.*gj)" % (prec, self.real, prec, self.imag)

__str__ = __repr__

a = Number(3.14, prec=6)

self.assertEqual(repr(a), "3.14")

self.assertEqual(a.prec, 6)

a = Number(a, prec=2)

self.assertEqual(repr(a), "3.1")

self.assertEqual(a.prec, 2)

a = Number(234.5)

self.assertEqual(repr(a), "234.5")

self.assertEqual(a.prec, 12)

def test_explicit_reverse_methods(self):

# see issue 9930

self.assertEqual(complex.__radd__(3j, 4.0), complex(4.0, 3.0))

self.assertEqual(float.__rsub__(3.0, 1), -2.0)

@support.impl_detail("the module 'xxsubtype' is internal")

@unittest.skipIf(xxsubtype is None, "requires xxsubtype module")

def test_spam_lists(self):

# Testing spamlist operations...

import copy, xxsubtype as spam

def spamlist(l, memo=None):

import xxsubtype as spam

return spam.spamlist(l)

# This is an ugly hack:

copy._deepcopy_dispatch[spam.spamlist] = spamlist

self.binop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b",

"__add__")

self.binop_test(spamlist([1,2,3]), 2, 1, "b in a", "__contains__")

self.binop_test(spamlist([1,2,3]), 4, 0, "b in a", "__contains__")

self.binop_test(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__")

self.sliceop_test(spamlist([1,2,3]), 0, 2, spamlist([1,2]), "a[b:c]",

"__getitem__")

self.setop_test(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+=b",

"__iadd__")

self.setop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b",

"__imul__")

self.unop_test(spamlist([1,2,3]), 3, "len(a)", "__len__")

self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b",

"__mul__")

self.binop_test(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a",

"__rmul__")

self.set2op_test(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c",

"__setitem__")

self.setsliceop_test(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),

spamlist([1,5,6,4]), "a[b:c]=d", "__setitem__")

# Test subclassing

class C(spam.spamlist):

def foo(self): return 1

a = C()

self.assertEqual(a, [])

self.assertEqual(a.foo(), 1)

a.append(100)

self.assertEqual(a, [100])

self.assertEqual(a.getstate(), 0)

a.setstate(42)

self.assertEqual(a.getstate(), 42)

@support.impl_detail("the module 'xxsubtype' is internal")

@unittest.skipIf(xxsubtype is None, "requires xxsubtype module")

def test_spam_dicts(self):

# Testing spamdict operations...

import copy, xxsubtype as spam

def spamdict(d, memo=None):

import xxsubtype as spam

sd = spam.spamdict()

for k, v in list(d.items()):

sd[k] = v

return sd

# This is an ugly hack:

copy._deepcopy_dispatch[spam.spamdict] = spamdict

self.binop_test(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__")

self.binop_test(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__")

self.binop_test(spamdict({1:2,3:4}), 1, 2, "a[b]", "__getitem__")

d = spamdict({1:2,3:4})

l1 = []

for i in list(d.keys()):

l1.append(i)

l = []

for i in iter(d):

l.append(i)

self.assertEqual(l, l1)

l = []

for i in d.__iter__():

l.append(i)

self.assertEqual(l, l1)

l = []

for i in type(spamdict({})).__iter__(d):

l.append(i)

self.assertEqual(l, l1)

straightd = {1:2, 3:4}

spamd = spamdict(straightd)

self.unop_test(spamd, 2, "len(a)", "__len__")

self.unop_test(spamd, repr(straightd), "repr(a)", "__repr__")

self.set2op_test(spamdict({1:2,3:4}), 2, 3, spamdict({1:2,2:3,3:4}),

"a[b]=c", "__setitem__")

# Test subclassing

class C(spam.spamdict):

def foo(self): return 1

a = C()

self.assertEqual(list(a.items()), [])

self.assertEqual(a.foo(), 1)

a['foo'] = 'bar'

self.assertEqual(list(a.items()), [('foo', 'bar')])

self.assertEqual(a.getstate(), 0)

a.setstate(100)

self.assertEqual(a.getstate(), 100)

def test_wrap_lenfunc_bad_cast(self):

def assertHasAttr(self, obj, name):

self.assertTrue(hasattr(obj, name),

'%r has no attribute %r' % (obj, name))

def assertNotHasAttr(self, obj, name):

self.assertFalse(hasattr(obj, name),

'%r has unexpected attribute %r' % (obj, name))

def test_python_dicts(self):

# Testing Python subclass of dict...

self.assertTrue(issubclass(dict, dict))

self.assertIsInstance({}, dict)

d = dict()

self.assertEqual(d, {})

self.assertIs(d.__class__, dict)

self.assertIsInstance(d, dict)

class C(dict):

state = -1

def __init__(self_local, *a, **kw):

if a:

self.assertEqual(len(a), 1)

self_local.state = a[0]

if kw:

for k, v in list(kw.items()):

self_local[v] = k

def __getitem__(self, key):

return self.get(key, 0)

def __setitem__(self_local, key, value):

self.assertIsInstance(key, int)

dict.__setitem__(self_local, key, value)

def setstate(self, state):

self.state = state

def getstate(self):

return self.state

self.assertTrue(issubclass(C, dict))

a1 = C(12)

self.assertEqual(a1.state, 12)

a2 = C(foo=1, bar=2)

self.assertEqual(a2[1] == 'foo' and a2[2], 'bar')

a = C()

self.assertEqual(a.state, -1)

self.assertEqual(a.getstate(), -1)

a.setstate(0)

self.assertEqual(a.state, 0)

self.assertEqual(a.getstate(), 0)

a.setstate(10)

self.assertEqual(a.state, 10)

self.assertEqual(a.getstate(), 10)

self.assertEqual(a[42], 0)

a[42] = 24

self.assertEqual(a[42], 24)

N = 50

for i in range(N):

a[i] = C()

for j in range(N):

a[i][j] = i*j

for i in range(N):

for j in range(N):

self.assertEqual(a[i][j], i*j)

def test_python_lists(self):

# Testing Python subclass of list...

class C(list):

def __getitem__(self, i):

if isinstance(i, slice):

return i.start, i.stop

return list.__getitem__(self, i) + 100

a = C()

a.extend([0,1,2])

self.assertEqual(a[0], 100)

self.assertEqual(a[1], 101)

self.assertEqual(a[2], 102)

self.assertEqual(a[100:200], (100,200))

# TODO: RUSTPYTHON

@unittest.expectedFailure

def test_metaclass(self):

# Testing metaclasses...

class C(metaclass=type):

def __init__(self):

self.__state = 0

def getstate(self):

return self.__state

def setstate(self, state):

self.__state = state

a = C()

self.assertEqual(a.getstate(), 0)

a.setstate(10)

self.assertEqual(a.getstate(), 10)

class _metaclass(type):

def myself(cls): return cls

class D(metaclass=_metaclass):

pass

self.assertEqual(D.myself(), D)

d = D()

self.assertEqual(d.__class__, D)

class M1(type):

def __new__(cls, name, bases, dict):

dict['__spam__'] = 1

return type.__new__(cls, name, bases, dict)

class C(metaclass=M1):

pass

self.assertEqual(C.__spam__, 1)

c = C()

self.assertEqual(c.__spam__, 1)

class _instance(object):

pass

class M2(object):

@staticmethod

def __new__(cls, name, bases, dict):

self = object.__new__(cls)

self.name = name

self.bases = bases

self.dict = dict

return self

def __call__(self):

it = _instance()

# Early binding of methods

for key in self.dict:

if key.startswith("__"):

continue

setattr(it, key, self.dict[key].__get__(it, self))

return it

class C(metaclass=M2):

def spam(self):

return 42

self.assertEqual(C.name, 'C')

self.assertEqual(C.bases, ())

self.assertIn('spam', C.dict)

c = C()

self.assertEqual(c.spam(), 42)

# More metaclass examples

class autosuper(type):

# Automatically add __super to the class

# This trick only works for dynamic classes

def __new__(metaclass, name, bases, dict):

cls = super(autosuper, metaclass).__new__(metaclass,

name, bases, dict)

# Name mangling for __super removes leading underscores

while name[:1] == "_":

name = name[1:]

if name:

name = "_%s__super" % name

else:

name = "__super"

setattr(cls, name, super(cls))

return cls

class A(metaclass=autosuper):

def meth(self):

return "A"

class B(A):

def meth(self):

return "B" + self.__super.meth()

class C(A):

def meth(self):

return "C" + self.__super.meth()

class D(C, B):

def meth(self):

return "D" + self.__super.meth()

self.assertEqual(D().meth(), "DCBA")

class E(B, C):

def meth(self):

return "E" + self.__super.meth()

self.assertEqual(E().meth(), "EBCA")

class autoproperty(type):

# Automatically create property attributes when methods

# named _get_x and/or _set_x are found

def __new__(metaclass, name, bases, dict):

hits = {}

for key, val in dict.items():

if key.startswith("_get_"):

key = key[5:]

get, set = hits.get(key, (None, None))

get = val

hits[key] = get, set

elif key.startswith("_set_"):

key = key[5:]

get, set = hits.get(key, (None, None))

set = val

hits[key] = get, set

for key, (get, set) in hits.items():

dict[key] = property(get, set)

return super(autoproperty, metaclass).__new__(metaclass,

name, bases, dict)

class A(metaclass=autoproperty):

def _get_x(self):

return -self.__x

def _set_x(self, x):

self.__x = -x

a = A()

self.assertNotHasAttr(a, "x")

a.x = 12

self.assertEqual(a.x, 12)

self.assertEqual(a._A__x, -12)

class multimetaclass(autoproperty, autosuper):

# Merge of multiple cooperating metaclasses

pass

class A(metaclass=multimetaclass):

def _get_x(self):

return "A"

class B(A):

def _get_x(self):

return "B" + self.__super._get_x()

class C(A):

def _get_x(self):

return "C" + self.__super._get_x()

class D(C, B):

def _get_x(self):

return "D" + self.__super._get_x()

self.assertEqual(D().x, "DCBA")

# Make sure type(x) doesn't call x.__class__.__init__

class T(type):

counter = 0

def __init__(self, *args):

T.counter += 1

class C(metaclass=T):

pass

self.assertEqual(T.counter, 1)

a = C()

self.assertEqual(type(a), C)

self.assertEqual(T.counter, 1)

class C(object): pass

c = C()

try: c()

except TypeError: pass

else: self.fail("calling object w/o call method should raise "

"TypeError")

# Testing code to find most derived baseclass

class A(type):

def __new__(*args, **kwargs):

return type.__new__(*args, **kwargs)

class B(object):

pass

class C(object, metaclass=A):

pass

# The most derived metaclass of D is A rather than type.

class D(B, C):

pass

self.assertIs(A, type(D))

# issue1294232: correct metaclass calculation

new_calls = [] # to check the order of __new__ calls

class AMeta(type):

@staticmethod

def __new__(mcls, name, bases, ns):

new_calls.append('AMeta')

return super().__new__(mcls, name, bases, ns)

@classmethod

def __prepare__(mcls, name, bases):

return {}

class BMeta(AMeta):

@staticmethod

def __new__(mcls, name, bases, ns):

new_calls.append('BMeta')

return super().__new__(mcls, name, bases, ns)

@classmethod

def __prepare__(mcls, name, bases):

ns = super().__prepare__(name, bases)

ns['BMeta_was_here'] = True

return ns

class A(metaclass=AMeta):

pass

self.assertEqual(['AMeta'], new_calls)

new_calls.clear()

class B(metaclass=BMeta):

pass

# BMeta.__new__ calls AMeta.__new__ with super:

self.assertEqual(['BMeta', 'AMeta'], new_calls)

new_calls.clear()

class C(A, B):

pass

# The most derived metaclass is BMeta:

self.assertEqual(['BMeta', 'AMeta'], new_calls)

new_calls.clear()

# BMeta.__prepare__ should've been called:

self.assertIn('BMeta_was_here', C.__dict__)

# The order of the bases shouldn't matter:

class C2(B, A):

pass

self.assertEqual(['BMeta', 'AMeta'], new_calls)

new_calls.clear()

self.assertIn('BMeta_was_here', C2.__dict__)

# Check correct metaclass calculation when a metaclass is declared:

class D(C, metaclass=type):

pass

self.assertEqual(['BMeta', 'AMeta'], new_calls)

new_calls.clear()

self.assertIn('BMeta_was_here', D.__dict__)

class E(C, metaclass=AMeta):

pass

self.assertEqual(['BMeta', 'AMeta'], new_calls)

new_calls.clear()

self.assertIn('BMeta_was_here', E.__dict__)

# Special case: the given metaclass isn't a class,

# so there is no metaclass calculation.

marker = object()

def func(*args, **kwargs):

return marker

class X(metaclass=func):

pass

class Y(object, metaclass=func):

pass

class Z(D, metaclass=func):

pass

self.assertIs(marker, X)

self.assertIs(marker, Y)

self.assertIs(marker, Z)

# The given metaclass is a class,

# but not a descendant of type.

prepare_calls = [] # to track __prepare__ calls

class ANotMeta:

def __new__(mcls, *args, **kwargs):

new_calls.append('ANotMeta')

return super().__new__(mcls)

@classmethod

def __prepare__(mcls, name, bases):

prepare_calls.append('ANotMeta')

return {}

class BNotMeta(ANotMeta):

def __new__(mcls, *args, **kwargs):

new_calls.append('BNotMeta')

return super().__new__(mcls)

@classmethod

def __prepare__(mcls, name, bases):

prepare_calls.append('BNotMeta')

return super().__prepare__(name, bases)

class A(metaclass=ANotMeta):

pass

self.assertIs(ANotMeta, type(A))

self.assertEqual(['ANotMeta'], prepare_calls)

prepare_calls.clear()

self.assertEqual(['ANotMeta'], new_calls)

new_calls.clear()

class B(metaclass=BNotMeta):

pass

self.assertIs(BNotMeta, type(B))

self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)

prepare_calls.clear()

self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)

new_calls.clear()

class C(A, B):

pass

self.assertIs(BNotMeta, type(C))

self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)

new_calls.clear()

self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)

prepare_calls.clear()

class C2(B, A):

pass

self.assertIs(BNotMeta, type(C2))

self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)

new_calls.clear()

self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)

prepare_calls.clear()

# This is a TypeError, because of a metaclass conflict:

# BNotMeta is neither a subclass, nor a superclass of type

with self.assertRaises(TypeError):

class D(C, metaclass=type):

pass

class E(C, metaclass=ANotMeta):

pass

self.assertIs(BNotMeta, type(E))

self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)

new_calls.clear()

self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)

prepare_calls.clear()

class F(object(), C):

pass

self.assertIs(BNotMeta, type(F))

self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)

new_calls.clear()

self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)

prepare_calls.clear()

class F2(C, object()):

pass

self.assertIs(BNotMeta, type(F2))

self.assertEqual(['BNotMeta', 'ANotMeta'], new_calls)

new_calls.clear()

self.assertEqual(['BNotMeta', 'ANotMeta'], prepare_calls)

prepare_calls.clear()

# TypeError: BNotMeta is neither a

# subclass, nor a superclass of int

with self.assertRaises(TypeError):

class X(C, int()):

pass

with self.assertRaises(TypeError):

class X(int(), C):

pass

def test_module_subclasses(self):

# Testing Python subclass of module...

log = []

MT = type(sys)

class MM(MT):

def __init__(self, name):

MT.__init__(self, name)

def __getattribute__(self, name):

log.append(("getattr", name))

return MT.__getattribute__(self, name)

def __setattr__(self, name, value):

log.append(("setattr", name, value))

MT.__setattr__(self, name, value)

def __delattr__(self, name):

log.append(("delattr", name))

MT.__delattr__(self, name)

a = MM("a")

a.foo = 12

x = a.foo

del a.foo

self.assertEqual(log, [("setattr", "foo", 12),

("getattr", "foo"),

("delattr", "foo")])

# https://bugs.python.org/issue1174712

try:

class Module(types.ModuleType, str):

pass

except TypeError:

pass

else:

self.fail("inheriting from ModuleType and str at the same time "

"should fail")

# Issue 34805: Verify that definition order is retained

def random_name():

return ''.join(random.choices(string.ascii_letters, k=10))

class A:

pass

subclasses = [type(random_name(), (A,), {}) for i in range(100)]

self.assertEqual(A.__subclasses__(), subclasses)

def test_multiple_inheritance(self):

# Testing multiple inheritance...

class C(object):

def __init__(self):

self.__state = 0

def getstate(self):

return self.__state

def setstate(self, state):

self.__state = state

a = C()

self.assertEqual(a.getstate(), 0)

a.setstate(10)

self.assertEqual(a.getstate(), 10)

class D(dict, C):

def __init__(self):

dict.__init__(self)

C.__init__(self)

d = D()

self.assertEqual(list(d.keys()), [])

d["hello"] = "world"

self.assertEqual(list(d.items()), [("hello", "world")])

self.assertEqual(d["hello"], "world")

self.assertEqual(d.getstate(), 0)

d.setstate(10)

self.assertEqual(d.getstate(), 10)

self.assertEqual(D.__mro__, (D, dict, C, object))

# SF bug #442833

class Node(object):

def __int__(self):

return int(self.foo())

def foo(self):

return "23"

class Frag(Node, list):

def foo(self):

return "42"

self.assertEqual(Node().__int__(), 23)

self.assertEqual(int(Node()), 23)

self.assertEqual(Frag().__int__(), 42)

self.assertEqual(int(Frag()), 42)

def test_diamond_inheritance(self):

# Testing multiple inheritance special cases...

class A(object):

def spam(self): return "A"

self.assertEqual(A().spam(), "A")

class B(A):

def boo(self): return "B"

def spam(self): return "B"

self.assertEqual(B().spam(), "B")

self.assertEqual(B().boo(), "B")

class C(A):

def boo(self): return "C"

self.assertEqual(C().spam(), "A")

self.assertEqual(C().boo(), "C")

class D(B, C): pass

self.assertEqual(D().spam(), "B")

self.assertEqual(D().boo(), "B")

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

class E(C, B): pass

self.assertEqual(E().spam(), "B")

self.assertEqual(E().boo(), "C")

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

# MRO order disagreement

try:

class F(D, E): pass

except TypeError:

pass

else:

self.fail("expected MRO order disagreement (F)")

try:

class G(E, D): pass

except TypeError:

pass

else:

self.fail("expected MRO order disagreement (G)")

# see thread python-dev/2002-October/029035.html

def test_ex5_from_c3_switch(self):

# Testing ex5 from C3 switch discussion...

class A(object): pass

class B(object): pass

class C(object): pass

class X(A): pass

class Y(A): pass

class Z(X,B,Y,C): pass

self.assertEqual(Z.__mro__, (Z, X, B, Y, A, C, object))

# see "A Monotonic Superclass Linearization for Dylan",

# by Kim Barrett et al. (OOPSLA 1996)

def test_monotonicity(self):

# Testing MRO monotonicity...

class Boat(object): pass

class DayBoat(Boat): pass

class WheelBoat(Boat): pass

class EngineLess(DayBoat): pass

class SmallMultihull(DayBoat): pass

class PedalWheelBoat(EngineLess,WheelBoat): pass

class SmallCatamaran(SmallMultihull): pass