# Test enhancements related to descriptors and new-style classes

from test.test_support import verbose, TestFailed, TESTFN, get_original_stdout
from test.test_support import run_unittest
import unittest
from copy import deepcopy
import warnings
import types

warnings.filterwarnings("ignore",
         r'complex divmod\(\), // and % are deprecated$',
         DeprecationWarning, r'(<string>|%s)$' % __name__)

class TestCase(unittest.TestCase):

    # This could be part of the standard unittest.TestCase
    def assertIs(self, first, second, msg=None):
        """Fail if the two parameters do not refer to the same object."""
        if first is not second:
            raise self.failureException, \
                  (msg or '%r is %r' % (first, second))

class TestDocstrings(TestCase):
    def test_class_docstrings(self):
        class Classic:
            "A classic docstring."
        self.assertEquals(Classic.__doc__, "A classic docstring.")
        self.assertEquals(Classic.__dict__['__doc__'], "A classic docstring.")

        class Classic2:
            pass
        self.failUnless(Classic2.__doc__ is None)

        class NewStatic(object):
            "Another docstring."
        self.assertEquals(NewStatic.__doc__, "Another docstring.")
        self.assertEquals(NewStatic.__dict__['__doc__'], "Another docstring.")

        class NewStatic2(object):
            pass
        self.failUnless(NewStatic2.__doc__ is None)

        class NewDynamic(object):
            "Another docstring."
        self.assertEquals(NewDynamic.__doc__, "Another docstring.")
        self.assertEquals(NewDynamic.__dict__['__doc__'], "Another docstring.")

        class NewDynamic2(object):
            pass
        self.failUnless(NewDynamic2.__doc__ is None)

    def test_descrdoc(self):
        "Testing descriptor doc strings"
        def check(descr, what):
            self.assertEquals(descr.__doc__, what)
        check(file.closed, "True if the file is closed") # getset descriptor
        check(file.name, "file name") # member descriptor

    def test_docdescriptor(self):
        "Testing __doc__ descriptor"
        # SF bug 542984
        class DocDescr(object):
            def __get__(self, object, otype):
                if object:
                    object = object.__class__.__name__ + ' instance'
                if otype:
                    otype = otype.__name__
                return 'object=%s; type=%s' % (object, otype)
        class OldClass:
            __doc__ = DocDescr()
        class NewClass(object):
            __doc__ = DocDescr()
        self.assertEquals(OldClass.__doc__, 'object=None; type=OldClass')
        self.assertEquals(OldClass().__doc__, 'object=OldClass instance; type=OldClass')
        self.assertEquals(NewClass.__doc__, 'object=None; type=NewClass')
        self.assertEquals(NewClass().__doc__, 'object=NewClass instance; type=NewClass')


class TestOperations(TestCase):

    def _testunop(self, a, res, expr="len(a)", meth="__len__"):
        #if verbose: print "checking", expr
        dict = {'a': a}
        self.assertEquals(eval(expr, dict), res)
        t = type(a)
        m = getattr(t, meth)
        while meth not in t.__dict__:
            t = t.__bases__[0]
        self.assertEquals(m, t.__dict__[meth])
        self.assertEquals(m(a), res)
        bm = getattr(a, meth)
        self.assertEquals(bm(), res)

    def _testbinop(self, a, b, res, expr="a+b", meth="__add__"):
        #if verbose: print "checking", expr
        dict = {'a': a, 'b': b}

        # XXX Hack so this passes before 2.3 when -Qnew is specified.
        if meth == "__div__" and 1/2 == 0.5:
            meth = "__truediv__"

        self.assertEquals(eval(expr, dict), res)
        t = type(a)
        m = getattr(t, meth)
        while meth not in t.__dict__:
            t = t.__bases__[0]
        self.assertEquals(m, t.__dict__[meth])
        self.assertEquals(m(a, b), res)
        bm = getattr(a, meth)
        self.assertEquals(bm(b), res)

    def _testternop(self, a, b, c, res, expr="a[b:c]", meth="__getslice__"):
        #if verbose: print "checking", expr
        dict = {'a': a, 'b': b, 'c': c}
        self.assertEquals(eval(expr, dict), res)
        t = type(a)
        m = getattr(t, meth)
        while meth not in t.__dict__:
            t = t.__bases__[0]
        self.assertEquals(m, t.__dict__[meth])
        self.assertEquals(m(a, b, c), res)
        bm = getattr(a, meth)
        self.assertEquals(bm(b, c), res)

    def _testsetop(self, a, b, res, stmt="a+=b", meth="__iadd__"):
        #if verbose: print "checking", stmt
        dict = {'a': deepcopy(a), 'b': b}
        exec stmt in dict
        self.assertEquals(dict['a'], res)
        t = type(a)
        m = getattr(t, meth)
        while meth not in t.__dict__:
            t = t.__bases__[0]
        self.assertEquals(m, t.__dict__[meth])
        dict['a'] = deepcopy(a)
        m(dict['a'], b)
        self.assertEquals(dict['a'], res)
        dict['a'] = deepcopy(a)
        bm = getattr(dict['a'], meth)
        bm(b)
        self.assertEquals(dict['a'], res)

    def _testset2op(self, a, b, c, res, stmt="a[b]=c", meth="__setitem__"):
        #if verbose: print "checking", stmt
        dict = {'a': deepcopy(a), 'b': b, 'c': c}
        exec stmt in dict
        self.assertEquals(dict['a'], res)
        t = type(a)
        m = getattr(t, meth)
        while meth not in t.__dict__:
            t = t.__bases__[0]
        self.assertEquals(m, t.__dict__[meth])
        dict['a'] = deepcopy(a)
        m(dict['a'], b, c)
        self.assertEquals(dict['a'], res)
        dict['a'] = deepcopy(a)
        bm = getattr(dict['a'], meth)
        bm(b, c)
        self.assertEquals(dict['a'], res)

    def _testset3op(self, a, b, c, d, res, stmt="a[b:c]=d", meth="__setslice__"):
        #if verbose: print "checking", stmt
        dict = {'a': deepcopy(a), 'b': b, 'c': c, 'd': d}
        exec stmt in dict
        self.assertEquals(dict['a'], res)
        t = type(a)
        while meth not in t.__dict__:
            t = t.__bases__[0]
        m = getattr(t, meth)
        self.assertEquals(m, t.__dict__[meth])
        dict['a'] = deepcopy(a)
        m(dict['a'], b, c, d)
        self.assertEquals(dict['a'], res)
        dict['a'] = deepcopy(a)
        bm = getattr(dict['a'], meth)
        bm(b, c, d)
        self.assertEquals(dict['a'], res)


class TestCommonOperations(TestOperations):

    def test_lists(self):
        "Testing list operations"
        self._testbinop([1], [2], [1,2], "a+b", "__add__")
        self._testbinop([1,2,3], 2, 1, "b in a", "__contains__")
        self._testbinop([1,2,3], 4, 0, "b in a", "__contains__")
        self._testbinop([1,2,3], 1, 2, "a[b]", "__getitem__")
        self._testternop([1,2,3], 0, 2, [1,2], "a[b:c]", "__getslice__")
        self._testsetop([1], [2], [1,2], "a+=b", "__iadd__")
        self._testsetop([1,2], 3, [1,2,1,2,1,2], "a*=b", "__imul__")
        self._testunop([1,2,3], 3, "len(a)", "__len__")
        self._testbinop([1,2], 3, [1,2,1,2,1,2], "a*b", "__mul__")
        self._testbinop([1,2], 3, [1,2,1,2,1,2], "b*a", "__rmul__")
        self._testset2op([1,2], 1, 3, [1,3], "a[b]=c", "__setitem__")
        self._testset3op([1,2,3,4], 1, 3, [5,6], [1,5,6,4], "a[b:c]=d", "__setslice__")

    def test_dicts(self):
        "Testing dict operations"
        self._testbinop({1:2}, {2:1}, -1, "cmp(a,b)", "__cmp__")
        self._testbinop({1:2,3:4}, 1, 1, "b in a", "__contains__")
        self._testbinop({1:2,3:4}, 2, 0, "b in a", "__contains__")
        self._testbinop({1:2,3:4}, 1, 2, "a[b]", "__getitem__")
        d = {1:2,3:4}
        l1 = []
        for i in d.keys(): l1.append(i)
        l = []
        for i in iter(d): l.append(i)
        self.assertEquals(l, l1)
        l = []
        for i in d.__iter__(): l.append(i)
        self.assertEquals(l, l1)
        l = []
        for i in dict.__iter__(d): l.append(i)
        self.assertEquals(l, l1)
        d = {1:2, 3:4}
        self._testunop(d, 2, "len(a)", "__len__")
        self.assertEquals(eval(repr(d), {}), d)
        self.assertEquals(eval(d.__repr__(), {}), d)
        self._testset2op({1:2,3:4}, 2, 3, {1:2,2:3,3:4}, "a[b]=c", "__setitem__")

    def test_dict_constructor(self):
        "Testing dict constructor"
        d = dict()
        self.assertEquals(d, {})
        d = dict({})
        self.assertEquals(d, {})
        d = dict({1: 2, 'a': 'b'})
        self.assertEquals(d, {1: 2, 'a': 'b'})
        self.assertEquals(d, dict(d.items()))
        self.assertEquals(d, dict(d.iteritems()))
        d = dict({'one':1, 'two':2})
        self.assertEquals(d, dict(one=1, two=2))
        self.assertEquals(d, dict(**d))
        self.assertEquals(d, dict({"one": 1}, two=2))
        self.assertEquals(d, dict([("two", 2)], one=1))
        self.assertEquals(d, dict([("one", 100), ("two", 200)], **d))
        self.failUnless(d is not dict(**d))
        for badarg in 0, 0L, 0j, "0", [0], (0,):
            try:
                dict(badarg)
            except TypeError:
                pass
            except ValueError:
                if badarg == "0":
                    # It's a sequence, and its elements are also sequences (gotta
                    # love strings <wink>), but they aren't of length 2, so this
                    # one seemed better as a ValueError than a TypeError.
                    pass
                else:
                    self.fail("no TypeError from dict(%r)" % badarg)
            else:
                self.fail("no TypeError from dict(%r)" % badarg)

        self.assertRaises(TypeError, dict, {}, {})

        class Mapping:
            # Lacks a .keys() method; will be added later.
            dict = {1:2, 3:4, 'a':1j}

        self.assertRaises(TypeError, dict, Mapping())

        Mapping.keys = lambda self: self.dict.keys()
        Mapping.__getitem__ = lambda self, i: self.dict[i]
        d = dict(Mapping())
        self.assertEquals(d, Mapping.dict)

        # Init from sequence of iterable objects, each producing a 2-sequence.
        class AddressBookEntry:
            def __init__(self, first, last):
                self.first = first
                self.last = last
            def __iter__(self):
                return iter([self.first, self.last])

        d = dict([AddressBookEntry('Tim', 'Warsaw'),
                  AddressBookEntry('Barry', 'Peters'),
                  AddressBookEntry('Tim', 'Peters'),
                  AddressBookEntry('Barry', 'Warsaw')])
        self.assertEquals(d, {'Barry': 'Warsaw', 'Tim': 'Peters'})

        d = dict(zip(range(4), range(1, 5)))
        self.assertEquals(d, dict([(i, i+1) for i in range(4)]))

        # Bad sequence lengths.
        for bad in [('tooshort',)], [('too', 'long', 'by 1')]:
            self.assertRaises(ValueError, dict, bad)

    def test_dir(self):
        "Testing dir()"
        junk = 12
        self.assertEquals(dir(), ['junk', 'self'])
        del junk

        # Just make sure these don't blow up!
        for arg in 2, 2L, 2j, 2e0, [2], "2", u"2", (2,), {2:2}, type, self.test_dir:
            dir(arg)

        # Try classic classes.
        class C:
            Cdata = 1
            def Cmethod(self): pass

        cstuff = ['Cdata', 'Cmethod', '__doc__', '__module__']
        self.assertEquals(dir(C), cstuff)
        self.failUnless('im_self' in dir(C.Cmethod))

        c = C()  # c.__doc__ is an odd thing to see here; ditto c.__module__.
        self.assertEquals(dir(c), cstuff)

        c.cdata = 2
        c.cmethod = lambda self: 0
        self.assertEquals(dir(c), cstuff + ['cdata', 'cmethod'])
        self.failUnless('im_self' in dir(c.Cmethod))

        class A(C):
            Adata = 1
            def Amethod(self): pass

        astuff = ['Adata', 'Amethod'] + cstuff
        self.assertEquals(dir(A), astuff)
        self.failUnless('im_self' in dir(A.Amethod))
        a = A()
        self.assertEquals(dir(a), astuff)
        self.failUnless('im_self' in dir(a.Amethod))
        a.adata = 42
        a.amethod = lambda self: 3
        self.assertEquals(dir(a), astuff + ['adata', 'amethod'])

        # The same, but with new-style classes.  Since these have object as a
        # base class, a lot more gets sucked in.
        def interesting(strings):
            return [s for s in strings if not s.startswith('_')]

        class C(object):
            Cdata = 1
            def Cmethod(self): pass

        cstuff = ['Cdata', 'Cmethod']
        self.assertEquals(interesting(dir(C)), cstuff)

        c = C()
        self.assertEquals(interesting(dir(c)), cstuff)
        self.failUnless('im_self' in dir(C.Cmethod))

        c.cdata = 2
        c.cmethod = lambda self: 0
        self.assertEquals(interesting(dir(c)), cstuff + ['cdata', 'cmethod'])
        self.failUnless('im_self' in dir(c.Cmethod))

        class A(C):
            Adata = 1
            def Amethod(self): pass

        astuff = ['Adata', 'Amethod'] + cstuff
        self.assertEquals(interesting(dir(A)), astuff)
        self.failUnless('im_self' in dir(A.Amethod))
        a = A()
        self.assertEquals(interesting(dir(a)), astuff)
        a.adata = 42
        a.amethod = lambda self: 3
        self.assertEquals(interesting(dir(a)), astuff + ['adata', 'amethod'])
        self.failUnless('im_self' in dir(a.Amethod))

        # Try a module subclass.
        import sys
        class M(type(sys)):
            pass
        minstance = M("m")
        minstance.b = 2
        minstance.a = 1
        names = [x for x in dir(minstance) if x not in ["__name__", "__doc__"]]
        self.assertEquals(names, ['a', 'b'])

        class M2(M):
            def getdict(self):
                return "Not a dict!"
            __dict__ = property(getdict)

        m2instance = M2("m2")
        m2instance.b = 2
        m2instance.a = 1
        self.assertEquals(m2instance.__dict__, "Not a dict!")
        try:
            dir(m2instance)
        except TypeError:
            pass

        # Two essentially featureless objects, just inheriting stuff from
        # object.
        self.assertEquals(dir(None), dir(Ellipsis))

        # Nasty test case for proxied objects
        class Wrapper(object):
            def __init__(self, obj):
                self.__obj = obj
            def __repr__(self):
                return "Wrapper(%s)" % repr(self.__obj)
            def __getitem__(self, key):
                return Wrapper(self.__obj[key])
            def __len__(self):
                return len(self.__obj)
            def __getattr__(self, name):
                return Wrapper(getattr(self.__obj, name))

        class C(object):
            def __getclass(self):
                return Wrapper(type(self))
            __class__ = property(__getclass)

        dir(C()) # This used to segfault


class TestNumeric(TestOperations):

    binops = {
        'add': '+',
        'sub': '-',
        'mul': '*',
        'div': '/',
        'mod': '%',
        'divmod': 'divmod',
        'pow': '**',
        'lshift': '<<',
        'rshift': '>>',
        'and': '&',
        'xor': '^',
        'or': '|',
        'cmp': 'cmp',
        'lt': '<',
        'le': '<=',
        'eq': '==',
        'ne': '!=',
        'gt': '>',
        'ge': '>=',
        }

    for name, expr in binops.items():
        if expr.islower():
            expr = expr + "(a, b)"
        else:
            expr = 'a %s b' % expr
        binops[name] = expr

    unops = {
        'pos': '+',
        'neg': '-',
        'abs': 'abs',
        'invert': '~',
        'int': 'int',
        'long': 'long',
        'float': 'float',
        'oct': 'oct',
        'hex': 'hex',
        }

    for name, expr in unops.items():
        if expr.islower():
            expr = expr + "(a)"
        else:
            expr = '%s a' % expr
        unops[name] = expr

    def _numops(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._testbinop(a, b, res, expr, name)
        for name, expr in self.unops.items():
            if name not in skip:
                name = "__%s__" % name
                if hasattr(a, name):
                    res = eval(expr, dict)
                    self._testunop(a, res, expr, name)

    def test_ints(self):
        "Testing int operations"
        self._numops(100, 3)
        # The following crashes in Python 2.2
        self.assertEquals((1).__nonzero__(), 1)
        self.assertEquals((0).__nonzero__(), 0)
        # This returns 'NotImplemented' in Python 2.2
        class C(int):
            def __add__(self, other):
                return NotImplemented
        self.assertEquals(C(5L), 5)
        try:
            C() + ""
        except TypeError:
            pass
        else:
            raise TestFailed, "NotImplemented should have caused TypeError"
        import sys
        try:
            C(sys.maxint+1)
        except OverflowError:
            pass
        else:
            raise TestFailed, "should have raised OverflowError"

    def test_longs(self):
        "Testing long operations"
        self._numops(100L, 3L)

    def test_floats(self):
        "Testing float operations"
        self._numops(100.0, 3.0)

    def test_complexes(self):
        "Testing complex operations"
        self._numops(100.0j, 3.0j, skip=['lt', 'le', 'gt', 'ge', 'int', 'long', 'float'])
        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.assertEquals(repr(a), "3.14")
        self.assertEquals(a.prec, 6)

        a = Number(a, prec=2)
        self.assertEquals(repr(a), "3.1")
        self.assertEquals(a.prec, 2)

        a = Number(234.5)
        self.assertEquals(repr(a), "234.5")
        self.assertEquals(a.prec, 12)

    def test_rmul(self):
        "Testing correct invocation of __rmul__"
        # SF patch 592646
        class C(object):
            def __mul__(self, other):
                return "mul"
            def __rmul__(self, other):
                return "rmul"
        a = C()
        self.assertEquals(a*2, "mul")
        self.assertEquals(a*2.2, "mul")
        self.assertEquals(2*a, "rmul")
        self.assertEquals(2.2*a, "rmul")

    def test_imulbug(self):
        "Testing for __imul__ problems"
        # SF bug 544647
        class C(object):
            def __imul__(self, other):
                return (self, other)
        x = C()
        y = x
        y *= 1.0
        self.assertEquals(y, (x, 1.0))
        y = x
        y *= 2
        self.assertEquals(y, (x, 2))
        y = x
        y *= 3L
        self.assertEquals(y, (x, 3L))
        y = x
        y *= 1L<<100
        self.assertEquals(y, (x, 1L<<100))
        y = x
        y *= None
        self.assertEquals(y, (x, None))
        y = x
        y *= "foo"
        self.assertEquals(y, (x, "foo"))

    def test_ipow(self):
        "Testing correct invocation of __ipow__"
        # [SF bug 620179]
        class C(object):
            def __ipow__(self, other):
                pass
        a = C()
        a **= 2

    def test_subclass_right_op(self):
        "Testing correct dispatch of subclass overloading __r<op>__"

        # This code tests various cases where right-dispatch of a subclass
        # should be preferred over left-dispatch of a base class.

        # Case 1: subclass of int; this tests code in abstract.c::binary_op1()

        class B(int):
            def __floordiv__(self, other):
                return "B.__floordiv__"
            def __rfloordiv__(self, other):
                return "B.__rfloordiv__"

        self.assertEquals(B(1) // 1, "B.__floordiv__")
        self.assertEquals(1 // B(1), "B.__rfloordiv__")

        # Case 2: subclass of object; this is just the baseline for case 3

        class C(object):
            def __floordiv__(self, other):
                return "C.__floordiv__"
            def __rfloordiv__(self, other):
                return "C.__rfloordiv__"

        self.assertEquals(C() // 1, "C.__floordiv__")
        self.assertEquals(1 // C(), "C.__rfloordiv__")

        # Case 3: subclass of new-style class; here it gets interesting

        class D(C):
            def __floordiv__(self, other):
                return "D.__floordiv__"
            def __rfloordiv__(self, other):
                return "D.__rfloordiv__"

        self.assertEquals(D() // C(), "D.__floordiv__")
        self.assertEquals(C() // D(), "D.__rfloordiv__")

        # Case 4: this didn't work right in 2.2.2 and 2.3a1

        class E(C):
            pass

        self.assertEquals(E.__rfloordiv__, C.__rfloordiv__)

        self.assertEquals(E() // 1, "C.__floordiv__")
        self.assertEquals(1 // E(), "C.__rfloordiv__")
        self.assertEquals(E() // C(), "C.__floordiv__")
        self.assertEquals(C() // E(), "C.__floordiv__") # This one would fail

    def test_notimplemented(self):
        "Testing NotImplemented"
        # all binary methods should be able to return a NotImplemented
        import sys
        import types
        import operator

        def specialmethod(self, other):
            return NotImplemented

        def check(expr, x, y):
            try:
                exec expr in {'x': x, 'y': y, 'operator': operator}
            except TypeError:
                pass
            else:
                raise self.failureException("no TypeError from %r" % (expr,))

        N1 = sys.maxint + 1L    # might trigger OverflowErrors instead of TypeErrors
        N2 = sys.maxint         # if sizeof(int) < sizeof(long), might trigger
                                #   ValueErrors instead of TypeErrors
        for metaclass in [type, types.ClassType]:
            for name, expr, iexpr in [
                    ('__add__',      'x + y',                   'x += y'),
                    ('__sub__',      'x - y',                   'x -= y'),
                    ('__mul__',      'x * y',                   'x *= y'),
                    ('__truediv__',  'operator.truediv(x, y)',  None),
                    ('__floordiv__', 'operator.floordiv(x, y)', None),
                    ('__div__',      'x / y',                   'x /= y'),
                    ('__mod__',      'x % y',                   'x %= y'),
                    ('__divmod__',   'divmod(x, y)',            None),
                    ('__pow__',      'x ** y',                  'x **= y'),
                    ('__lshift__',   'x << y',                  'x <<= y'),
                    ('__rshift__',   'x >> y',                  'x >>= y'),
                    ('__and__',      'x & y',                   'x &= y'),
                    ('__or__',       'x | y',                   'x |= y'),
                    ('__xor__',      'x ^ y',                   'x ^= y'),
                    ('__coerce__',   'coerce(x, y)',            None)]:
                if name == '__coerce__':
                    rname = name
                else:
                    rname = '__r' + name[2:]
                A = metaclass('A', (), {name: specialmethod})
                B = metaclass('B', (), {rname: specialmethod})
                a = A()
                b = B()
                check(expr, a, a)
                check(expr, a, b)
                check(expr, b, a)
                check(expr, b, b)
                check(expr, a, N1)
                check(expr, a, N2)
                check(expr, N1, b)
                check(expr, N2, b)
                if iexpr:
                    check(iexpr, a, a)
                    check(iexpr, a, b)
                    check(iexpr, b, a)
                    check(iexpr, b, b)
                    check(iexpr, a, N1)
                    check(iexpr, a, N2)
                    iname = '__i' + name[2:]
                    C = metaclass('C', (), {iname: specialmethod})
                    c = C()
                    check(iexpr, c, a)
                    check(iexpr, c, b)
                    check(iexpr, c, N1)
                    check(iexpr, c, N2)

    def test_coercions(self):
        "Testing coercions"
        class I(int): pass
        coerce(I(0), 0)
        coerce(0, I(0))
        class L(long): pass
        coerce(L(0), 0)
        coerce(L(0), 0L)
        coerce(0, L(0))
        coerce(0L, L(0))
        class F(float): pass
        coerce(F(0), 0)
        coerce(F(0), 0L)
        coerce(F(0), 0.)
        coerce(0, F(0))
        coerce(0L, F(0))
        coerce(0., F(0))
        class C(complex): pass
        coerce(C(0), 0)
        coerce(C(0), 0L)
        coerce(C(0), 0.)
        coerce(C(0), 0j)
        coerce(0, C(0))
        coerce(0L, C(0))
        coerce(0., C(0))
        coerce(0j, C(0))


class TestString(TestCase):
    def test_strops(self):
        try: 'a' + 5
        except TypeError: pass
        else: raise TestFailed, "'' + 5 doesn't raise TypeError"

        try: ''.split('')
        except ValueError: pass
        else: raise TestFailed, "''.split('') doesn't raise ValueError"

        try: ''.join([0])
        except TypeError: pass
        else: raise TestFailed, "''.join([0]) doesn't raise TypeError"

        try: ''.rindex('5')
        except ValueError: pass
        else: raise TestFailed, "''.rindex('5') doesn't raise ValueError"

        try: '%(n)s' % None
        except TypeError: pass
        else: raise TestFailed, "'%(n)s' % None doesn't raise TypeError"

        try: '%(n' % {}
        except ValueError: pass
        else: raise TestFailed, "'%(n' % {} '' doesn't raise ValueError"

        try: '%*s' % ('abc')
        except TypeError: pass
        else: raise TestFailed, "'%*s' % ('abc') doesn't raise TypeError"

        try: '%*.*s' % ('abc', 5)
        except TypeError: pass
        else: raise TestFailed, "'%*.*s' % ('abc', 5) doesn't raise TypeError"

        try: '%s' % (1, 2)
        except TypeError: pass
        else: raise TestFailed, "'%s' % (1, 2) doesn't raise TypeError"

        try: '%' % None
        except ValueError: pass
        else: raise TestFailed, "'%' % None doesn't raise ValueError"

        self.assertEquals('534253'.isdigit(), 1)
        self.assertEquals('534253x'.isdigit(), 0)
        self.assertEquals('%c' % 5, '\x05')
        self.assertEquals('%c' % '5', '5')


class TestSpams(TestOperations):
    def test_spamlists(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._testbinop(spamlist([1]), spamlist([2]), spamlist([1,2]), "a+b", "__add__")
        self._testbinop(spamlist([1,2,3]), 2, 1, "b in a", "__contains__")
        self._testbinop(spamlist([1,2,3]), 4, 0, "b in a", "__contains__")
        self._testbinop(spamlist([1,2,3]), 1, 2, "a[b]", "__getitem__")
        self._testternop(spamlist([1,2,3]), 0, 2, spamlist([1,2]),
                   "a[b:c]", "__getslice__")
        self._testsetop(spamlist([1]), spamlist([2]), spamlist([1,2]),
                  "a+=b", "__iadd__")
        self._testsetop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*=b", "__imul__")
        self._testunop(spamlist([1,2,3]), 3, "len(a)", "__len__")
        self._testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "a*b", "__mul__")
        self._testbinop(spamlist([1,2]), 3, spamlist([1,2,1,2,1,2]), "b*a", "__rmul__")
        self._testset2op(spamlist([1,2]), 1, 3, spamlist([1,3]), "a[b]=c", "__setitem__")
        self._testset3op(spamlist([1,2,3,4]), 1, 3, spamlist([5,6]),
                         spamlist([1,5,6,4]), "a[b:c]=d", "__setslice__")
        # Test subclassing
        class C(spam.spamlist):
            def foo(self): return 1
        a = C()
        self.assertEquals(a, [])
        self.assertEquals(a.foo(), 1)
        a.append(100)
        self.assertEquals(a, [100])
        self.assertEquals(a.getstate(), 0)
        a.setstate(42)
        self.assertEquals(a.getstate(), 42)

    def test_spamdicts(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 d.items(): sd[k] = v
            return sd
        # This is an ugly hack:
        copy._deepcopy_dispatch[spam.spamdict] = spamdict

        self._testbinop(spamdict({1:2}), spamdict({2:1}), -1, "cmp(a,b)", "__cmp__")
        self._testbinop(spamdict({1:2,3:4}), 1, 1, "b in a", "__contains__")
        self._testbinop(spamdict({1:2,3:4}), 2, 0, "b in a", "__contains__")
        self._testbinop(spamdict({1:2,3:4}), 1, 2, "a[b]", "__getitem__")
        d = spamdict({1:2,3:4})
        l1 = []
        for i in d.keys(): l1.append(i)
        l = []
        for i in iter(d): l.append(i)
        self.assertEquals(l, l1)
        l = []
        for i in d.__iter__(): l.append(i)
        self.assertEquals(l, l1)
        l = []
        for i in type(spamdict({})).__iter__(d): l.append(i)
        self.assertEquals(l, l1)
        straightd = {1:2, 3:4}
        spamd = spamdict(straightd)
        self._testunop(spamd, 2, "len(a)", "__len__")
        self._testunop(spamd, repr(straightd), "repr(a)", "__repr__")
        self._testset2op(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.assertEquals(a.items(), [])
        self.assertEquals(a.foo(), 1)
        a['foo'] = 'bar'
        self.assertEquals(a.items(), [('foo', 'bar')])
        self.assertEquals(a.getstate(), 0)
        a.setstate(100)
        self.assertEquals(a.getstate(), 100)


class TestSubclasses(TestCase):
    def test_pydicts(self):
        "Testing Python subclass of dict"
        self.failUnless(issubclass(dict, dict))
        self.failUnless(isinstance({}, dict))
        d = dict()
        self.assertEquals(d, {})
        self.failUnless(d.__class__ is dict)
        self.failUnless(isinstance(d, dict))
        test = self
        class C(dict):
            state = -1
            def __init__(self, *a, **kw):
                if a:
                    test.assertEquals(len(a), 1)
                    self.state = a[0]
                if kw:
                    for k, v in kw.items(): self[v] = k
            def __getitem__(self, key):
                return self.get(key, 0)
            def __setitem__(self, key, value):
                test.failUnless(isinstance(key, type(0)))
                dict.__setitem__(self, key, value)
            def setstate(self, state):
                self.state = state
            def getstate(self):
                return self.state
        self.failUnless(issubclass(C, dict))
        a1 = C(12)
        self.assertEquals(a1.state, 12)
        a2 = C(foo=1, bar=2)
        self.assertEquals(a2[1] == 'foo' and a2[2], 'bar')
        a = C()
        self.assertEquals(a.state, -1)
        self.assertEquals(a.getstate(), -1)
        a.setstate(0)
        self.assertEquals(a.state, 0)
        self.assertEquals(a.getstate(), 0)
        a.setstate(10)
        self.assertEquals(a.state, 10)
        self.assertEquals(a.getstate(), 10)
        self.assertEquals(a[42], 0)
        a[42] = 24
        self.assertEquals(a[42], 24)

        # pydict stress test
        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.assertEquals(a[i][j], i*j)

    def test_pylists(self):
        "Testing Python subclass of list"
        class C(list):
            def __getitem__(self, i):
                return list.__getitem__(self, i) + 100
            def __getslice__(self, i, j):
                return (i, j)
        a = C()
        a.extend([0,1,2])
        self.assertEquals(a[0], 100)
        self.assertEquals(a[1], 101)
        self.assertEquals(a[2], 102)
        self.assertEquals(a[100:200], (100,200))

    def test_pymods(self):
        "Testing Python subclass of module"
        log = []
        import sys
        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.assertEquals(log, [("setattr", "foo", 12),
                    ("getattr", "foo"),
                    ("delattr", "foo")])

        # http://python.org/sf/1174712
        try:
            class Module(types.ModuleType, str):
                pass
        except TypeError:
            pass
        else:
            raise self.failureException("inheriting from ModuleType and str "
                                        "at the same time should fail")

    def test_inherits(self):
        "Testing inheritance from basic types"

        class hexint(int):
            def __repr__(self):
                return hex(self)
            def __add__(self, other):
                return hexint(int.__add__(self, other))
            # (Note that overriding __radd__ doesn't work,
            # because the int type gets first dibs.)
        self.assertEquals(repr(hexint(7) + 9), "0x10")
        self.assertEquals(repr(hexint(1000) + 7), "0x3ef")
        a = hexint(12345)
        self.assertEquals(a, 12345)
        self.assertEquals(int(a), 12345)
        self.failUnless(int(a).__class__ is int)
        self.assertEquals(hash(a), hash(12345))
        self.failUnless((+a).__class__ is int)
        self.failUnless((a >> 0).__class__ is int)
        self.failUnless((a << 0).__class__ is int)
        self.failUnless((hexint(0) << 12).__class__ is int)
        self.failUnless((hexint(0) >> 12).__class__ is int)

        class octlong(long):
            __slots__ = []
            def __str__(self):
                s = oct(self)
                if s[-1] == 'L':
                    s = s[:-1]
                return s
            def __add__(self, other):
                return self.__class__(super(octlong, self).__add__(other))
            __radd__ = __add__
        self.assertEquals(str(octlong(3) + 5), "010")
        # (Note that overriding __radd__ here only seems to work
        # because the example uses a short int left argument.)
        self.assertEquals(str(5 + octlong(3000)), "05675")
        a = octlong(12345)
        self.assertEquals(a, 12345L)
        self.assertEquals(long(a), 12345L)
        self.assertEquals(hash(a), hash(12345L))
        self.failUnless(long(a).__class__ is long)
        self.failUnless((+a).__class__ is long)
        self.failUnless((-a).__class__ is long)
        self.failUnless((-octlong(0)).__class__ is long)
        self.failUnless((a >> 0).__class__ is long)
        self.failUnless((a << 0).__class__ is long)
        self.failUnless((a - 0).__class__ is long)
        self.failUnless((a * 1).__class__ is long)
        self.failUnless((a ** 1).__class__ is long)
        self.failUnless((a // 1).__class__ is long)
        self.failUnless((1 * a).__class__ is long)
        self.failUnless((a | 0).__class__ is long)
        self.failUnless((a ^ 0).__class__ is long)
        self.failUnless((a & -1L).__class__ is long)
        self.failUnless((octlong(0) << 12).__class__ is long)
        self.failUnless((octlong(0) >> 12).__class__ is long)
        self.failUnless(abs(octlong(0)).__class__ is long)

        # Because octlong overrides __add__, we can't check the absence of +0
        # optimizations using octlong.
        class longclone(long):
            pass
        a = longclone(1)
        self.failUnless((a + 0).__class__ is long)
        self.failUnless((0 + a).__class__ is long)

        # Check that negative clones don't segfault
        a = longclone(-1)
        self.assertEquals(a.__dict__, {})
        self.assertEquals(long(a), -1)  # verify PyNumber_Long() copies the sign bit

        class precfloat(float):
            __slots__ = ['prec']
            def __init__(self, value=0.0, prec=12):
                self.prec = int(prec)
            def __repr__(self):
                return "%.*g" % (self.prec, self)
        self.assertEquals(repr(precfloat(1.1)), "1.1")
        a = precfloat(12345)
        self.assertEquals(a, 12345.0)
        self.assertEquals(float(a), 12345.0)
        self.failUnless(float(a).__class__ is float)
        self.assertEquals(hash(a), hash(12345.0))
        self.failUnless((+a).__class__ is float)

        class madcomplex(complex):
            def __repr__(self):
                return "%.17gj%+.17g" % (self.imag, self.real)
        a = madcomplex(-3, 4)
        self.assertEquals(repr(a), "4j-3")
        base = complex(-3, 4)
        self.assertIs(base.__class__, complex)
        self.assertEquals(a, base)
        self.assertEquals(complex(a), base)
        self.assertIs(complex(a).__class__, complex)
        a = madcomplex(a)  # just trying another form of the constructor
        self.assertEquals(repr(a), "4j-3")
        self.assertEquals(a, base)
        self.assertEquals(complex(a), base)
        self.assertIs(complex(a).__class__, complex)
        self.assertEquals(hash(a), hash(base))
        self.assertIs((+a).__class__, complex)
        self.assertIs((a + 0).__class__, complex)
        self.assertEquals(a + 0, base)
        self.assertIs((a - 0).__class__, complex)
        self.assertEquals(a - 0, base)
        self.assertIs((a * 1).__class__, complex)
        self.assertEquals(a * 1, base)
        self.assertIs((a / 1).__class__, complex)
        self.assertEquals(a / 1, base)

        class madtuple(tuple):
            _rev = None
            def rev(self):
                if self._rev is not None:
                    return self._rev
                L = list(self)
                L.reverse()
                self._rev = self.__class__(L)
                return self._rev
        a = madtuple((1,2,3,4,5,6,7,8,9,0))
        self.assertEquals(a, (1,2,3,4,5,6,7,8,9,0))
        self.assertEquals(a.rev(), madtuple((0,9,8,7,6,5,4,3,2,1)))
        self.assertEquals(a.rev().rev(), madtuple((1,2,3,4,5,6,7,8,9,0)))
        for i in range(512):
            t = madtuple(range(i))
            u = t.rev()
            v = u.rev()
            self.assertEquals(v, t)
        a = madtuple((1,2,3,4,5))
        self.assertEquals(tuple(a), (1,2,3,4,5))
        self.failUnless(tuple(a).__class__ is tuple)
        self.assertEquals(hash(a), hash((1,2,3,4,5)))
        self.failUnless(a[:].__class__ is tuple)
        self.failUnless((a * 1).__class__ is tuple)
        self.failUnless((a * 0).__class__ is tuple)
        self.failUnless((a + ()).__class__ is tuple)
        a = madtuple(())
        self.assertEquals(tuple(a), ())
        self.failUnless(tuple(a).__class__ is tuple)
        self.failUnless((a + a).__class__ is tuple)
        self.failUnless((a * 0).__class__ is tuple)
        self.failUnless((a * 1).__class__ is tuple)
        self.failUnless((a * 2).__class__ is tuple)
        self.failUnless(a[:].__class__ is tuple)

        class madstring(str):
            _rev = None
            def rev(self):
                if self._rev is not None:
                    return self._rev
                L = list(self)
                L.reverse()
                self._rev = self.__class__("".join(L))
                return self._rev
        s = madstring("abcdefghijklmnopqrstuvwxyz")
        self.assertEquals(s, "abcdefghijklmnopqrstuvwxyz")
        self.assertEquals(s.rev(), madstring("zyxwvutsrqponmlkjihgfedcba"))
        self.assertEquals(s.rev().rev(), madstring("abcdefghijklmnopqrstuvwxyz"))
        for i in range(256):
            s = madstring("".join(map(chr, range(i))))
            t = s.rev()
            u = t.rev()
            self.assertEquals(u, s)
        s = madstring("12345")
        self.assertEquals(str(s), "12345")
        self.failUnless(str(s).__class__ is str)

        base = "\x00" * 5
        s = madstring(base)
        self.assertEquals(s, base)
        self.assertEquals(str(s), base)
        self.failUnless(str(s).__class__ is str)
        self.assertEquals(hash(s), hash(base))
        self.assertEquals({s: 1}[base], 1)
        self.assertEquals({base: 1}[s], 1)
        self.failUnless((s + "").__class__ is str)
        self.assertEquals(s + "", base)
        self.failUnless(("" + s).__class__ is str)
        self.assertEquals("" + s, base)
        self.failUnless((s * 0).__class__ is str)
        self.assertEquals(s * 0, "")
        self.failUnless((s * 1).__class__ is str)
        self.assertEquals(s * 1, base)
        self.failUnless((s * 2).__class__ is str)
        self.assertEquals(s * 2, base + base)
        self.failUnless(s[:].__class__ is str)
        self.assertEquals(s[:], base)
        self.failUnless(s[0:0].__class__ is str)
        self.assertEquals(s[0:0], "")
        self.failUnless(s.strip().__class__ is str)
        self.assertEquals(s.strip(), base)
        self.failUnless(s.lstrip().__class__ is str)
        self.assertEquals(s.lstrip(), base)
        self.failUnless(s.rstrip().__class__ is str)
        self.assertEquals(s.rstrip(), base)
        identitytab = ''.join([chr(i) for i in range(256)])
        self.failUnless(s.translate(identitytab).__class__ is str)
        self.assertEquals(s.translate(identitytab), base)
        self.failUnless(s.translate(identitytab, "x").__class__ is str)
        self.assertEquals(s.translate(identitytab, "x"), base)
        self.assertEquals(s.translate(identitytab, "\x00"), "")
        self.failUnless(s.replace("x", "x").__class__ is str)
        self.assertEquals(s.replace("x", "x"), base)
        self.failUnless(s.ljust(len(s)).__class__ is str)
        self.assertEquals(s.ljust(len(s)), base)
        self.failUnless(s.rjust(len(s)).__class__ is str)
        self.assertEquals(s.rjust(len(s)), base)
        self.failUnless(s.center(len(s)).__class__ is str)
        self.assertEquals(s.center(len(s)), base)
        self.failUnless(s.lower().__class__ is str)
        self.assertEquals(s.lower(), base)

        class madunicode(unicode):
            _rev = None
            def rev(self):
                if self._rev is not None:
                    return self._rev
                L = list(self)
                L.reverse()
                self._rev = self.__class__(u"".join(L))
                return self._rev
        u = madunicode("ABCDEF")
        self.assertEquals(u, u"ABCDEF")
        self.assertEquals(u.rev(), madunicode(u"FEDCBA"))
        self.assertEquals(u.rev().rev(), madunicode(u"ABCDEF"))
        base = u"12345"
        u = madunicode(base)
        self.assertEquals(unicode(u), base)
        self.failUnless(unicode(u).__class__ is unicode)
        self.assertEquals(hash(u), hash(base))
        self.assertEquals({u: 1}[base], 1)
        self.assertEquals({base: 1}[u], 1)
        self.failUnless(u.strip().__class__ is unicode)
        self.assertEquals(u.strip(), base)
        self.failUnless(u.lstrip().__class__ is unicode)
        self.assertEquals(u.lstrip(), base)
        self.failUnless(u.rstrip().__class__ is unicode)
        self.assertEquals(u.rstrip(), base)
        self.failUnless(u.replace(u"x", u"x").__class__ is unicode)
        self.assertEquals(u.replace(u"x", u"x"), base)
        self.failUnless(u.replace(u"xy", u"xy").__class__ is unicode)
        self.assertEquals(u.replace(u"xy", u"xy"), base)
        self.failUnless(u.center(len(u)).__class__ is unicode)
        self.assertEquals(u.center(len(u)), base)
        self.failUnless(u.ljust(len(u)).__class__ is unicode)
        self.assertEquals(u.ljust(len(u)), base)
        self.failUnless(u.rjust(len(u)).__class__ is unicode)
        self.assertEquals(u.rjust(len(u)), base)
        self.failUnless(u.lower().__class__ is unicode)
        self.assertEquals(u.lower(), base)
        self.failUnless(u.upper().__class__ is unicode)
        self.assertEquals(u.upper(), base)
        self.failUnless(u.capitalize().__class__ is unicode)
        self.assertEquals(u.capitalize(), base)
        self.failUnless(u.title().__class__ is unicode)
        self.assertEquals(u.title(), base)
        self.failUnless((u + u"").__class__ is unicode)
        self.assertEquals(u + u"", base)
        self.failUnless((u"" + u).__class__ is unicode)
        self.assertEquals(u"" + u, base)
        self.failUnless((u * 0).__class__ is unicode)
        self.assertEquals(u * 0, u"")
        self.failUnless((u * 1).__class__ is unicode)
        self.assertEquals(u * 1, base)
        self.failUnless((u * 2).__class__ is unicode)
        self.assertEquals(u * 2, base + base)
        self.failUnless(u[:].__class__ is unicode)
        self.assertEquals(u[:], base)
        self.failUnless(u[0:0].__class__ is unicode)
        self.assertEquals(u[0:0], u"")

        class sublist(list):
            pass
        a = sublist(range(5))
        self.assertEquals(a, range(5))
        a.append("hello")
        self.assertEquals(a, range(5) + ["hello"])
        a[5] = 5
        self.assertEquals(a, range(6))
        a.extend(range(6, 20))
        self.assertEquals(a, range(20))
        a[-5:] = []
        self.assertEquals(a, range(15))
        del a[10:15]
        self.assertEquals(len(a), 10)
        self.assertEquals(a, range(10))
        self.assertEquals(list(a), range(10))
        self.assertEquals(a[0], 0)
        self.assertEquals(a[9], 9)
        self.assertEquals(a[-10], 0)
        self.assertEquals(a[-1], 9)
        self.assertEquals(a[:5], range(5))

        class CountedInput(file):
            """Counts lines read by self.readline().

            self.lineno is the 0-based ordinal of the last line read, up to
            a maximum of one greater than the number of lines in the file.

            self.ateof is true if and only if the final "" line has been read,
            at which point self.lineno stops incrementing, and further calls
            to readline() continue to return "".
            """

            lineno = 0
            ateof = 0
            def readline(self):
                if self.ateof:
                    return ""
                s = file.readline(self)
                # Next line works too.
                # s = super(CountedInput, self).readline()
                self.lineno += 1
                if s == "":
                    self.ateof = 1
                return s

        f = file(name=TESTFN, mode='w')
        lines = ['a\n', 'b\n', 'c\n']
        try:
            f.writelines(lines)
            f.close()
            f = CountedInput(TESTFN)
            for (i, expected) in zip(range(1, 5) + [4], lines + 2 * [""]):
                got = f.readline()
                self.assertEquals(expected, got)
                self.assertEquals(f.lineno, i)
                self.assertEquals(f.ateof, (i > len(lines)))
            f.close()
        finally:
            try:
                f.close()
            except:
                pass
            try:
                import os
                os.unlink(TESTFN)
            except:
                pass

    def test_buffer_inherit(self):
        "Testing that buffer interface is inherited"
        import binascii
        # SF bug [#470040] ParseTuple t# vs subclasses.

        class MyStr(str):
            pass
        base = 'abc'
        m = MyStr(base)
        # b2a_hex uses the buffer interface to get its argument's value, via
        # PyArg_ParseTuple 't#' code.
        self.assertEquals(binascii.b2a_hex(m), binascii.b2a_hex(base))

        # It's not clear that unicode will continue to support the character
        # buffer interface, and this test will fail if that's taken away.
        class MyUni(unicode):
            pass
        base = u'abc'
        m = MyUni(base)
        self.assertEquals(binascii.b2a_hex(m), binascii.b2a_hex(base))

        class MyInt(int):
            pass
        m = MyInt(42)

        # subclass of int should not have a buffer interface
        self.assertRaises(TypeError, binascii.b2a_hex, m)
        try:
            binascii.b2a_hex(m)
            raise TestFailed('subclass of int should not have a buffer interface')
        except TypeError:
            pass

    def test_hash_inherit(self):
        "Testing hash of mutable subclasses"

        class mydict(dict):
            pass
        d = mydict()
        try:
            hash(d)
        except TypeError:
            pass
        else:
            raise TestFailed, "hash() of dict subclass should fail"

        class mylist(list):
            pass
        d = mylist()
        try:
            hash(d)
        except TypeError:
            pass
        else:
            raise TestFailed, "hash() of list subclass should fail"

    def test_str_of_str_subclass(self):
        "Testing __str__ defined in subclass of str"
        import binascii
        import cStringIO

        class octetstring(str):
            def __str__(self):
                return binascii.b2a_hex(self)
            def __repr__(self):
                return self + " repr"

        o = octetstring('A')
        self.assertEquals(type(o), octetstring)
        self.assertEquals(type(str(o)), str)
        self.assertEquals(type(repr(o)), str)
        self.assertEquals(ord(o), 0x41)
        self.assertEquals(str(o), '41')
        self.assertEquals(repr(o), 'A repr')
        self.assertEquals(o.__str__(), '41')
        self.assertEquals(o.__repr__(), 'A repr')

        capture = cStringIO.StringIO()
        # Calling str() or not exercises different internal paths.
        print >> capture, o
        print >> capture, str(o)
        self.assertEquals(capture.getvalue(), '41\n41\n')
        capture.close()

    def test_str_subclass_as_dict_key(self):
        "Testing a str subclass used as dict key"

        class cistr(str):
            """Sublcass of str that computes __eq__ case-insensitively.

            Also computes a hash code of the string in canonical form.
            """

            def __init__(self, value):
                self.canonical = value.lower()
                self.hashcode = hash(self.canonical)

            def __eq__(self, other):
                if not isinstance(other, cistr):
                    other = cistr(other)
                return self.canonical == other.canonical

            def __hash__(self):
                return self.hashcode

        self.assertEquals(cistr('ABC'), 'abc')
        self.assertEquals('aBc', cistr('ABC'))
        self.assertEquals(str(cistr('ABC')), 'ABC')

        d = {cistr('one'): 1, cistr('two'): 2, cistr('tHree'): 3}
        self.assertEquals(d[cistr('one')], 1)
        self.assertEquals(d[cistr('tWo')], 2)
        self.assertEquals(d[cistr('THrEE')], 3)
        self.failUnless(cistr('ONe') in d)
        self.assertEquals(d.get(cistr('thrEE')), 3)


class TestMetaclass(TestCase):
    def test_metaclass(self):
        "Testing __metaclass__"
        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.assertEquals(a.getstate(), 0)
        a.setstate(10)
        self.assertEquals(a.getstate(), 10)
        class D:
            class __metaclass__(type):
                def myself(cls): return cls
        self.assertEquals(D.myself(), D)
        d = D()
        self.failUnless(d.__class__ is D)
        class M1(type):
            def __new__(cls, name, bases, dict):
                dict['__spam__'] = 1
                return type.__new__(cls, name, bases, dict)
        class C:
            __metaclass__ = M1
        self.assertEquals(C.__spam__, 1)
        c = C()
        self.assertEquals(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.assertEquals(C.name, 'C')
        self.assertEquals(C.bases, ())
        self.failUnless('spam' in C.dict)
        c = C()
        self.assertEquals(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.assertEquals(D().meth(), "DCBA")
        class E(B, C):
            def meth(self):
                return "E" + self.__super.meth()
        self.assertEquals(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.iteritems():
                    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.iteritems():
                    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.failUnless(not hasattr(a, "x"))
        a.x = 12
        self.assertEquals(a.x, 12)
        self.assertEquals(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.assertEquals(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
        self.assertEquals(T.counter, 1)
        a = C()
        self.assertEquals(type(a), C)
        self.assertEquals(T.counter, 1)

        class C(object): pass
        c = C()
        try: c()
        except TypeError: pass
        else: raise TestFailed, "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

        # The most derived metaclass of D is A rather than type.
        class D(B, C):
            pass

    def test_dict_type_with_metaclass(self):
        "Testing type of __dict__ when __metaclass__ set"

        class B(object):
            pass
        class M(type):
            pass
        class C:
            # In 2.3a1, C.__dict__ was a real dict rather than a dict proxy
            __metaclass__ = M
        self.assertIs(type(C.__dict__), type(B.__dict__))


class TestMultipleInheritance(TestCase):
    def test_multi(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.assertEquals(a.getstate(), 0)
        a.setstate(10)
        self.assertEquals(a.getstate(), 10)
        class D(dict, C):
            def __init__(self):
                type({}).__init__(self)
                C.__init__(self)
        d = D()
        self.assertEquals(d.keys(), [])
        d["hello"] = "world"
        self.assertEquals(d.items(), [("hello", "world")])
        self.assertEquals(d["hello"], "world")
        self.assertEquals(d.getstate(), 0)
        d.setstate(10)
        self.assertEquals(d.getstate(), 10)
        self.assertEquals(D.__mro__, (D, dict, C, object))

    def test_bug_442833(self):
        # 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.assertEquals(Node().__int__(), 23)
        self.assertEquals(int(Node()), 23)
        self.assertEquals(Frag().__int__(), 42)
        self.assertEquals(int(Frag()), 42)

    def test_mix_classic_new(self):
        "mixing classic and new-style classes"
        class A:
            x = 1

        class B(A):
            pass

        class C(A):
            x = 2

        class D(B, C):
            pass
        self.assertEquals(D.x, 1)

        # Classic MRO is preserved for a classic base class.
        class E(D, object):
            pass
        self.assertEquals(E.__mro__, (E, D, B, A, C, object))
        self.assertEquals(E.x, 1)

        # But with a mix of classic bases, their MROs are combined using
        # new-style MRO.
        class F(B, C, object):
            pass
        self.assertEquals(F.__mro__, (F, B, C, A, object))
        self.assertEquals(F.x, 2)

    def test_something_else(self):
        "Try something else"
        class C:
            def cmethod(self):
                return "C a"
            def all_method(self):
                return "C b"

        class M1(C, object):
            def m1method(self):
                return "M1 a"
            def all_method(self):
                return "M1 b"

        self.assertEquals(M1.__mro__, (M1, C, object))
        m = M1()
        self.assertEquals(m.cmethod(), "C a")
        self.assertEquals(m.m1method(), "M1 a")
        self.assertEquals(m.all_method(), "M1 b")

        class D(C):
            def dmethod(self):
                return "D a"
            def all_method(self):
                return "D b"

        class M2(D, object):
            def m2method(self):
                return "M2 a"
            def all_method(self):
                return "M2 b"

        self.assertEquals(M2.__mro__, (M2, D, C, object))
        m = M2()
        self.assertEquals(m.cmethod(), "C a")
        self.assertEquals(m.dmethod(), "D a")
        self.assertEquals(m.m2method(), "M2 a")
        self.assertEquals(m.all_method(), "M2 b")

        class M3(M1, M2, object):
            def m3method(self):
                return "M3 a"
            def all_method(self):
                return "M3 b"
        self.assertEquals(M3.__mro__, (M3, M1, M2, D, C, object))
        m = M3()
        self.assertEquals(m.cmethod(), "C a")
        self.assertEquals(m.dmethod(), "D a")
        self.assertEquals(m.m1method(), "M1 a")
        self.assertEquals(m.m2method(), "M2 a")
        self.assertEquals(m.m3method(), "M3 a")
        self.assertEquals(m.all_method(), "M3 b")

    def test_only_classic(self):
        class Classic:
            pass
        try:
            class New(Classic):
                __metaclass__ = type
        except TypeError:
            pass
        else:
            raise TestFailed, "new class with only classic bases - shouldn't be"

    def test_mro_disagreement(self):
        "Testing error messages for MRO disagreement"
        mro_err_msg = ("Cannot create a consistent method resolution\n"
                       "order (MRO) for bases ")

        def raises(exc, expected, callable, *args):
            try:
                callable(*args)
            except exc, msg:
                if not str(msg).startswith(expected):
                    raise TestFailed, "Message %r, expected %r" % (str(msg),
                                                                   expected)
            else:
                raise TestFailed, "Expected %s" % exc
        class A(object): pass
        class B(A): pass
        class C(object): pass
        # Test some very simple errors
        raises(TypeError, "duplicate base class A",
               type, "X", (A, A), {})
        raises(TypeError, mro_err_msg,
               type, "X", (A, B), {})
        raises(TypeError, mro_err_msg,
               type, "X", (A, C, B), {})
        # Test a slightly more complex error
        class GridLayout(object): pass
        class HorizontalGrid(GridLayout): pass
        class VerticalGrid(GridLayout): pass
        class HVGrid(HorizontalGrid, VerticalGrid): pass
        class VHGrid(VerticalGrid, HorizontalGrid): pass
        raises(TypeError, mro_err_msg,
               type, "ConfusedGrid", (HVGrid, VHGrid), {})

    def test_diamond(self):
        "Testing multiple inheritance special cases"
        class A(object):
            def spam(self): return "A"
        self.assertEquals(A().spam(), "A")
        class B(A):
            def boo(self): return "B"
            def spam(self): return "B"
        self.assertEquals(B().spam(), "B")
        self.assertEquals(B().boo(), "B")
        class C(A):
            def boo(self): return "C"
        self.assertEquals(C().spam(), "A")
        self.assertEquals(C().boo(), "C")
        class D(B, C): pass
        self.assertEquals(D().spam(), "B")
        self.assertEquals(D().boo(), "B")
        self.assertEquals(D.__mro__, (D, B, C, A, object))
        class E(C, B): pass
        self.assertEquals(E().spam(), "B")
        self.assertEquals(E().boo(), "C")
        self.assertEquals(E.__mro__, (E, C, B, A, object))
        # MRO order disagreement
        try:
            class F(D, E): pass
        except TypeError:
            pass
        else:
            raise TestFailed, "expected MRO order disagreement (F)"
        try:
            class G(E, D): pass
        except TypeError:
            pass
        else:
            raise TestFailed, "expected MRO order disagreement (G)"


    def test_ex5(self):
        "Testing ex5 from C3 switch discussion"
        # see thread python-dev/2002-October/029035.html
        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.assertEquals(Z.__mro__, (Z, X, B, Y, A, C, object))

    def test_monotonicity(self):
        "Testing MRO monotonicity"
        # see "A Monotonic Superclass Linearization for Dylan",
        # by Kim Barrett et al. (OOPSLA 1996)
        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
        class Pedalo(PedalWheelBoat,SmallCatamaran): pass

        self.assertEquals(PedalWheelBoat.__mro__,
              (PedalWheelBoat, EngineLess, DayBoat, WheelBoat, Boat,
               object))
        self.assertEquals(SmallCatamaran.__mro__,
              (SmallCatamaran, SmallMultihull, DayBoat, Boat, object))

        self.assertEquals(Pedalo.__mro__,
              (Pedalo, PedalWheelBoat, EngineLess, SmallCatamaran,
               SmallMultihull, DayBoat, WheelBoat, Boat, object))

    def test_consistency_with_epg(self):
        "Testing consistentcy with EPG"
        # see "A Monotonic Superclass Linearization for Dylan",
        # by Kim Barrett et al. (OOPSLA 1996)
        class Pane(object): pass
        class ScrollingMixin(object): pass
        class EditingMixin(object): pass
        class ScrollablePane(Pane,ScrollingMixin): pass
        class EditablePane(Pane,EditingMixin): pass
        class EditableScrollablePane(ScrollablePane,EditablePane): pass

        self.assertEquals(EditableScrollablePane.__mro__,
              (EditableScrollablePane, ScrollablePane, EditablePane,
               Pane, ScrollingMixin, EditingMixin, object))

    def test_slotmultipleinheritance(self):
        # SF bug 575229, multiple inheritance w/ slots dumps core
        class A(object):
            __slots__=()
        class B(object):
            pass
        class C(A,B) :
            __slots__=()
        self.assertEquals(C.__basicsize__, B.__basicsize__)
        self.failUnless(hasattr(C, '__dict__'))
        self.failUnless(hasattr(C, '__weakref__'))
        C().x = 2


class TestObject(TestCase):
    def test_objects(self):
        "Testing object class"
        a = object()
        self.assertEquals(a.__class__, object)
        self.assertEquals(type(a), object)
        b = object()
        self.failUnless(a is not b)
        self.failUnless(not hasattr(a, "foo"))
        try:
            a.foo = 12
        except (AttributeError, TypeError):
            pass
        else:
            self.failUnless(0, "object() should not allow setting a foo attribute")
        self.failUnless(not hasattr(object(), "__dict__"))

        class Cdict(object):
            pass
        x = Cdict()
        self.assertEquals(x.__dict__, {})
        x.foo = 1
        self.assertEquals(x.foo, 1)
        self.assertEquals(x.__dict__, {'foo': 1})


class TestSlots(TestCase):

    def test_slots(self):
        "Testing __slots__"
        class C0(object):
            __slots__ = []
        x = C0()
        self.failUnless(not hasattr(x, "__dict__"))
        self.failUnless(not hasattr(x, "foo"))

        class C1(object):
            __slots__ = ['a']
        x = C1()
        self.failUnless(not hasattr(x, "__dict__"))
        self.failUnless(not hasattr(x, "a"))
        x.a = 1
        self.assertEquals(x.a, 1)
        x.a = None
        self.assertIs(x.a, None)
        del x.a
        self.failUnless(not hasattr(x, "a"))

        class C3(object):
            __slots__ = ['a', 'b', 'c']
        x = C3()
        self.failUnless(not hasattr(x, "__dict__"))
        self.failUnless(not hasattr(x, 'a'))
        self.failUnless(not hasattr(x, 'b'))
        self.failUnless(not hasattr(x, 'c'))
        x.a = 1
        x.b = 2
        x.c = 3
        self.assertEquals(x.a, 1)
        self.assertEquals(x.b, 2)
        self.assertEquals(x.c, 3)

    def test_slot_mangling(self):
        class C4(object):
            """Validate name mangling"""
            __slots__ = ['__a']
            def __init__(self, value):
                self.__a = value
            def get(self):
                return self.__a
        x = C4(5)
        self.failUnless(not hasattr(x, '__dict__'))
        self.failUnless(not hasattr(x, '__a'))
        self.assertEquals(x.get(), 5)
        try:
            x.__a = 6
        except AttributeError:
            pass
        else:
            raise TestFailed, "Double underscored names not mangled"

    def test_slot_names(self):
        "Make sure slot names are proper identifiers"
        try:
            class C(object):
                __slots__ = [None]
        except TypeError:
            pass
        else:
            raise TestFailed, "[None] slots not caught"
        try:
            class C(object):
                __slots__ = ["foo bar"]
        except TypeError:
            pass
        else:
            raise TestFailed, "['foo bar'] slots not caught"
        try:
            class C(object):
                __slots__ = ["foo\0bar"]
        except TypeError:
            pass
        else:
            raise TestFailed, "['foo\\0bar'] slots not caught"
        try:
            class C(object):
                __slots__ = ["1"]
        except TypeError:
            pass
        else:
            raise TestFailed, "['1'] slots not caught"
        try:
            class C(object):
                __slots__ = [""]
        except TypeError:
            pass
        else:
            raise TestFailed, "[''] slots not caught"
        class C(object):
            __slots__ = ["a", "a_b", "_a", "A0123456789Z"]
        # XXX(nnorwitz): was there supposed to be something tested
        # from the class above?

    def test_single_string(self):
        "Test a single string is not expanded as a sequence"
        class C(object):
            __slots__ = "abc"
        c = C()
        c.abc = 5
        self.assertEquals(c.abc, 5)

    def test_unicode_slots(self):
        "Test unicode slot names"
        try:
            unicode
        except NameError:
            pass
        else:
            # Test a single unicode string is not expanded as a sequence.
            class C(object):
                __slots__ = unicode("abc")
            c = C()
            c.abc = 5
            self.assertEquals(c.abc, 5)

            # _unicode_to_string used to modify slots in certain circumstances
            slots = (unicode("foo"), unicode("bar"))
            class C(object):
                __slots__ = slots
            x = C()
            x.foo = 5
            self.assertEquals(x.foo, 5)
            self.assertIs(type(slots[0]), unicode)
            # this used to leak references
            try:
                class C(object):
                    __slots__ = [unichr(128)]
            except (TypeError, UnicodeEncodeError):
                pass
            else:
                raise TestFailed, "[unichr(128)] slots not caught"

    def test_leaks(self):

        # Test leaks
        class Counted(object):
            counter = 0    # counts the number of instances alive
            def __init__(self):
                Counted.counter += 1
            def __del__(self):
                Counted.counter -= 1
        class C(object):
            __slots__ = ['a', 'b', 'c']
        x = C()
        x.a = Counted()
        x.b = Counted()
        x.c = Counted()
        self.assertEquals(Counted.counter, 3)
        del x
        self.assertEquals(Counted.counter, 0)
        class D(C):
            pass
        x = D()
        x.a = Counted()
        x.z = Counted()
        self.assertEquals(Counted.counter, 2)
        del x
        self.assertEquals(Counted.counter, 0)
        class E(D):
            __slots__ = ['e']
        x = E()
        x.a = Counted()
        x.z = Counted()
        x.e = Counted()
        self.assertEquals(Counted.counter, 3)
        del x
        self.assertEquals(Counted.counter, 0)

        # Test cyclical leaks [SF bug 519621]
        class F(object):
            __slots__ = ['a', 'b']
        log = []
        s = F()
        s.a = [Counted(), s]
        self.assertEquals(Counted.counter, 1)
        s = None
        import gc
        gc.collect()
        self.assertEquals(Counted.counter, 0)

    def test_lookup_leaks(self):
        "Test lookup leaks [SF bug 572567]"
        import sys,gc
        class G(object):
            def __cmp__(self, other):
                return 0
        g = G()
        orig_objects = len(gc.get_objects())
        for i in xrange(10):
            g==g
        new_objects = len(gc.get_objects())
        self.assertEquals(orig_objects, new_objects)
        test = self
        class H(object):
            __slots__ = ['a', 'b']
            failed = False
            def __init__(self):
                self.a = 1
                self.b = 2
            def __del__(self):
                # no assertion in __del__! failures are always ignored.
                if not (self.a == 1 and self.b == 2):
                    H.failed = True

        save_stderr = sys.stderr
        sys.stderr = sys.stdout
        h = H()
        try:
            del h
        finally:
            sys.stderr = save_stderr
        self.failUnless(H.failed == False)

    def test_slotspecials(self):
        "Testing __dict__ and __weakref__ in __slots__"

        class D(object):
            __slots__ = ["__dict__"]
        a = D()
        self.failUnless(hasattr(a, "__dict__"))
        self.failUnless(not hasattr(a, "__weakref__"))
        a.foo = 42
        self.assertEquals(a.__dict__, {"foo": 42})

        class W(object):
            __slots__ = ["__weakref__"]
        a = W()
        self.failUnless(hasattr(a, "__weakref__"))
        self.failUnless(not hasattr(a, "__dict__"))
        try:
            a.foo = 42
        except AttributeError:
            pass
        else:
            raise TestFailed, "shouldn't be allowed to set a.foo"

        class C1(W, D):
            __slots__ = []
        a = C1()
        self.failUnless(hasattr(a, "__dict__"))
        self.failUnless(hasattr(a, "__weakref__"))
        a.foo = 42
        self.assertEquals(a.__dict__, {"foo": 42})

        class C2(D, W):
            __slots__ = []
        a = C2()
        self.failUnless(hasattr(a, "__dict__"))
        self.failUnless(hasattr(a, "__weakref__"))
        a.foo = 42
        self.assertEquals(a.__dict__, {"foo": 42})

    # MRO order disagreement
    #
    #    class C3(C1, C2):
    #        __slots__ = []
    #
    #    class C4(C2, C1):
    #        __slots__ = []


class TestAttributePropagation(TestCase):
    def test_dynamics(self):
        "Testing class attribute propagation"
        class D(object):
            pass
        class E(D):
            pass
        class F(D):
            pass
        D.foo = 1
        self.assertEquals(D.foo, 1)
        # Test that dynamic attributes are inherited
        self.assertEquals(E.foo, 1)
        self.assertEquals(F.foo, 1)
        # Test dynamic instances
        class C(object):
            pass
        a = C()
        self.failUnless(not hasattr(a, "foobar"))
        C.foobar = 2
        self.assertEquals(a.foobar, 2)
        C.method = lambda self: 42
        self.assertEquals(a.method(), 42)
        C.__repr__ = lambda self: "C()"
        self.assertEquals(repr(a), "C()")
        C.__int__ = lambda self: 100
        self.assertEquals(int(a), 100)
        self.assertEquals(a.foobar, 2)
        self.failUnless(not hasattr(a, "spam"))
        def mygetattr(self, name):
            if name == "spam":
                return "spam"
            raise AttributeError
        C.__getattr__ = mygetattr
        self.assertEquals(a.spam, "spam")
        a.new = 12
        self.assertEquals(a.new, 12)
        def mysetattr(self, name, value):
            if name == "spam":
                raise AttributeError
            return object.__setattr__(self, name, value)
        C.__setattr__ = mysetattr
        try:
            a.spam = "not spam"
        except AttributeError:
            pass
        else:
            self.failUnless(0, "expected AttributeError")
        self.assertEquals(a.spam, "spam")
        class D(C):
            pass
        d = D()
        d.foo = 1
        self.assertEquals(d.foo, 1)

        # Test handling of int*seq and seq*int
        class I(int):
            pass
        self.assertEquals("a"*I(2), "aa")
        self.assertEquals(I(2)*"a", "aa")
        self.assertEquals(2*I(3), 6)
        self.assertEquals(I(3)*2, 6)
        self.assertEquals(I(3)*I(2), 6)

        # Test handling of long*seq and seq*long
        class L(long):
            pass
        self.assertEquals("a"*L(2L), "aa")
        self.assertEquals(L(2L)*"a", "aa")
        self.assertEquals(2*L(3), 6)
        self.assertEquals(L(3)*2, 6)
        self.assertEquals(L(3)*L(2), 6)

        # Test comparison of classes with dynamic metaclasses
        class dynamicmetaclass(type):
            pass
        class someclass:
            __metaclass__ = dynamicmetaclass
        self.failUnless(someclass != object)

    def test_subclasspropagation(self):
        "Testing propagation of slot functions to subclasses"
        class A(object):
            pass
        class B(A):
            pass
        class C(A):
            pass
        class D(B, C):
            pass
        d = D()
        orig_hash = hash(d) # related to id(d) in platform-dependent ways
        A.__hash__ = lambda self: 42
        self.assertEquals(hash(d), 42)
        C.__hash__ = lambda self: 314
        self.assertEquals(hash(d), 314)
        B.__hash__ = lambda self: 144
        self.assertEquals(hash(d), 144)
        D.__hash__ = lambda self: 100
        self.assertEquals(hash(d), 100)
        del D.__hash__
        self.assertEquals(hash(d), 144)
        del B.__hash__
        self.assertEquals(hash(d), 314)
        del C.__hash__
        self.assertEquals(hash(d), 42)
        del A.__hash__
        self.assertEquals(hash(d), orig_hash)
        d.foo = 42
        d.bar = 42
        self.assertEquals(d.foo, 42)
        self.assertEquals(d.bar, 42)
        def __getattribute__(self, name):
            if name == "foo":
                return 24
            return object.__getattribute__(self, name)
        A.__getattribute__ = __getattribute__
        self.assertEquals(d.foo, 24)
        self.assertEquals(d.bar, 42)
        def __getattr__(self, name):
            if name in ("spam", "foo", "bar"):
                return "hello"
            raise AttributeError, name
        B.__getattr__ = __getattr__
        self.assertEquals(d.spam, "hello")
        self.assertEquals(d.foo, 24)
        self.assertEquals(d.bar, 42)
        del A.__getattribute__
        self.assertEquals(d.foo, 42)
        del d.foo
        self.assertEquals(d.foo, "hello")
        self.assertEquals(d.bar, 42)
        del B.__getattr__
        try:
            d.foo
        except AttributeError:
            pass
        else:
            raise TestFailed, "d.foo should be undefined now"

        # Test a nasty bug in recurse_down_subclasses()
        import gc
        class A(object):
            pass
        class B(A):
            pass
        del B
        gc.collect()
        A.__setitem__ = lambda *a: None # crash


class TestErrors(TestCase):
    def test_errors(self):
        "Testing errors"

        try:
            class C(list, dict):
                pass
        except TypeError:
            pass
        else:
            self.failUnless(0, "inheritance from both list and dict should be illegal")

        try:
            class C(object, None):
                pass
        except TypeError:
            pass
        else:
            self.failUnless(0, "inheritance from non-type should be illegal")
        class Classic:
            pass

        try:
            class C(type(len)):
                pass
        except TypeError:
            pass
        else:
            self.failUnless(0, "inheritance from CFunction should be illegal")

        try:
            class C(object):
                __slots__ = 1
        except TypeError:
            pass
        else:
            self.failUnless(0, "__slots__ = 1 should be illegal")

        try:
            class C(object):
                __slots__ = [1]
        except TypeError:
            pass
        else:
            self.failUnless(0, "__slots__ = [1] should be illegal")

        class M1(type):
            pass
        class M2(type):
            pass
        class A1(object):
            __metaclass__ = M1
        class A2(object):
            __metaclass__ = M2
        try:
            class B(A1, A2):
                pass
        except TypeError:
            pass
        else:
            self.failUnless(0, "finding the most derived metaclass should have failed")


class TestMethods(TestCase):
    def test_methods(self):
        "Testing methods"
        class C(object):
            def __init__(self, x):
                self.x = x
            def foo(self):
                return self.x
        c1 = C(1)
        self.assertEquals(c1.foo(), 1)
        class D(C):
            boo = C.foo
            goo = c1.foo
        d2 = D(2)
        self.assertEquals(d2.foo(), 2)
        self.assertEquals(d2.boo(), 2)
        self.assertEquals(d2.goo(), 1)
        class E(object):
            foo = C.foo
        self.assertEquals(E().foo, C.foo) # i.e., unbound
        self.failUnless(repr(C.foo.__get__(C(1))).startswith("<bound method "))

    def test_classmethods(self):
        "Testing class methods"
        class C(object):
            def foo(*a): return a
            goo = classmethod(foo)
        c = C()
        self.assertEquals(C.goo(1), (C, 1))
        self.assertEquals(c.goo(1), (C, 1))
        self.assertEquals(c.foo(1), (c, 1))
        class D(C):
            pass
        d = D()
        self.assertEquals(D.goo(1), (D, 1))
        self.assertEquals(d.goo(1), (D, 1))
        self.assertEquals(d.foo(1), (d, 1))
        self.assertEquals(D.foo(d, 1), (d, 1))
        # Test for a specific crash (SF bug 528132)
        def f(cls, arg): return (cls, arg)
        ff = classmethod(f)
        self.assertEquals(ff.__get__(0, int)(42), (int, 42))
        self.assertEquals(ff.__get__(0)(42), (int, 42))

        # Test super() with classmethods (SF bug 535444)
        self.assertIs(C.goo.im_self, C)
        self.assertIs(D.goo.im_self, D)
        self.assertIs(super(D,D).goo.im_self, D)
        self.assertIs(super(D,d).goo.im_self, D)
        self.assertEquals(super(D,D).goo(), (D,))
        self.assertEquals(super(D,d).goo(), (D,))

        # Verify that argument is checked for callability (SF bug 753451)
        try:
            classmethod(1).__get__(1)
        except TypeError:
            pass
        else:
            raise TestFailed, "classmethod should check for callability"

        # Verify that classmethod() doesn't allow keyword args
        try:
            classmethod(f, kw=1)
        except TypeError:
            pass
        else:
            raise TestFailed, "classmethod shouldn't accept keyword args"

    def test_classmethods_in_c(self):
        "Testing C-based class methods"
        import xxsubtype as spam
        a = (1, 2, 3)
        d = {'abc': 123}
        x, a1, d1 = spam.spamlist.classmeth(*a, **d)
        self.assertIs(x, spam.spamlist)
        self.assertEquals(a, a1)
        self.assertEquals(d, d1)
        x, a1, d1 = spam.spamlist().classmeth(*a, **d)
        self.assertIs(x, spam.spamlist)
        self.assertEquals(a, a1)
        self.assertEquals(d, d1)

    def test_staticmethods(self):
        "Testing static methods"
        class C(object):
            def foo(*a): return a
            goo = staticmethod(foo)
        c = C()
        self.assertEquals(C.goo(1), (1,))
        self.assertEquals(c.goo(1), (1,))
        self.assertEquals(c.foo(1), (c, 1,))
        class D(C):
            pass
        d = D()
        self.assertEquals(D.goo(1), (1,))
        self.assertEquals(d.goo(1), (1,))
        self.assertEquals(d.foo(1), (d, 1))
        self.assertEquals(D.foo(d, 1), (d, 1))

    def test_staticmethods_in_c(self):
        "Testing C-based static methods"
        import xxsubtype as spam
        a = (1, 2, 3)
        d = {"abc": 123}
        x, a1, d1 = spam.spamlist.staticmeth(*a, **d)
        self.assertIs(x, None)
        self.assertEquals(a, a1)
        self.assertEquals(d, d1)
        x, a1, d2 = spam.spamlist().staticmeth(*a, **d)
        self.assertIs(x, None)
        self.assertEquals(a, a1)
        self.assertEquals(d, d1)

    def test_methodwrapper(self):
        "Testing method-wrapper objects"
        # <type 'method-wrapper'> did not support any reflection before 2.5

        l = []
        self.assertEquals(l.__add__, l.__add__)
        self.assertEquals(l.__add__, [].__add__)
        self.failUnless(l.__add__ != [5].__add__)
        self.failUnless(l.__add__ != l.__mul__)
        self.failUnless(l.__add__.__name__ == '__add__')
        self.failUnless(l.__add__.__self__ is l)
        self.failUnless(l.__add__.__objclass__ is list)
        self.assertEquals(l.__add__.__doc__, list.__add__.__doc__)
        try:
            hash(l.__add__)
        except TypeError:
            pass
        else:
            raise TestFailed("no TypeError from hash([].__add__)")

        t = ()
        t += (7,)
        self.assertEquals(t.__add__, (7,).__add__)
        self.assertEquals(hash(t.__add__), hash((7,).__add__))


class TestClassicClasses(TestCase):
    def test_classic(self):
        "Testing classic classes"
        class C:
            def foo(*a): return a
            goo = classmethod(foo)
        c = C()
        self.assertEquals(C.goo(1), (C, 1))
        self.assertEquals(c.goo(1), (C, 1))
        self.assertEquals(c.foo(1), (c, 1))
        class D(C):
            pass
        d = D()
        self.assertEquals(D.goo(1), (D, 1))
        self.assertEquals(d.goo(1), (D, 1))
        self.assertEquals(d.foo(1), (d, 1))
        self.assertEquals(D.foo(d, 1), (d, 1))
        class E: # *not* subclassing from C
            foo = C.foo
        self.assertEquals(E().foo, C.foo) # i.e., unbound
        self.failUnless(repr(C.foo.__get__(C())).startswith("<bound method "))


class TestComputedAttributes(TestCase):
    def test_compattr(self):
        "Testing computed attributes"
        class C(object):
            class computed_attribute(object):
                def __init__(self, get, set=None, delete=None):
                    self.__get = get
                    self.__set = set
                    self.__delete = delete
                def __get__(self, obj, type=None):
                    return self.__get(obj)
                def __set__(self, obj, value):
                    return self.__set(obj, value)
                def __delete__(self, obj):
                    return self.__delete(obj)
            def __init__(self):
                self.__x = 0
            def __get_x(self):
                x = self.__x
                self.__x = x+1
                return x
            def __set_x(self, x):
                self.__x = x
            def __delete_x(self):
                del self.__x
            x = computed_attribute(__get_x, __set_x, __delete_x)
        a = C()
        self.assertEquals(a.x, 0)
        self.assertEquals(a.x, 1)
        a.x = 10
        self.assertEquals(a.x, 10)
        self.assertEquals(a.x, 11)
        del a.x
        self.assertEquals(hasattr(a, 'x'), 0)


class TestOverrides(TestCase):
    def test_newslot(self):
        "Testing __new__ slot override"
        class C(list):
            def __new__(cls):
                self = list.__new__(cls)
                self.foo = 1
                return self
            def __init__(self):
                self.foo = self.foo + 2
        a = C()
        self.assertEquals(a.foo, 3)
        self.failUnless(a.__class__ is C)
        class D(C):
            pass
        b = D()
        self.assertEquals(b.foo, 3)
        self.failUnless(b.__class__ is D)

    def test_altmro(self):
        "Testing mro() and overriding it"
        class A(object):
            def f(self): return "A"
        class B(A):
            pass
        class C(A):
            def f(self): return "C"
        class D(B, C):
            pass
        self.assertEquals(D.mro(), [D, B, C, A, object])
        self.assertEquals(D.__mro__, (D, B, C, A, object))
        self.assertEquals(D().f(), "C")

        class PerverseMetaType(type):
            def mro(cls):
                L = type.mro(cls)
                L.reverse()
                return L
        class X(D,B,C,A):
            __metaclass__ = PerverseMetaType
        self.assertEquals(X.__mro__, (object, A, C, B, D, X))
        self.assertEquals(X().f(), "A")

        try:
            class X(object):
                class __metaclass__(type):
                    def mro(self):
                        return [self, dict, object]
        except TypeError:
            pass
        else:
            raise TestFailed, "devious mro() return not caught"

        try:
            class X(object):
                class __metaclass__(type):
                    def mro(self):
                        return [1]
        except TypeError:
            pass
        else:
            raise TestFailed, "non-class mro() return not caught"

        try:
            class X(object):
                class __metaclass__(type):
                    def mro(self):
                        return 1
        except TypeError:
            pass
        else:
            raise TestFailed, "non-sequence mro() return not caught"


    def test_overloading(self):
        "Testing operator overloading"

        class B(object):
            "Intermediate class because object doesn't have a __setattr__"

        class C(B):

            def __getattr__(self, name):
                if name == "foo":
                    return ("getattr", name)
                else:
                    raise AttributeError
            def __setattr__(self, name, value):
                if name == "foo":
                    self.setattr = (name, value)
                else:
                    return B.__setattr__(self, name, value)
            def __delattr__(self, name):
                if name == "foo":
                    self.delattr = name
                else:
                    return B.__delattr__(self, name)

            def __getitem__(self, key):
                return ("getitem", key)
            def __setitem__(self, key, value):
                self.setitem = (key, value)
            def __delitem__(self, key):
                self.delitem = key

            def __getslice__(self, i, j):
                return ("getslice", i, j)
            def __setslice__(self, i, j, value):
                self.setslice = (i, j, value)
            def __delslice__(self, i, j):
                self.delslice = (i, j)

        a = C()
        self.assertEquals(a.foo, ("getattr", "foo"))
        a.foo = 12
        self.assertEquals(a.setattr, ("foo", 12))
        del a.foo
        self.assertEquals(a.delattr, "foo")

        self.assertEquals(a[12], ("getitem", 12))
        a[12] = 21
        self.assertEquals(a.setitem, (12, 21))
        del a[12]
        self.assertEquals(a.delitem, 12)

        self.assertEquals(a[0:10], ("getslice", 0, 10))
        a[0:10] = "foo"
        self.assertEquals(a.setslice, (0, 10, "foo"))
        del a[0:10]
        self.assertEquals(a.delslice, (0, 10))

    def test_binopoverride(self):
        "Testing overrides of binary operations"
        class I(int):
            def __repr__(self):
                return "I(%r)" % int(self)
            def __add__(self, other):
                return I(int(self) + int(other))
            __radd__ = __add__
            def __pow__(self, other, mod=None):
                if mod is None:
                    return I(pow(int(self), int(other)))
                else:
                    return I(pow(int(self), int(other), int(mod)))
            def __rpow__(self, other, mod=None):
                if mod is None:
                    return I(pow(int(other), int(self), mod))
                else:
                    return I(pow(int(other), int(self), int(mod)))

        self.assertEquals(repr(I(1) + I(2)), "I(3)")
        self.assertEquals(repr(I(1) + 2), "I(3)")
        self.assertEquals(repr(1 + I(2)), "I(3)")
        self.assertEquals(repr(I(2) ** I(3)), "I(8)")
        self.assertEquals(repr(2 ** I(3)), "I(8)")
        self.assertEquals(repr(I(2) ** 3), "I(8)")
        self.assertEquals(repr(pow(I(2), I(3), I(5))), "I(3)")
        class S(str):
            def __eq__(self, other):
                return self.lower() == other.lower()

    def test_slices(self):
        "Testing cases with slices and overridden __getitem__"
        # Strings
        self.assertEquals("hello"[:4], "hell")
        self.assertEquals("hello"[slice(4)], "hell")
        self.assertEquals(str.__getitem__("hello", slice(4)), "hell")
        class S(str):
            def __getitem__(self, x):
                return str.__getitem__(self, x)
        self.assertEquals(S("hello")[:4], "hell")
        self.assertEquals(S("hello")[slice(4)], "hell")
        self.assertEquals(S("hello").__getitem__(slice(4)), "hell")
        # Tuples
        self.assertEquals((1,2,3)[:2], (1,2))
        self.assertEquals((1,2,3)[slice(2)], (1,2))
        self.assertEquals(tuple.__getitem__((1,2,3), slice(2)), (1,2))
        class T(tuple):
            def __getitem__(self, x):
                return tuple.__getitem__(self, x)
        self.assertEquals(T((1,2,3))[:2], (1,2))
        self.assertEquals(T((1,2,3))[slice(2)], (1,2))
        self.assertEquals(T((1,2,3)).__getitem__(slice(2)), (1,2))
        # Lists
        self.assertEquals([1,2,3][:2], [1,2])
        self.assertEquals([1,2,3][slice(2)], [1,2])
        self.assertEquals(list.__getitem__([1,2,3], slice(2)), [1,2])
        class L(list):
            def __getitem__(self, x):
                return list.__getitem__(self, x)
        self.assertEquals(L([1,2,3])[:2], [1,2])
        self.assertEquals(L([1,2,3])[slice(2)], [1,2])
        self.assertEquals(L([1,2,3]).__getitem__(slice(2)), [1,2])
        # Now do lists and __setitem__
        a = L([1,2,3])
        a[slice(1, 3)] = [3,2]
        self.assertEquals(a, [1,3,2])
        a[slice(0, 2, 1)] = [3,1]
        self.assertEquals(a, [3,1,2])
        a.__setitem__(slice(1, 3), [2,1])
        self.assertEquals(a, [3,2,1])
        a.__setitem__(slice(0, 2, 1), [2,3])
        self.assertEquals(a, [2,3,1])

    def test_assign_slice(self):
        "Testing assign_slice"
        # ceval.c's assign_slice used to check for
        # tp->tp_as_sequence->sq_slice instead of
        # tp->tp_as_sequence->sq_ass_slice

        class C(object):
            def __setslice__(self, start, stop, value):
                self.value = value

        c = C()
        c[1:2] = 3
        self.assertEquals(c.value, 3)


class TestSpecialOperators(TestCase):
    def test_specials(self):
        "Testing special operators"
        # Test operators like __hash__ for which a built-in default exists
        # Test the default behavior for static classes
        class C(object):
            def __getitem__(self, i):
                if 0 <= i < 10: return i
                raise IndexError
        c1 = C()
        c2 = C()
        self.failUnless(not not c1)
        self.failUnless(id(c1) != id(c2))
        hash(c1)
        hash(c2)
        self.assertEquals(cmp(c1, c2), cmp(id(c1), id(c2)))
        self.assertEquals(c1, c1)
        self.failUnless(c1 != c2)
        self.failUnless(not c1 != c1)
        self.failUnless(not c1 == c2)
        # Note that the module name appears in str/repr, and that varies
        # depending on whether this test is run standalone or from a framework.
        self.failUnless(str(c1).find('C object at ') >= 0)
        self.assertEquals(str(c1), repr(c1))
        self.failUnless(-1 not in c1)
        for i in range(10):
            self.failUnless(i in c1)
        self.failUnless(10 not in c1)
        # Test the default behavior for dynamic classes
        class D(object):
            def __getitem__(self, i):
                if 0 <= i < 10: return i
                raise IndexError
        d1 = D()
        d2 = D()
        self.failUnless(not not d1)
        self.failUnless(id(d1) != id(d2))
        hash(d1)
        hash(d2)
        self.assertEquals(cmp(d1, d2), cmp(id(d1), id(d2)))
        self.assertEquals(d1, d1)
        self.failUnless(d1 != d2)
        self.failUnless(not d1 != d1)
        self.failUnless(not d1 == d2)
        # Note that the module name appears in str/repr, and that varies
        # depending on whether this test is run standalone or from a framework.
        self.failUnless(str(d1).find('D object at ') >= 0)
        self.assertEquals(str(d1), repr(d1))
        self.failUnless(-1 not in d1)
        for i in range(10):
            self.failUnless(i in d1)
        self.failUnless(10 not in d1)
        # Test overridden behavior for static classes
        class Proxy(object):
            def __init__(self, x):
                self.x = x
            def __nonzero__(self):
                return not not self.x
            def __hash__(self):
                return hash(self.x)
            def __eq__(self, other):
                return self.x == other
            def __ne__(self, other):
                return self.x != other
            def __cmp__(self, other):
                return cmp(self.x, other.x)
            def __str__(self):
                return "Proxy:%s" % self.x
            def __repr__(self):
                return "Proxy(%r)" % self.x
            def __contains__(self, value):
                return value in self.x
        p0 = Proxy(0)
        p1 = Proxy(1)
        p_1 = Proxy(-1)
        self.failUnless(not p0)
        self.failUnless(not not p1)
        self.assertEquals(hash(p0), hash(0))
        self.assertEquals(p0, p0)
        self.failUnless(p0 != p1)
        self.failUnless(not p0 != p0)
        self.assertEquals(not p0, p1)
        self.assertEquals(cmp(p0, p1), -1)
        self.assertEquals(cmp(p0, p0), 0)
        self.assertEquals(cmp(p0, p_1), 1)
        self.assertEquals(str(p0), "Proxy:0")
        self.assertEquals(repr(p0), "Proxy(0)")
        p10 = Proxy(range(10))
        self.failUnless(-1 not in p10)
        for i in range(10):
            self.failUnless(i in p10)
        self.failUnless(10 not in p10)
        # Test overridden behavior for dynamic classes
        class DProxy(object):
            def __init__(self, x):
                self.x = x
            def __nonzero__(self):
                return not not self.x
            def __hash__(self):
                return hash(self.x)
            def __eq__(self, other):
                return self.x == other
            def __ne__(self, other):
                return self.x != other
            def __cmp__(self, other):
                return cmp(self.x, other.x)
            def __str__(self):
                return "DProxy:%s" % self.x
            def __repr__(self):
                return "DProxy(%r)" % self.x
            def __contains__(self, value):
                return value in self.x
        p0 = DProxy(0)
        p1 = DProxy(1)
        p_1 = DProxy(-1)
        self.failUnless(not p0)
        self.failUnless(not not p1)
        self.assertEquals(hash(p0), hash(0))
        self.assertEquals(p0, p0)
        self.failUnless(p0 != p1)
        self.failUnless(not p0 != p0)
        self.assertEquals(not p0, p1)
        self.assertEquals(cmp(p0, p1), -1)
        self.assertEquals(cmp(p0, p0), 0)
        self.assertEquals(cmp(p0, p_1), 1)
        self.assertEquals(str(p0), "DProxy:0")
        self.assertEquals(repr(p0), "DProxy(0)")
        p10 = DProxy(range(10))
        self.failUnless(-1 not in p10)
        for i in range(10):
            self.failUnless(i in p10)
        self.failUnless(10 not in p10)
        # Safety test for __cmp__
        def unsafecmp(a, b):
            try:
                a.__class__.__cmp__(a, b)
            except TypeError:
                pass
            else:
                raise TestFailed, "shouldn't allow %s.__cmp__(%r, %r)" % (
                    a.__class__, a, b)
        unsafecmp(u"123", "123")
        unsafecmp("123", u"123")
        unsafecmp(1, 1.0)
        unsafecmp(1.0, 1)
        unsafecmp(1, 1L)
        unsafecmp(1L, 1)


class TestRecursions(TestCase):
    def test_recursions(self):
        "Testing recursion checks"

        class Letter(str):
            def __new__(cls, letter):
                if letter == 'EPS':
                    return str.__new__(cls)
                return str.__new__(cls, letter)
            def __str__(self):
                if not self:
                    return 'EPS'
                return self
        # sys.stdout needs to be the original to trigger the recursion bug
        import sys
        test_stdout = sys.stdout
        sys.stdout = get_original_stdout()
        try:
            # nothing should actually be printed, this should raise an exception
            print Letter('w')
        except RuntimeError:
            pass
        else:
            raise TestFailed, "expected a RuntimeError for print recursion"
        sys.stdout = test_stdout

        # Bug #1202533.
        class A(object):
            pass
        A.__mul__ = types.MethodType(lambda self, x: self * x, None, A)
        try:
            A()*2
        except RuntimeError:
            pass
        else:
            raise TestFailed("expected a RuntimeError")

    def test_recursive__call__(self):
        "Testing recursive __call__() by setting to instance of class"
        class A(object):
            pass

        A.__call__ = A()
        try:
            A()()
        except RuntimeError:
            pass
        else:
            raise TestFailed("Recursion limit should have been reached for "
                             "__call__()")


class TestWeakrefs(TestCase):
    def test_weakrefs(self):
        "Testing weak references"
        import weakref
        class C(object):
            pass
        c = C()
        r = weakref.ref(c)
        self.failUnless(r() is c)
        del c
        self.failUnless(r() is None)
        del r
        class NoWeak(object):
            __slots__ = ['foo']
        no = NoWeak()
        try:
            weakref.ref(no)
        except TypeError, msg:
            self.failUnless(str(msg).find("weak reference") >= 0)
        else:
            self.failUnless(0, "weakref.ref(no) should be illegal")
        class Weak(object):
            __slots__ = ['foo', '__weakref__']
        yes = Weak()
        r = weakref.ref(yes)
        self.failUnless(r() is yes)
        del yes
        self.failUnless(r() is None)
        del r


class TestProperties(TestCase):
    def test_property(self):
        "Testing property"
        class C(object):
            def getx(self):
                return self.__x
            def setx(self, value):
                self.__x = value
            def delx(self):
                del self.__x
            x = property(getx, setx, delx, doc="I'm the x property.")
        a = C()
        self.failUnless(not hasattr(a, "x"))
        a.x = 42
        self.assertEquals(a._C__x, 42)
        self.assertEquals(a.x, 42)
        del a.x
        self.failUnless(not hasattr(a, "x"))
        self.failUnless(not hasattr(a, "_C__x"))
        C.x.__set__(a, 100)
        self.assertEquals(C.x.__get__(a), 100)
        C.x.__delete__(a)
        self.failUnless(not hasattr(a, "x"))

        raw = C.__dict__['x']
        self.failUnless(isinstance(raw, property))

        attrs = dir(raw)
        self.failUnless("__doc__" in attrs)
        self.failUnless("fget" in attrs)
        self.failUnless("fset" in attrs)
        self.failUnless("fdel" in attrs)

        self.assertEquals(raw.__doc__, "I'm the x property.")
        self.failUnless(raw.fget is C.__dict__['getx'])
        self.failUnless(raw.fset is C.__dict__['setx'])
        self.failUnless(raw.fdel is C.__dict__['delx'])

        for attr in "__doc__", "fget", "fset", "fdel":
            try:
                setattr(raw, attr, 42)
            except TypeError, msg:
                if str(msg).find('readonly') < 0:
                    raise TestFailed("when setting readonly attr %r on a "
                                     "property, got unexpected TypeError "
                                     "msg %r" % (attr, str(msg)))
            else:
                raise TestFailed("expected TypeError from trying to set "
                                 "readonly %r attr on a property" % attr)

        class D(object):
            __getitem__ = property(lambda s: 1/0)

        d = D()
        try:
            for i in d:
                str(i)
        except ZeroDivisionError:
            pass
        else:
            raise TestFailed, "expected ZeroDivisionError from bad property"

        class E(object):
            def getter(self):
                "getter method"
                return 0
            def setter(self, value):
                "setter method"
                pass
            prop = property(getter)
            self.assertEquals(prop.__doc__, "getter method")
            prop2 = property(fset=setter)
            self.assertEquals(prop2.__doc__, None)

        # this segfaulted in 2.5b2
        try:
            import _testcapi
        except ImportError:
            pass
        else:
            class X(object):
                p = property(_testcapi.test_with_docstring)

    def test_properties_plus(self):
        class C(object):
            foo = property(doc="hello")
            @foo.getter
            def foo(self):
                return self._foo
            @foo.setter
            def foo(self, value):
                self._foo = abs(value)
            @foo.deleter
            def foo(self):
                del self._foo
        c = C()
        self.assertEqual(C.foo.__doc__, "hello")
        self.failIf(hasattr(c, "foo"))
        c.foo = -42
        self.assertTrue(hasattr(c, '_foo'))
        self.assertEqual(c._foo, 42)
        self.assertEqual(c.foo, 42)
        del c.foo
        self.failIf(hasattr(c, '_foo'))
        self.failIf(hasattr(c, 'xfoo'))

        class D(C):
            @C.foo.deleter
            def foo(self):
                try:
                    del self._foo
                except AttributeError:
                    pass
        d = D()
        d.foo = 24
        self.assertEqual(d.foo, 24)
        del d.foo
        del d.foo

        class E(object):
            @property
            def foo(self):
                return self._foo
            @foo.setter
            def foo(self, value):
                raise RuntimeError
            @foo.setter
            def foo(self, value):
                self._foo = abs(value)
            @foo.deleter
            def foo(self, value=None):
                del self._foo

        e = E()
        e.foo = -42
        self.assertEqual(e.foo, 42)
        del e.foo

        class F(E):
            @E.foo.deleter
            def foo(self):
                del self._foo
            @foo.setter
            def foo(self, value):
                self._foo = max(0, value)
        f = F()
        f.foo = -10
        self.assertEqual(f.foo, 0)
        del f.foo


class TestSuper(TestCase):
    def test_supers(self):
        "Testing super"

        class A(object):
            def meth(self, a):
                return "A(%r)" % a

        self.assertEquals(A().meth(1), "A(1)")

        class B(A):
            def __init__(self):
                self.__super = super(B, self)
            def meth(self, a):
                return "B(%r)" % a + self.__super.meth(a)

        self.assertEquals(B().meth(2), "B(2)A(2)")

        class C(A):
            def meth(self, a):
                return "C(%r)" % a + self.__super.meth(a)
        C._C__super = super(C)

        self.assertEquals(C().meth(3), "C(3)A(3)")

        class D(C, B):
            def meth(self, a):
                return "D(%r)" % a + super(D, self).meth(a)

        self.assertEquals(D().meth(4), "D(4)C(4)B(4)A(4)")

        # Test for subclassing super

        class mysuper(super):
            def __init__(self, *args):
                return super(mysuper, self).__init__(*args)

        class E(D):
            def meth(self, a):
                return "E(%r)" % a + mysuper(E, self).meth(a)

        self.assertEquals(E().meth(5), "E(5)D(5)C(5)B(5)A(5)")

        class F(E):
            def meth(self, a):
                s = self.__super # == mysuper(F, self)
                return "F(%r)[%s]" % (a, s.__class__.__name__) + s.meth(a)
        F._F__super = mysuper(F)

        self.assertEquals(F().meth(6), "F(6)[mysuper]E(6)D(6)C(6)B(6)A(6)")

        # Make sure certain errors are raised

        try:
            super(D, 42)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't allow super(D, 42)"

        try:
            super(D, C())
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't allow super(D, C())"

        try:
            super(D).__get__(12)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't allow super(D).__get__(12)"

        try:
            super(D).__get__(C())
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't allow super(D).__get__(C())"

        # Make sure data descriptors can be overridden and accessed via super
        # (new feature in Python 2.3)

        class DDbase(object):
            def getx(self): return 42
            x = property(getx)

        class DDsub(DDbase):
            def getx(self): return "hello"
            x = property(getx)

        dd = DDsub()
        self.assertEquals(dd.x, "hello")
        self.assertEquals(super(DDsub, dd).x, 42)

        # Ensure that super() lookup of descriptor from classmethod
        # works (SF ID# 743627)

        class Base(object):
            aProp = property(lambda self: "foo")

        class Sub(Base):
            @classmethod
            def test(klass):
                return super(Sub,klass).aProp

        self.assertIs(Sub.test(), Base.aProp)

        # Verify that super() doesn't allow keyword args
        try:
            super(Base, kw=1)
        except TypeError:
            pass
        else:
            raise TestFailed, "super shouldn't accept keyword args"


class TestKeywords(TestCase):
    def test_constructor_keywords(self):
        "Testing keyword args to basic type constructors"
        self.assertEquals(int(x=1), 1)
        self.assertEquals(float(x=2), 2.0)
        self.assertEquals(long(x=3), 3L)
        self.assertEquals(complex(imag=42, real=666), complex(666, 42))
        self.assertEquals(str(object=500), '500')
        self.assertEquals(unicode(string='abc', errors='strict'), u'abc')
        self.assertEquals(tuple(sequence=range(3)), (0, 1, 2))
        self.assertEquals(list(sequence=(0, 1, 2)), range(3))
        # note: as of Python 2.3, dict() no longer has an "items" keyword arg

        for constructor in (int, float, long, complex, str, unicode,
                            tuple, list, file):
            try:
                constructor(bogus_keyword_arg=1)
            except TypeError:
                pass
            else:
                raise TestFailed("expected TypeError from bogus keyword "
                                 "argument to %r" % constructor)

    def test_kwdargs(self):
        "Testing keyword arguments to __init__, __call__"
        def f(a): return a
        self.assertEquals(f.__call__(a=42), 42)
        a = []
        list.__init__(a, sequence=[0, 1, 2])
        self.assertEquals(a, [0, 1, 2])


class TestRexec(TestCase):
    def do_not_test_restricted(self):
        # XXX This test is disabled because rexec is not deemed safe
        return
        "Testing interaction with restricted execution"
        import rexec

        sandbox = rexec.RExec()

        code1 = """f = open(%r, 'w')""" % TESTFN
        code2 = """f = file(%r, 'w')""" % TESTFN
        code3 = """\
    f = open(%r)
    t = type(f)  # a sneaky way to get the file() constructor
    f.close()
    f = t(%r, 'w')  # rexec can't catch this by itself
    """ % (TESTFN, TESTFN)

        f = open(TESTFN, 'w')  # Create the file so code3 can find it.
        f.close()

        try:
            for code in code1, code2, code3:
                try:
                    sandbox.r_exec(code)
                except IOError, msg:
                    if str(msg).find("restricted") >= 0:
                        outcome = "OK"
                    else:
                        outcome = "got an exception, but not an expected one"
                else:
                    outcome = "expected a restricted-execution exception"

                if outcome != "OK":
                    raise TestFailed("%s, in %r" % (outcome, code))

        finally:
            try:
                import os
                os.unlink(TESTFN)
            except:
                pass


class TestComparisons(TestCase):
    def test_classic_comparisons(self):
        "Testing classic comparisons"
        class classic:
            pass
        for base in (classic, int, object):
            #if verbose: print "        (base = %s)" % base
            class C(base):
                def __init__(self, value):
                    self.value = int(value)
                def __cmp__(self, other):
                    if isinstance(other, C):
                        return cmp(self.value, other.value)
                    if isinstance(other, int) or isinstance(other, long):
                        return cmp(self.value, other)
                    return NotImplemented
            c1 = C(1)
            c2 = C(2)
            c3 = C(3)
            self.assertEquals(c1, 1)
            c = {1: c1, 2: c2, 3: c3}
            for x in 1, 2, 3:
                for y in 1, 2, 3:
                    self.failUnless(cmp(c[x], c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))
                    for op in "<", "<=", "==", "!=", ">", ">=":
                        self.failUnless(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),
                               "x=%d, y=%d" % (x, y))
                    self.failUnless(cmp(c[x], y) == cmp(x, y), "x=%d, y=%d" % (x, y))
                    self.failUnless(cmp(x, c[y]) == cmp(x, y), "x=%d, y=%d" % (x, y))

    def test_rich_comparisons(self):
        "Testing rich comparisons"
        class Z(complex):
            pass
        z = Z(1)
        self.assertEquals(z, 1+0j)
        self.assertEquals(1+0j, z)
        class ZZ(complex):
            def __eq__(self, other):
                try:
                    return abs(self - other) <= 1e-6
                except:
                    return NotImplemented
        zz = ZZ(1.0000003)
        self.assertEquals(zz, 1+0j)
        self.assertEquals(1+0j, zz)

        class classic:
            pass
        for base in (classic, int, object, list):
            #if verbose: print "        (base = %s)" % base
            class C(base):
                def __init__(self, value):
                    self.value = int(value)
                def __cmp__(self, other):
                    raise TestFailed, "shouldn't call __cmp__"
                def __eq__(self, other):
                    if isinstance(other, C):
                        return self.value == other.value
                    if isinstance(other, int) or isinstance(other, long):
                        return self.value == other
                    return NotImplemented
                def __ne__(self, other):
                    if isinstance(other, C):
                        return self.value != other.value
                    if isinstance(other, int) or isinstance(other, long):
                        return self.value != other
                    return NotImplemented
                def __lt__(self, other):
                    if isinstance(other, C):
                        return self.value < other.value
                    if isinstance(other, int) or isinstance(other, long):
                        return self.value < other
                    return NotImplemented
                def __le__(self, other):
                    if isinstance(other, C):
                        return self.value <= other.value
                    if isinstance(other, int) or isinstance(other, long):
                        return self.value <= other
                    return NotImplemented
                def __gt__(self, other):
                    if isinstance(other, C):
                        return self.value > other.value
                    if isinstance(other, int) or isinstance(other, long):
                        return self.value > other
                    return NotImplemented
                def __ge__(self, other):
                    if isinstance(other, C):
                        return self.value >= other.value
                    if isinstance(other, int) or isinstance(other, long):
                        return self.value >= other
                    return NotImplemented
            c1 = C(1)
            c2 = C(2)
            c3 = C(3)
            self.assertEquals(c1, 1)
            c = {1: c1, 2: c2, 3: c3}
            for x in 1, 2, 3:
                for y in 1, 2, 3:
                    for op in "<", "<=", "==", "!=", ">", ">=":
                        self.failUnless(eval("c[x] %s c[y]" % op) == eval("x %s y" % op),
                               "x=%d, y=%d" % (x, y))
                        self.failUnless(eval("c[x] %s y" % op) == eval("x %s y" % op),
                               "x=%d, y=%d" % (x, y))
                        self.failUnless(eval("x %s c[y]" % op) == eval("x %s y" % op),
                               "x=%d, y=%d" % (x, y))


class TestClassChange(TestCase):
    def test_setclass(self):
        "Testing __class__ assignment"
        class C(object): pass
        class D(object): pass
        class E(object): pass
        class F(D, E): pass
        for cls in C, D, E, F:
            for cls2 in C, D, E, F:
                x = cls()
                x.__class__ = cls2
                self.failUnless(x.__class__ is cls2)
                x.__class__ = cls
                self.failUnless(x.__class__ is cls)
        def cant(x, C):
            try:
                x.__class__ = C
            except TypeError:
                pass
            else:
                raise TestFailed, "shouldn't allow %r.__class__ = %r" % (x, C)
            try:
                delattr(x, "__class__")
            except TypeError:
                pass
            else:
                raise TestFailed, "shouldn't allow del %r.__class__" % x
        cant(C(), list)
        cant(list(), C)
        cant(C(), 1)
        cant(C(), object)
        cant(object(), list)
        cant(list(), object)
        class Int(int): __slots__ = []
        cant(2, Int)
        cant(Int(), int)
        cant(True, int)
        cant(2, bool)
        o = object()
        cant(o, type(1))
        cant(o, type(None))
        del o
        class G(object):
            __slots__ = ["a", "b"]
        class H(object):
            __slots__ = ["b", "a"]
        try:
            unicode
        except NameError:
            class I(object):
                __slots__ = ["a", "b"]
        else:
            class I(object):
                __slots__ = [unicode("a"), unicode("b")]
        class J(object):
            __slots__ = ["c", "b"]
        class K(object):
            __slots__ = ["a", "b", "d"]
        class L(H):
            __slots__ = ["e"]
        class M(I):
            __slots__ = ["e"]
        class N(J):
            __slots__ = ["__weakref__"]
        class P(J):
            __slots__ = ["__dict__"]
        class Q(J):
            pass
        class R(J):
            __slots__ = ["__dict__", "__weakref__"]

        for cls, cls2 in ((G, H), (G, I), (I, H), (Q, R), (R, Q)):
            x = cls()
            x.a = 1
            x.__class__ = cls2
            self.failUnless(x.__class__ is cls2,
                   "assigning %r as __class__ for %r silently failed" % (cls2, x))
            self.assertEquals(x.a, 1)
            x.__class__ = cls
            self.failUnless(x.__class__ is cls,
                   "assigning %r as __class__ for %r silently failed" % (cls, x))
            self.assertEquals(x.a, 1)
        for cls in G, J, K, L, M, N, P, R, list, Int:
            for cls2 in G, J, K, L, M, N, P, R, list, Int:
                if cls is cls2:
                    continue
                cant(cls(), cls2)

    def test_setdict(self):
        "Testing __dict__ assignment"
        class C(object): pass
        a = C()
        a.__dict__ = {'b': 1}
        self.assertEquals(a.b, 1)
        def cant(x, dict):
            try:
                x.__dict__ = dict
            except (AttributeError, TypeError):
                pass
            else:
                raise TestFailed, "shouldn't allow %r.__dict__ = %r" % (x, dict)
        cant(a, None)
        cant(a, [])
        cant(a, 1)
        del a.__dict__ # Deleting __dict__ is allowed

        class Base(object):
            pass
        def verify_dict_readonly(x):
            """
            x has to be an instance of a class inheriting from Base.
            """
            cant(x, {})
            try:
                del x.__dict__
            except (AttributeError, TypeError):
                pass
            else:
                raise TestFailed, "shouldn't allow del %r.__dict__" % x
            dict_descr = Base.__dict__["__dict__"]
            try:
                dict_descr.__set__(x, {})
            except (AttributeError, TypeError):
                pass
            else:
                raise TestFailed, "dict_descr allowed access to %r's dict" % x

        # Classes don't allow __dict__ assignment and have readonly dicts
        class Meta1(type, Base):
            pass
        class Meta2(Base, type):
            pass
        class D(object):
            __metaclass__ = Meta1
        class E(object):
            __metaclass__ = Meta2
        for cls in C, D, E:
            verify_dict_readonly(cls)
            class_dict = cls.__dict__
            try:
                class_dict["spam"] = "eggs"
            except TypeError:
                pass
            else:
                raise TestFailed, "%r's __dict__ can be modified" % cls

        # Modules also disallow __dict__ assignment
        class Module1(types.ModuleType, Base):
            pass
        class Module2(Base, types.ModuleType):
            pass
        for ModuleType in Module1, Module2:
            mod = ModuleType("spam")
            verify_dict_readonly(mod)
            mod.__dict__["spam"] = "eggs"

        # Exception's __dict__ can be replaced, but not deleted
        class Exception1(Exception, Base):
            pass
        class Exception2(Base, Exception):
            pass
        for ExceptionType in Exception, Exception1, Exception2:
            e = ExceptionType()
            e.__dict__ = {"a": 1}
            self.assertEquals(e.a, 1)
            try:
                del e.__dict__
            except (TypeError, AttributeError):
                pass
            else:
                raise TestFaied, "%r's __dict__ can be deleted" % e

    def test_mutable_bases(self):
        "Testing mutable bases"
        # stuff that should work:
        class C(object):
            pass
        class C2(object):
            def __getattribute__(self, attr):
                if attr == 'a':
                    return 2
                else:
                    return super(C2, self).__getattribute__(attr)
            def meth(self):
                return 1
        class D(C):
            pass
        class E(D):
            pass
        d = D()
        e = E()
        D.__bases__ = (C,)
        D.__bases__ = (C2,)
        self.assertEquals(d.meth(), 1)
        self.assertEquals(e.meth(), 1)
        self.assertEquals(d.a, 2)
        self.assertEquals(e.a, 2)
        self.assertEquals(C2.__subclasses__(), [D])

        # stuff that shouldn't:
        class L(list):
            pass

        try:
            L.__bases__ = (dict,)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't turn list subclass into dict subclass"

        try:
            list.__bases__ = (dict,)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't be able to assign to list.__bases__"

        try:
            D.__bases__ = (C2, list)
        except TypeError:
            pass
        else:
            raise TestFailed, "best_base calculation found wanting"

        try:
            del D.__bases__
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't be able to delete .__bases__"

        try:
            D.__bases__ = ()
        except TypeError, msg:
            if str(msg) == "a new-style class can't have only classic bases":
                raise TestFailed, "wrong error message for .__bases__ = ()"
        else:
            raise TestFailed, "shouldn't be able to set .__bases__ to ()"

        try:
            D.__bases__ = (D,)
        except TypeError:
            pass
        else:
            # actually, we'll have crashed by here...
            raise TestFailed, "shouldn't be able to create inheritance cycles"

        try:
            D.__bases__ = (C, C)
        except TypeError:
            pass
        else:
            raise TestFailed, "didn't detect repeated base classes"

        try:
            D.__bases__ = (E,)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't be able to create inheritance cycles"

        # let's throw a classic class into the mix:
        class Classic:
            def meth2(self):
                return 3

        D.__bases__ = (C, Classic)

        self.assertEquals(d.meth2(), 3)
        self.assertEquals(e.meth2(), 3)
        try:
            d.a
        except AttributeError:
            pass
        else:
            raise TestFailed, "attribute should have vanished"

        try:
            D.__bases__ = (Classic,)
        except TypeError:
            pass
        else:
            raise TestFailed, "new-style class must have a new-style base"

    def test_mutable_bases_with_failing_mro(self):
        "Testing mutable bases with failing mro"
        class WorkOnce(type):
            def __new__(self, name, bases, ns):
                self.flag = 0
                return super(WorkOnce, self).__new__(WorkOnce, name, bases, ns)
            def mro(self):
                if self.flag > 0:
                    raise RuntimeError, "bozo"
                else:
                    self.flag += 1
                    return type.mro(self)

        class WorkAlways(type):
            def mro(self):
                # this is here to make sure that .mro()s aren't called
                # with an exception set (which was possible at one point).
                # An error message will be printed in a debug build.
                # What's a good way to test for this?
                return type.mro(self)

        class C(object):
            pass

        class C2(object):
            pass

        class D(C):
            pass

        class E(D):
            pass

        class F(D):
            __metaclass__ = WorkOnce

        class G(D):
            __metaclass__ = WorkAlways

        # Immediate subclasses have their mro's adjusted in alphabetical
        # order, so E's will get adjusted before adjusting F's fails.  We
        # check here that E's gets restored.

        E_mro_before = E.__mro__
        D_mro_before = D.__mro__

        try:
            D.__bases__ = (C2,)
        except RuntimeError:
            self.assertEquals(E.__mro__, E_mro_before)
            self.assertEquals(D.__mro__, D_mro_before)
        else:
            raise TestFailed, "exception not propagated"

    def test_mutable_bases_catch_mro_conflict(self):
        "Testing mutable bases catch mro conflict"
        class A(object):
            pass

        class B(object):
            pass

        class C(A, B):
            pass

        class D(A, B):
            pass

        class E(C, D):
            pass

        try:
            C.__bases__ = (B, A)
        except TypeError:
            pass
        else:
            raise TestFailed, "didn't catch MRO conflict"

    def test_mutable_names(self):
        "Testing mutable namesx"
        class C(object):
            pass

        # C.__module__ could be 'test_descr' or '__main__'
        mod = C.__module__

        C.__name__ = 'D'
        self.assertEquals((C.__module__, C.__name__), (mod, 'D'))

        C.__name__ = 'D.E'
        self.assertEquals((C.__module__, C.__name__), (mod, 'D.E'))



class TestCopy(TestCase):
    def test_pickles(self):
        "Testing pickling and copying new-style classes and objects"
        import pickle, cPickle

        def sorteditems(d):
            L = d.items()
            L.sort()
            return L

        global C
        class C(object):
            def __init__(self, a, b):
                super(C, self).__init__()
                self.a = a
                self.b = b
            def __repr__(self):
                return "C(%r, %r)" % (self.a, self.b)

        global C1
        class C1(list):
            def __new__(cls, a, b):
                return super(C1, cls).__new__(cls)
            def __getnewargs__(self):
                return (self.a, self.b)
            def __init__(self, a, b):
                self.a = a
                self.b = b
            def __repr__(self):
                return "C1(%r, %r)<%r>" % (self.a, self.b, list(self))

        global C2
        class C2(int):
            def __new__(cls, a, b, val=0):
                return super(C2, cls).__new__(cls, val)
            def __getnewargs__(self):
                return (self.a, self.b, int(self))
            def __init__(self, a, b, val=0):
                self.a = a
                self.b = b
            def __repr__(self):
                return "C2(%r, %r)<%r>" % (self.a, self.b, int(self))

        global C3
        class C3(object):
            def __init__(self, foo):
                self.foo = foo
            def __getstate__(self):
                return self.foo
            def __setstate__(self, foo):
                self.foo = foo

        global C4classic, C4
        class C4classic: # classic
            pass
        class C4(C4classic, object): # mixed inheritance
            pass

        for p in pickle, cPickle:
            for bin in 0, 1:
                #if verbose: print p.__name__, ["text", "binary"][bin]

                for cls in C, C1, C2:
                    s = p.dumps(cls, bin)
                    cls2 = p.loads(s)
                    self.failUnless(cls2 is cls)

                a = C1(1, 2); a.append(42); a.append(24)
                b = C2("hello", "world", 42)
                s = p.dumps((a, b), bin)
                x, y = p.loads(s)
                self.assertEquals(x.__class__, a.__class__)
                self.assertEquals(sorteditems(x.__dict__), sorteditems(a.__dict__))
                self.assertEquals(y.__class__, b.__class__)
                self.assertEquals(sorteditems(y.__dict__), sorteditems(b.__dict__))
                self.assertEquals(repr(x), repr(a))
                self.assertEquals(repr(y), repr(b))
                #if verbose:
                #    print "a = x =", a
                #    print "b = y =", b
                # Test for __getstate__ and __setstate__ on new style class
                u = C3(42)
                s = p.dumps(u, bin)
                v = p.loads(s)
                self.assertIs(u.__class__, v.__class__)
                self.assertEquals(u.foo, v.foo)
                # Test for picklability of hybrid class
                u = C4()
                u.foo = 42
                s = p.dumps(u, bin)
                v = p.loads(s)
                self.assertIs(u.__class__, v.__class__)
                self.assertEquals(u.foo, v.foo)

        # Testing copy.deepcopy()
        # if verbose: print "deepcopy"
        import copy
        for cls in C, C1, C2:
            cls2 = copy.deepcopy(cls)
            self.failUnless(cls2 is cls)

        a = C1(1, 2); a.append(42); a.append(24)
        b = C2("hello", "world", 42)
        x, y = copy.deepcopy((a, b))
        self.assertEquals(x.__class__, a.__class__)
        self.assertEquals(sorteditems(x.__dict__), sorteditems(a.__dict__))
        self.assertEquals(y.__class__, b.__class__)
        self.assertEquals(sorteditems(y.__dict__), sorteditems(b.__dict__))
        self.assertEquals(repr(x), repr(a))
        self.assertEquals(repr(y), repr(b))
        # if verbose:
        #     print "a = x =", a
        #     print "b = y =", b

    def test_pickleslots(self):
        "Testing pickling of classes with __slots__"
        import pickle, cPickle
        # Pickling of classes with __slots__ but without __getstate__ should fail
        global B, C, D, E
        class B(object):
            pass
        for base in [object, B]:
            class C(base):
                __slots__ = ['a']
            class D(C):
                pass
            try:
                pickle.dumps(C())
            except TypeError:
                pass
            else:
                raise TestFailed, "should fail: pickle C instance - %s" % base
            try:
                cPickle.dumps(C())
            except TypeError:
                pass
            else:
                raise TestFailed, "should fail: cPickle C instance - %s" % base
            try:
                pickle.dumps(C())
            except TypeError:
                pass
            else:
                raise TestFailed, "should fail: pickle D instance - %s" % base
            try:
                cPickle.dumps(D())
            except TypeError:
                pass
            else:
                raise TestFailed, "should fail: cPickle D instance - %s" % base
            # Give C a nice generic __getstate__ and __setstate__
            class C(base):
                __slots__ = ['a']
                def __getstate__(self):
                    try:
                        d = self.__dict__.copy()
                    except AttributeError:
                        d = {}
                    for cls in self.__class__.__mro__:
                        for sn in cls.__dict__.get('__slots__', ()):
                            try:
                                d[sn] = getattr(self, sn)
                            except AttributeError:
                                pass
                    return d
                def __setstate__(self, d):
                    for k, v in d.items():
                        setattr(self, k, v)
            class D(C):
                pass
            # Now it should work
            x = C()
            y = pickle.loads(pickle.dumps(x))
            self.assertEquals(hasattr(y, 'a'), 0)
            y = cPickle.loads(cPickle.dumps(x))
            self.assertEquals(hasattr(y, 'a'), 0)
            x.a = 42
            y = pickle.loads(pickle.dumps(x))
            self.assertEquals(y.a, 42)
            y = cPickle.loads(cPickle.dumps(x))
            self.assertEquals(y.a, 42)
            x = D()
            x.a = 42
            x.b = 100
            y = pickle.loads(pickle.dumps(x))
            self.assertEquals(y.a + y.b, 142)
            y = cPickle.loads(cPickle.dumps(x))
            self.assertEquals(y.a + y.b, 142)
            # A subclass that adds a slot should also work
            class E(C):
                __slots__ = ['b']
            x = E()
            x.a = 42
            x.b = "foo"
            y = pickle.loads(pickle.dumps(x))
            self.assertEquals(y.a, x.a)
            self.assertEquals(y.b, x.b)
            y = cPickle.loads(cPickle.dumps(x))
            self.assertEquals(y.a, x.a)
            self.assertEquals(y.b, x.b)

    def test_copies(self):
        "Testing copy.copy() and copy.deepcopy()"
        import copy
        class C(object):
            pass

        a = C()
        a.foo = 12
        b = copy.copy(a)
        self.assertEquals(b.__dict__, a.__dict__)

        a.bar = [1,2,3]
        c = copy.copy(a)
        self.assertEquals(c.bar, a.bar)
        self.failUnless(c.bar is a.bar)

        d = copy.deepcopy(a)
        self.assertEquals(d.__dict__, a.__dict__)
        a.bar.append(4)
        self.assertEquals(d.bar, [1,2,3])

    def test_deepcopyrecursive(self):
        "Testing deepcopy of recursive objects"
        class Node:
            pass
        a = Node()
        b = Node()
        a.b = b
        b.a = a
        z = deepcopy(a) # This blew up before

    def test_copy_setstate(self):
        "Testing that copy.*copy() correctly uses __setstate__"
        import copy
        test = self
        class C(object):
            def __init__(self, foo=None):
                self.foo = foo
                self.__foo = foo
            def setfoo(self, foo=None):
                self.foo = foo
            def getfoo(self):
                return self.__foo
            def __getstate__(self):
                return [self.foo]
            def __setstate__(self, lst):
                test.assertEqual(len(lst), 1)
                self.__foo = self.foo = lst[0]
        a = C(42)
        a.setfoo(24)
        self.assertEquals(a.foo, 24)
        self.assertEquals(a.getfoo(), 42)
        b = copy.copy(a)
        self.assertEquals(b.foo, 24)
        self.assertEquals(b.getfoo(), 24)
        b = copy.deepcopy(a)
        self.assertEquals(b.foo, 24)
        self.assertEquals(b.getfoo(), 24)

class TestDescriptors(TestCase):
    def test_delhook(self):
        "Testing __del__ hook"
        log = []
        class C(object):
            def __del__(self):
                log.append(1)
        c = C()
        self.assertEquals(log, [])
        del c
        self.assertEquals(log, [1])

        class D(object): pass
        d = D()
        try: del d[0]
        except TypeError: pass
        else: raise TestFailed, "invalid del() didn't raise TypeError"

    def test_meth_class_get(self):
        "Testing __get__ method of METH_CLASS C methods"
        # Full coverage of descrobject.c::classmethod_get()
        # Baseline
        arg = [1, 2, 3]
        res = {1: None, 2: None, 3: None}
        self.assertEquals(dict.fromkeys(arg), res)
        self.assertEquals({}.fromkeys(arg), res)
        # Now get the descriptor
        descr = dict.__dict__["fromkeys"]
        # More baseline using the descriptor directly
        self.assertEquals(descr.__get__(None, dict)(arg), res)
        self.assertEquals(descr.__get__({})(arg), res)
        # Now check various error cases
        try:
            descr.__get__(None, None)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't have allowed descr.__get__(None, None)"
        try:
            descr.__get__(42)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't have allowed descr.__get__(42)"
        try:
            descr.__get__(None, 42)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't have allowed descr.__get__(None, 42)"
        try:
            descr.__get__(None, int)
        except TypeError:
            pass
        else:
            raise TestFailed, "shouldn't have allowed descr.__get__(None, int)"


class TestNew(TestCase):
    def test_modules(self):
        "Testing uninitialized module objects"
        from types import ModuleType as M
        m = M.__new__(M)
        str(m)
        self.assertEquals(hasattr(m, "__name__"), 0)
        self.assertEquals(hasattr(m, "__file__"), 0)
        self.assertEquals(hasattr(m, "foo"), 0)
        self.assertEquals(m.__dict__, None)
        m.foo = 1
        self.assertEquals(m.__dict__, {"foo": 1})

    def test_funnynew(self):
        "Testing __new__ returning something unexpected"
        class C(object):
            def __new__(cls, arg):
                if isinstance(arg, str): return [1, 2, 3]
                elif isinstance(arg, int): return object.__new__(D)
                else: return object.__new__(cls)
        class D(C):
            def __init__(self, arg):
                self.foo = arg
        self.assertEquals(C("1"), [1, 2, 3])
        self.assertEquals(D("1"), [1, 2, 3])
        d = D(None)
        self.assertIs(d.foo, None)
        d = C(1)
        self.assertEquals(isinstance(d, D), True)
        self.assertEquals(d.foo, 1)
        d = D(1)
        self.assertEquals(isinstance(d, D), True)
        self.assertEquals(d.foo, 1)

    def test_init(self):
        # SF 1155938
        class Foo(object):
            def __init__(self):
                return 10
        try:
            Foo()
        except TypeError:
            pass
        else:
            raise TestFailed, "did not test __init__() for None return"


class TestDictProxy(TestCase):
    def test_dictproxyiterkeys(self):
        "Testing dict-proxy iterkeys"
        class C(object):
            def meth(self):
                pass
        keys = [ key for key in C.__dict__.iterkeys() ]
        keys.sort()
        self.assertEquals(keys, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth'])

    def test_dictproxyitervalues(self):
        "Testing dict-proxy itervalues"
        class C(object):
            def meth(self):
                pass
        values = [ values for values in C.__dict__.itervalues() ]
        self.assertEquals(len(values), 5)

    def test_dictproxyiteritems(self):
        "Testing dict-proxy iteritems"
        class C(object):
            def meth(self):
                pass
        keys = [ key for (key, value) in C.__dict__.iteritems() ]
        keys.sort()
        self.assertEquals(keys, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth'])


class TestDealloc(TestCase):

    def test_subtype_resurrection(self):
        "Testing resurrection of new-style instance"

        class C(object):
            container = []

            def __del__(self):
                # resurrect the instance
                C.container.append(self)

        c = C()
        c.attr = 42
        # The most interesting thing here is whether this blows up, due to flawed
        #  GC tracking logic in typeobject.c's call_finalizer() (a 2.2.1 bug).
        del c

        # If that didn't blow up, it's also interesting to see whether clearing
        # the last container slot works:  that will attempt to delete c again,
        # which will cause c to get appended back to the container again "during"
        # the del.
        del C.container[-1]
        self.assertEquals(len(C.container), 1)
        self.assertEquals(C.container[-1].attr, 42)

        # Make c mortal again, so that the test framework with -l doesn't report
        # it as a leak.
        del C.__del__

    def test_slottrash(self):
        "Testing slot trash"
        # Deallocating deeply nested slotted trash caused stack overflows
        class trash(object):
            __slots__ = ['x']
            def __init__(self, x):
                self.x = x
        o = None
        for i in xrange(50000):
            o = trash(o)
        del o


class TestProxy(TestCase):
    def test_isinst_isclass(self):
        "Testing proxy isinstance() and isclass()"
        class Proxy(object):
            def __init__(self, obj):
                self.__obj = obj
            def __getattribute__(self, name):
                if name.startswith("_Proxy__"):
                    return object.__getattribute__(self, name)
                else:
                    return getattr(self.__obj, name)
        # Test with a classic class
        class C:
            pass
        a = C()
        pa = Proxy(a)
        self.failUnless(isinstance(a, C))  # Baseline
        self.failUnless(isinstance(pa, C)) # Test
        # Test with a classic subclass
        class D(C):
            pass
        a = D()
        pa = Proxy(a)
        self.failUnless(isinstance(a, C))  # Baseline
        self.failUnless(isinstance(pa, C)) # Test
        # Test with a new-style class
        class C(object):
            pass
        a = C()
        pa = Proxy(a)
        self.failUnless(isinstance(a, C))  # Baseline
        self.failUnless(isinstance(pa, C)) # Test
        # Test with a new-style subclass
        class D(C):
            pass
        a = D()
        pa = Proxy(a)
        self.failUnless(isinstance(a, C))  # Baseline
        self.failUnless(isinstance(pa, C)) # Test

    def test_proxysuper(self):
        "Testing super() for a proxy object"
        class Proxy(object):
            def __init__(self, obj):
                self.__obj = obj
            def __getattribute__(self, name):
                if name.startswith("_Proxy__"):
                    return object.__getattribute__(self, name)
                else:
                    return getattr(self.__obj, name)

        class B(object):
            def f(self):
                return "B.f"

        class C(B):
            def f(self):
                return super(C, self).f() + "->C.f"

        obj = C()
        p = Proxy(obj)
        self.assertEquals(C.__dict__["f"](p), "B.f->C.f")


class TestCrashes(TestCase):
    def test_0_do_this_first(self):
        "Testing early bugs"
        # This dumps core when SF bug 551412 isn't fixed --
        # but only when test_descr.py is run separately.
        # (That can't be helped -- as soon as PyType_Ready()
        # is called for PyLong_Type, the bug is gone.)
        class UserLong(object):
            def __pow__(self, *args):
                pass
        try:
            pow(0L, UserLong(), 0L)
        except:
            pass

        # Testing SF bug 570483..."
        # Another segfault only when run early
        # (before PyType_Ready(tuple) is called)
        type.mro(tuple)

    def test_carloverre(self):
        "Testing prohibition of Carlo Verre's hack"
        self.assertRaises(TypeError, object.__setattr__, str, "foo", 42)
        self.assertRaises(TypeError, object.__delattr__, str, "lower")

    def test_weakref_segfault(self):
        # SF 742911
        import weakref

        class Provoker:
            def __init__(self, referrent):
                self.ref = weakref.ref(referrent)

            def __del__(self):
                x = self.ref()

        class Oops(object):
            pass

        o = Oops()
        o.whatever = Provoker(o)
        del o

    def test_wrapper_segfault(self):
        # SF 927248: deeply nested wrappers could cause stack overflow
        f = lambda:None
        for i in xrange(1000000):
            f = f.__call__
        f = None

    def test_filefault(self):
        "Testing sys.stdout is changed in getattr"
        # Fix SF #762455, segfault when sys.stdout is changed in getattr
        import sys
        class StdoutGuard:
            def __getattr__(self, attr):
                sys.stdout = sys.__stdout__
                raise RuntimeError("Premature access to sys.stdout.%s" % attr)
        sys.stdout = StdoutGuard()
        try:
            print "Oops!"
        except RuntimeError:
            pass

    def test_vicious_descriptor_nonsense(self):
        "Testing vicious_descriptor_nonsense"
        # A potential segfault spotted by Thomas Wouters in mail to
        # python-dev 2003-04-17, turned into an example & fixed by Michael
        # Hudson just less than four months later...

        class Evil(object):
            def __hash__(self):
                return hash('attr')
            def __eq__(self, other):
                del C.attr
                return 0

        class Descr(object):
            def __get__(self, ob, type=None):
                return 1

        class C(object):
            attr = Descr()

        c = C()
        c.__dict__[Evil()] = 0

        self.assertEquals(c.attr, 1)
        # this makes a crash more likely:
        import gc; gc.collect()
        self.assertEquals(hasattr(c, 'attr'), False)

    def test_weakref_in_del_segfault(self):
        "Testing weakref in del segfault"

        import weakref
        global ref

        class Target():
            def __del__(self):
                global ref
                ref = weakref.ref(self)

        w = Target()
        del w
        del ref

    def test_borrowed_ref_3_segfault(self):
        "Testing borrowed ref 3 segfault"
        # This used to segfault until r60224

        class KeyFunc(object):
            def __call__(self, n):
                del d['key']
                return 1

        d = {'key': KeyFunc()}
        try:
            min(range(10), **d)
        except:
            pass

    def test_borrowed_ref_4_segfault(self):
        "Testing borrowed ref 4 segfault"
        # This used to segfault until r60224

        import types
        import __builtin__

        class X(object):
            def __getattr__(self, name):
                # this is called with name == '__bases__' by PyObject_IsInstance()
                # during the unbound method call -- it frees the unbound method
                # itself before it invokes its im_func.
                del __builtin__.__import__
                return ()

        pseudoclass = X()

        class Y(object):
            def __call__(self, *args):
                # 'self' was freed already
                return (self, args)

        # make an unbound method
        orig_import = __import__
        try:
            __builtin__.__import__ = types.MethodType(Y(), None, (pseudoclass, str))
            import spam
        finally:
            __builtin__.__import__ = orig_import

    def test_losing_dict_ref_segfault(self):
        "Testing losing dict ref segfault"
        # This used to segfault;
        # derived from issue #1303614, test67.py

        class Strange(object):
            def __hash__(self):
                return hash('hello')

            def __eq__(self, other):
                x.__dict__ = {}   # the old x.__dict__ is deallocated
                return False

        class X(object):
            pass

        v = 123
        x = X()
        x.__dict__ = {Strange(): 42, 'hello': v+456}
        x.hello


def test_main():
    # Gather all classes in this module that inherit unittest.TestCase
    test_classes = []
    for obj in globals().itervalues():
        try:
            if not issubclass(obj, unittest.TestCase):
                continue
        except TypeError:
            # Not a class
            continue

        test_classes.append(obj)

    # TestCrashes must be first, somehow
    test_classes.remove(TestCrashes)
    test_classes.insert(0, TestCrashes)

    run_unittest(*test_classes)

if __name__ == "__main__":
    test_main()