import types

import unittest

import warnings

from copy import deepcopy

from test import test_support

class OperatorsTest(unittest.TestCase):

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

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

        self.binops = {

            'add': '+',

            'sub': '-',

            'mul': '*',

            'div': '/',

            'divmod': 'divmod',

            'pow': '**',

            'lshift': '<<',

            'rshift': '>>',

            'and': '&',

            'xor': '^',

            'or': '|',

            'cmp': 'cmp',

            'lt': '<',

            'le': '<=',

            'eq': '==',

            'ne': '!=',

            'gt': '>',

            'ge': '>=',

        }

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

            if expr.islower():

                expr = expr + "(a, b)"

            else:

                expr = 'a %s b' % expr

            self.binops[name] = expr

        self.unops = {

            'pos': '+',

            'neg': '-',

            'abs': 'abs',

            'invert': '~',

            'int': 'int',

            'long': 'long',

            'float': 'float',

            'oct': 'oct',

            'hex': 'hex',

        }

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

            if expr.islower():

                expr = expr + "(a)"

            else:

                expr = '%s a' % expr

            self.unops[name] = expr

    def setUp(self):

        self.original_filters = warnings.filters[:]

        warnings.filterwarnings("ignore",

                 r'complex divmod\(\), // and % are deprecated$',

                 DeprecationWarning, r'(<string>|%s)$' % __name__)

    def tearDown(self):

        warnings.filters = self.original_filters

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

        d = {'a': a}

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

        t = type(a)

        m = getattr(t, meth)

        # Find method in parent class

        while meth not in t.__dict__:

            t = t.__bases__[0]

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

        self.assertEqual(m(a), res)

        bm = getattr(a, meth)

        self.assertEqual(bm(), res)

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

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

        # XXX Hack so this passes before 2.3 when -Qnew is specified.

        if meth == "__div__" and 1/2 == 0.5:

            meth = "__truediv__"

        if meth == '__divmod__': pass

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

        t = type(a)

        m = getattr(t, meth)

        while meth not in t.__dict__:

            t = t.__bases__[0]

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

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

        bm = getattr(a, meth)

        self.assertEqual(bm(b), res)

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

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

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

        t = type(a)

        m = getattr(t, meth)

        while meth not in t.__dict__:

            t = t.__bases__[0]

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

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

        bm = getattr(a, meth)

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

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

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

        exec stmt in d

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

        t = type(a)

        m = getattr(t, meth)

        while meth not in t.__dict__:

            t = t.__bases__[0]

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

        d['a'] = deepcopy(a)

        m(d['a'], b)

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

        d['a'] = deepcopy(a)

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

        bm(b)

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

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

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

        exec stmt in d

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

        t = type(a)

        m = getattr(t, meth)

        while meth not in t.__dict__:

            t = t.__bases__[0]

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

        d['a'] = deepcopy(a)

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

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

        d['a'] = deepcopy(a)

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

        bm(b, c)

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

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

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

        exec stmt in dictionary

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

        t = type(a)

        while meth not in t.__dict__:

            t = t.__bases__[0]

        m = getattr(t, meth)

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

        dictionary['a'] = deepcopy(a)

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

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

        dictionary['a'] = deepcopy(a)

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

        bm(b, c, d)

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

    def test_lists(self):

        # Testing list operations...

        # Asserts are within individual test methods

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

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

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

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

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

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

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

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

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

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

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

        self.set3op_test([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.binop_test({1:2}, {2:1}, -1, "cmp(a,b)", "__cmp__")

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

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

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

        d = {1:2, 3:4}

        l1 = []

        for i in d.keys():

            l1.append(i)

        l = []

        for i in iter(d):

            l.append(i)

        self.assertEqual(l, l1)

        l = []

        for i in d.__iter__():

            l.append(i)

        self.assertEqual(l, l1)

        l = []

        for i in dict.__iter__(d):

            l.append(i)

        self.assertEqual(l, l1)

        d = {1:2, 3:4}

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

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

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

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

                        "__setitem__")

    # Tests for unary and binary operators

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

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

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

            if name not in skip:

                name = "__%s__" % name

                if hasattr(a, name):

                    res = eval(expr, dict)

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

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

            if name not in skip:

                name = "__%s__" % name

                if hasattr(a, name):

                    res = eval(expr, dict)

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

    def test_ints(self):

        # Testing int operations...

        self.number_operators(100, 3)

        # The following crashes in Python 2.2

        self.assertEqual((1).__nonzero__(), 1)

        self.assertEqual((0).__nonzero__(), 0)

        # This returns 'NotImplemented' in Python 2.2

        class C(int):

            def __add__(self, other):

                return NotImplemented

        self.assertEqual(C(5L), 5)

        try:

            C() + ""

        except TypeError:

            pass

        else:

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

        import sys

        try:

            C(sys.maxint+1)

        except OverflowError:

            pass

        else:

            self.fail("should have raised OverflowError")

    def test_longs(self):

        # Testing long operations...

        self.number_operators(100L, 3L)

    def test_floats(self):

        # Testing float operations...

        self.number_operators(100.0, 3.0)

    def test_complexes(self):

        # Testing complex operations...

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

                                                  'int', '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.assertEqual(repr(a), "3.14")

        self.assertEqual(a.prec, 6)

        a = Number(a, prec=2)

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

        self.assertEqual(a.prec, 2)

        a = Number(234.5)

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

        self.assertEqual(a.prec, 12)

    def test_spam_lists(self):

        # Testing spamlist operations...

        import copy, xxsubtype as spam

        def spamlist(l, memo=None):

            import xxsubtype as spam

            return spam.spamlist(l)

        # This is an ugly hack:

        copy._deepcopy_dispatch[spam.spamlist] = spamlist

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

                       "__add__")

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

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

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

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

                        "__getslice__")

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

                       "__iadd__")

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

                       "__imul__")

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

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

                       "__mul__")

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

                       "__rmul__")

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

                        "__setitem__")

        self.set3op_test(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.assertEqual(a, [])

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

        a.append(100)

        self.assertEqual(a, [100])

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

        a.setstate(42)

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

    def test_spam_dicts(self):

        # Testing spamdict operations...

        import copy, xxsubtype as spam

        def spamdict(d, memo=None):

            import xxsubtype as spam

            sd = spam.spamdict()

            for k, v in d.items():

                sd[k] = v

            return sd

        # This is an ugly hack:

        copy._deepcopy_dispatch[spam.spamdict] = spamdict

        self.binop_test(spamdict({1:2}), spamdict({2:1}), -1, "cmp(a,b)",

                       "__cmp__")

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

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

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

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

        l1 = []

        for i in d.keys():

            l1.append(i)

        l = []

        for i in iter(d):

            l.append(i)

        self.assertEqual(l, l1)

        l = []

        for i in d.__iter__():

            l.append(i)

        self.assertEqual(l, l1)

        l = []

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

            l.append(i)

        self.assertEqual(l, l1)

        straightd = {1:2, 3:4}

        spamd = spamdict(straightd)

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

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

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

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

        # Test subclassing

        class C(spam.spamdict):

            def foo(self): return 1

        a = C()

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

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

        a['foo'] = 'bar'

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

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

        a.setstate(100)

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

class ClassPropertiesAndMethods(unittest.TestCase):

    def test_python_dicts(self):

        # Testing Python subclass of dict...

        self.assert_(issubclass(dict, dict))

        self.assert_(isinstance({}, dict))

        d = dict()

        self.assertEqual(d, {})

        self.assert_(d.__class__ is dict)

        self.assert_(isinstance(d, dict))

        class C(dict):

            state = -1

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

                if a:

                    self.assertEqual(len(a), 1)

                    self_local.state = a[0]

                if kw:

                    for k, v in kw.items():

                        self_local[v] = k

            def __getitem__(self, key):

                return self.get(key, 0)

            def __setitem__(self_local, key, value):

                self.assert_(isinstance(key, type(0)))

                dict.__setitem__(self_local, key, value)

            def setstate(self, state):

                self.state = state

            def getstate(self):

                return self.state

        self.assert_(issubclass(C, dict))

        a1 = C(12)

        self.assertEqual(a1.state, 12)

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

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

        a = C()

        self.assertEqual(a.state, -1)

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

        a.setstate(0)

        self.assertEqual(a.state, 0)

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

        a.setstate(10)

        self.assertEqual(a.state, 10)

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

        self.assertEqual(a[42], 0)

        a[42] = 24

        self.assertEqual(a[42], 24)

        N = 50

        for i in range(N):

            a[i] = C()

            for j in range(N):

                a[i][j] = i*j

        for i in range(N):

            for j in range(N):

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

    def test_python_lists(self):

        # Testing Python subclass of list...

        class C(list):

            def __getitem__(self, i):

                return list.__getitem__(self, i) + 100

            def __getslice__(self, i, j):

                return (i, j)

        a = C()

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

        self.assertEqual(a[0], 100)

        self.assertEqual(a[1], 101)

        self.assertEqual(a[2], 102)

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

    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.assertEqual(a.getstate(), 0)

        a.setstate(10)

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

        class D:

            class __metaclass__(type):

                def myself(cls): return cls

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

        d = D()

        self.assertEqual(d.__class__, D)

        class M1(type):

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

                dict['__spam__'] = 1

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

        class C:

            __metaclass__ = M1

        self.assertEqual(C.__spam__, 1)

        c = C()

        self.assertEqual(c.__spam__, 1)

        class _instance(object):

            pass

        class M2(object):

            @staticmethod

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

                self = object.__new__(cls)

                self.name = name

                self.bases = bases

                self.dict = dict

                return self

            def __call__(self):

                it = _instance()

                # Early binding of methods

                for key in self.dict:

                    if key.startswith("__"):

                        continue

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

                return it

        class C:

            __metaclass__ = M2

            def spam(self):

                return 42

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

        self.assertEqual(C.bases, ())

        self.assert_('spam' in C.dict)

        c = C()

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

        # More metaclass examples

        class autosuper(type):

            # Automatically add __super to the class

            # This trick only works for dynamic classes

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

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

                                                          name, bases, dict)

                # Name mangling for __super removes leading underscores

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

                    name = name[1:]

                if name:

                    name = "_%s__super" % name