# Python test set -- built-in functions

import test.test_support, unittest

from test.test_support import fcmp, have_unicode, TESTFN, unlink, \

                              run_unittest, run_with_locale

from operator import neg

import sys, warnings, cStringIO, random, UserDict

warnings.filterwarnings("ignore", "hex../oct.. of negative int",

                        FutureWarning, __name__)

warnings.filterwarnings("ignore", "integer argument expected",

                        DeprecationWarning, "unittest")

# count the number of test runs.

# used to skip running test_execfile() multiple times

numruns = 0

class Squares:

    def __init__(self, max):

        self.max = max

        self.sofar = []

    def __len__(self): return len(self.sofar)

    def __getitem__(self, i):

        if not 0 <= i < self.max: raise IndexError

        n = len(self.sofar)

        while n <= i:

            self.sofar.append(n*n)

            n += 1

        return self.sofar[i]

class StrSquares:

    def __init__(self, max):

        self.max = max

        self.sofar = []

    def __len__(self):

        return len(self.sofar)

    def __getitem__(self, i):

        if not 0 <= i < self.max:

            raise IndexError

        n = len(self.sofar)

        while n <= i:

            self.sofar.append(str(n*n))

            n += 1

        return self.sofar[i]

class BitBucket:

    def write(self, line):

        pass

L = [

        ('0', 0),

        ('1', 1),

        ('9', 9),

        ('10', 10),

        ('99', 99),

        ('100', 100),

        ('314', 314),

        (' 314', 314),

        ('314 ', 314),

        ('  \t\t  314  \t\t  ', 314),

        (repr(sys.maxint), sys.maxint),

        ('  1x', ValueError),

        ('  1  ', 1),

        ('  1\02  ', ValueError),

        ('', ValueError),

        (' ', ValueError),

        ('  \t\t  ', ValueError)

]

if have_unicode:

    L += [

        (unicode('0'), 0),

        (unicode('1'), 1),

        (unicode('9'), 9),

        (unicode('10'), 10),

        (unicode('99'), 99),

        (unicode('100'), 100),

        (unicode('314'), 314),

        (unicode(' 314'), 314),

        (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),

        (unicode('  \t\t  314  \t\t  '), 314),

        (unicode('  1x'), ValueError),

        (unicode('  1  '), 1),

        (unicode('  1\02  '), ValueError),

        (unicode(''), ValueError),

        (unicode(' '), ValueError),

        (unicode('  \t\t  '), ValueError),

        (unichr(0x200), ValueError),

]

class TestFailingBool:

    def __nonzero__(self):

        raise RuntimeError

class TestFailingIter:

    def __iter__(self):

        raise RuntimeError

class BuiltinTest(unittest.TestCase):

    def test_import(self):

        __import__('sys')

        __import__('time')

        __import__('string')

        self.assertRaises(ImportError, __import__, 'spamspam')

        self.assertRaises(TypeError, __import__, 1, 2, 3, 4)

        self.assertRaises(ValueError, __import__, '')

    def test_abs(self):

        # int

        self.assertEqual(abs(0), 0)

        self.assertEqual(abs(1234), 1234)

        self.assertEqual(abs(-1234), 1234)

        self.assertTrue(abs(-sys.maxint-1) > 0)

        # float

        self.assertEqual(abs(0.0), 0.0)

        self.assertEqual(abs(3.14), 3.14)

        self.assertEqual(abs(-3.14), 3.14)

        # long

        self.assertEqual(abs(0L), 0L)

        self.assertEqual(abs(1234L), 1234L)

        self.assertEqual(abs(-1234L), 1234L)

        # str

        self.assertRaises(TypeError, abs, 'a')

    def test_all(self):

        self.assertEqual(all([2, 4, 6]), True)

        self.assertEqual(all([2, None, 6]), False)

        self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6])

        self.assertRaises(RuntimeError, all, TestFailingIter())

        self.assertRaises(TypeError, all, 10)               # Non-iterable

        self.assertRaises(TypeError, all)                   # No args

        self.assertRaises(TypeError, all, [2, 4, 6], [])    # Too many args

        self.assertEqual(all([]), True)                     # Empty iterator

        S = [50, 60]

        self.assertEqual(all(x > 42 for x in S), True)

        S = [50, 40, 60]

        self.assertEqual(all(x > 42 for x in S), False)

    def test_any(self):

        self.assertEqual(any([None, None, None]), False)

        self.assertEqual(any([None, 4, None]), True)

        self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6])

        self.assertRaises(RuntimeError, all, TestFailingIter())

        self.assertRaises(TypeError, any, 10)               # Non-iterable

        self.assertRaises(TypeError, any)                   # No args

        self.assertRaises(TypeError, any, [2, 4, 6], [])    # Too many args

        self.assertEqual(any([]), False)                    # Empty iterator

        S = [40, 60, 30]

        self.assertEqual(any(x > 42 for x in S), True)

        S = [10, 20, 30]

        self.assertEqual(any(x > 42 for x in S), False)

    def test_neg(self):

        x = -sys.maxint-1

        self.assert_(isinstance(x, int))

        self.assertEqual(-x, sys.maxint+1)

    def test_apply(self):

        def f0(*args):

            self.assertEqual(args, ())

        def f1(a1):

            self.assertEqual(a1, 1)

        def f2(a1, a2):

            self.assertEqual(a1, 1)

            self.assertEqual(a2, 2)

        def f3(a1, a2, a3):

            self.assertEqual(a1, 1)

            self.assertEqual(a2, 2)

            self.assertEqual(a3, 3)

        apply(f0, ())

        apply(f1, (1,))

        apply(f2, (1, 2))

        apply(f3, (1, 2, 3))

        # A PyCFunction that takes only positional parameters should allow an

        # empty keyword dictionary to pass without a complaint, but raise a

        # TypeError if the dictionary is non-empty.

        apply(id, (1,), {})

        self.assertRaises(TypeError, apply, id, (1,), {"foo": 1})

        self.assertRaises(TypeError, apply)

        self.assertRaises(TypeError, apply, id, 42)

        self.assertRaises(TypeError, apply, id, (42,), 42)

    def test_callable(self):

        self.assert_(callable(len))

        def f(): pass

        self.assert_(callable(f))

        class C:

            def meth(self): pass

        self.assert_(callable(C))

        x = C()

        self.assert_(callable(x.meth))

        self.assert_(not callable(x))

        class D(C):

            def __call__(self): pass

        y = D()

        self.assert_(callable(y))

        y()

    def test_chr(self):

        self.assertEqual(chr(32), ' ')

        self.assertEqual(chr(65), 'A')

        self.assertEqual(chr(97), 'a')

        self.assertEqual(chr(0xff), '\xff')

        self.assertRaises(ValueError, chr, 256)

        self.assertRaises(TypeError, chr)

    def test_cmp(self):

        self.assertEqual(cmp(-1, 1), -1)

        self.assertEqual(cmp(1, -1), 1)

        self.assertEqual(cmp(1, 1), 0)

        # verify that circular objects are not handled

        a = []; a.append(a)

        b = []; b.append(b)

        from UserList import UserList

        c = UserList(); c.append(c)

        self.assertRaises(RuntimeError, cmp, a, b)

        self.assertRaises(RuntimeError, cmp, b, c)

        self.assertRaises(RuntimeError, cmp, c, a)

        self.assertRaises(RuntimeError, cmp, a, c)

       # okay, now break the cycles

        a.pop(); b.pop(); c.pop()

        self.assertRaises(TypeError, cmp)

    def test_coerce(self):

        self.assert_(not fcmp(coerce(1, 1.1), (1.0, 1.1)))

        self.assertEqual(coerce(1, 1L), (1L, 1L))

        self.assert_(not fcmp(coerce(1L, 1.1), (1.0, 1.1)))

        self.assertRaises(TypeError, coerce)

        class BadNumber:

            def __coerce__(self, other):

                raise ValueError

        self.assertRaises(ValueError, coerce, 42, BadNumber())

        self.assertRaises(OverflowError, coerce, 0.5, int("12345" * 1000))

    def test_compile(self):

        compile('print 1\n', '', 'exec')

        bom = '\xef\xbb\xbf'

        compile(bom + 'print 1\n', '', 'exec')

        self.assertRaises(TypeError, compile)

        self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'badmode')

        self.assertRaises(ValueError, compile, 'print 42\n', '<string>', 'single', 0xff)

        self.assertRaises(TypeError, compile, chr(0), 'f', 'exec')

        if have_unicode:

            compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec')

            self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec')

            self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad')

    def test_delattr(self):

        import sys

        sys.spam = 1

        delattr(sys, 'spam')

        self.assertRaises(TypeError, delattr)

    def test_dir(self):

        x = 1

        self.assert_('x' in dir())

        import sys

        self.assert_('modules' in dir(sys))

        self.assertRaises(TypeError, dir, 42, 42)

    def test_divmod(self):

        self.assertEqual(divmod(12, 7), (1, 5))

        self.assertEqual(divmod(-12, 7), (-2, 2))

        self.assertEqual(divmod(12, -7), (-2, -2))

        self.assertEqual(divmod(-12, -7), (1, -5))

        self.assertEqual(divmod(12L, 7L), (1L, 5L))

        self.assertEqual(divmod(-12L, 7L), (-2L, 2L))

        self.assertEqual(divmod(12L, -7L), (-2L, -2L))

        self.assertEqual(divmod(-12L, -7L), (1L, -5L))

        self.assertEqual(divmod(12, 7L), (1, 5L))

        self.assertEqual(divmod(-12, 7L), (-2, 2L))

        self.assertEqual(divmod(12L, -7), (-2L, -2))

        self.assertEqual(divmod(-12L, -7), (1L, -5))

        self.assertEqual(divmod(-sys.maxint-1, -1),

                         (sys.maxint+1, 0))

        self.assert_(not fcmp(divmod(3.25, 1.0), (3.0, 0.25)))

        self.assert_(not fcmp(divmod(-3.25, 1.0), (-4.0, 0.75)))

        self.assert_(not fcmp(divmod(3.25, -1.0), (-4.0, -0.75)))

        self.assert_(not fcmp(divmod(-3.25, -1.0), (3.0, -0.25)))

        self.assertRaises(TypeError, divmod)

    def test_eval(self):

        self.assertEqual(eval('1+1'), 2)

        self.assertEqual(eval(' 1+1\n'), 2)

        globals = {'a': 1, 'b': 2}

        locals = {'b': 200, 'c': 300}

        self.assertEqual(eval('a', globals) , 1)

        self.assertEqual(eval('a', globals, locals), 1)

        self.assertEqual(eval('b', globals, locals), 200)

        self.assertEqual(eval('c', globals, locals), 300)

        if have_unicode:

            self.assertEqual(eval(unicode('1+1')), 2)

            self.assertEqual(eval(unicode(' 1+1\n')), 2)

        globals = {'a': 1, 'b': 2}

        locals = {'b': 200, 'c': 300}

        if have_unicode:

            self.assertEqual(eval(unicode('a'), globals), 1)

            self.assertEqual(eval(unicode('a'), globals, locals), 1)

            self.assertEqual(eval(unicode('b'), globals, locals), 200)

            self.assertEqual(eval(unicode('c'), globals, locals), 300)

            bom = '\xef\xbb\xbf'

            self.assertEqual(eval(bom + 'a', globals, locals), 1)

            self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),

                             unicode('\xc3\xa5', 'utf8'))

        self.assertRaises(TypeError, eval)

        self.assertRaises(TypeError, eval, ())

    def test_general_eval(self):

        # Tests that general mappings can be used for the locals argument

        class M:

            "Test mapping interface versus possible calls from eval()."

            def __getitem__(self, key):

                if key == 'a':

                    return 12

                raise KeyError

            def keys(self):

                return list('xyz')

        m = M()

        g = globals()

        self.assertEqual(eval('a', g, m), 12)

        self.assertRaises(NameError, eval, 'b', g, m)

        self.assertEqual(eval('dir()', g, m), list('xyz'))

        self.assertEqual(eval('globals()', g, m), g)

        self.assertEqual(eval('locals()', g, m), m)

        self.assertRaises(TypeError, eval, 'a', m)

        class A:

            "Non-mapping"

            pass

        m = A()

        self.assertRaises(TypeError, eval, 'a', g, m)

        # Verify that dict subclasses work as well

        class D(dict):

            def __getitem__(self, key):

                if key == 'a':

                    return 12

                return dict.__getitem__(self, key)

            def keys(self):

                return list('xyz')

        d = D()

        self.assertEqual(eval('a', g, d), 12)

        self.assertRaises(NameError, eval, 'b', g, d)

        self.assertEqual(eval('dir()', g, d), list('xyz'))

        self.assertEqual(eval('globals()', g, d), g)

        self.assertEqual(eval('locals()', g, d), d)

        # Verify locals stores (used by list comps)

        eval('[locals() for i in (2,3)]', g, d)

        eval('[locals() for i in (2,3)]', g, UserDict.UserDict())

        class SpreadSheet:

            "Sample application showing nested, calculated lookups."

            _cells = {}

            def __setitem__(self, key, formula):

                self._cells[key] = formula

            def __getitem__(self, key):

                return eval(self._cells[key], globals(), self)

        ss = SpreadSheet()

        ss['a1'] = '5'

        ss['a2'] = 'a1*6'

        ss['a3'] = 'a2*7'

        self.assertEqual(ss['a3'], 210)

        # Verify that dir() catches a non-list returned by eval

        # SF bug #1004669

        class C:

            def __getitem__(self, item):

                raise KeyError(item)

            def keys(self):

                return 'a'

        self.assertRaises(TypeError, eval, 'dir()', globals(), C())

    # Done outside of the method test_z to get the correct scope

    z = 0

    f = open(TESTFN, 'w')

    f.write('z = z+1\n')

    f.write('z = z*2\n')

    f.close()

    execfile(TESTFN)

    def test_execfile(self):

        global numruns

        if numruns:

            return

        numruns += 1

        globals = {'a': 1, 'b': 2}

        locals = {'b': 200, 'c': 300}

        self.assertEqual(self.__class__.z, 2)

        globals['z'] = 0

        execfile(TESTFN, globals)

        self.assertEqual(globals['z'], 2)

        locals['z'] = 0

        execfile(TESTFN, globals, locals)

        self.assertEqual(locals['z'], 2)

        class M:

            "Test mapping interface versus possible calls from execfile()."

            def __init__(self):

                self.z = 10

            def __getitem__(self, key):

                if key == 'z':

                    return self.z

                raise KeyError

            def __setitem__(self, key, value):

                if key == 'z':

                    self.z = value

                    return

                raise KeyError

        locals = M()

        locals['z'] = 0

        execfile(TESTFN, globals, locals)

        self.assertEqual(locals['z'], 2)

        unlink(TESTFN)

        self.assertRaises(TypeError, execfile)

        self.assertRaises(TypeError, execfile, TESTFN, {}, ())

        import os

        self.assertRaises(IOError, execfile, os.curdir)

        self.assertRaises(IOError, execfile, "I_dont_exist")

    def test_filter(self):

        self.assertEqual(filter(lambda c: 'a' <= c <= 'z', 'Hello World'), 'elloorld')

        self.assertEqual(filter(None, [1, 'hello', [], [3], '', None, 9, 0]), [1, 'hello', [3], 9])

        self.assertEqual(filter(lambda x: x > 0, [1, -3, 9, 0, 2]), [1, 9, 2])

        self.assertEqual(filter(None, Squares(10)), [1, 4, 9, 16, 25, 36, 49, 64, 81])

        self.assertEqual(filter(lambda x: x%2, Squares(10)), [1, 9, 25, 49, 81])

        def identity(item):

            return 1

        filter(identity, Squares(5))

        self.assertRaises(TypeError, filter)

        class BadSeq(object):

            def __getitem__(self, index):

                if index<4:

                    return 42

                raise ValueError

        self.assertRaises(ValueError, filter, lambda x: x, BadSeq())

        def badfunc():

            pass

        self.assertRaises(TypeError, filter, badfunc, range(5))

        # test bltinmodule.c::filtertuple()

        self.assertEqual(filter(None, (1, 2)), (1, 2))

        self.assertEqual(filter(lambda x: x>=3, (1, 2, 3, 4)), (3, 4))

        self.assertRaises(TypeError, filter, 42, (1, 2))

        # test bltinmodule.c::filterstring()

        self.assertEqual(filter(None, "12"), "12")

        self.assertEqual(filter(lambda x: x>="3", "1234"), "34")

        self.assertRaises(TypeError, filter, 42, "12")

        class badstr(str):

            def __getitem__(self, index):

                raise ValueError

        self.assertRaises(ValueError, filter, lambda x: x >="3", badstr("1234"))

        class badstr2(str):

            def __getitem__(self, index):

                return 42

        self.assertRaises(TypeError, filter, lambda x: x >=42, badstr2("1234"))

        class weirdstr(str):

            def __getitem__(self, index):

                return weirdstr(2*str.__getitem__(self, index))

        self.assertEqual(filter(lambda x: x>="33", weirdstr("1234")), "3344")

        class shiftstr(str):

            def __getitem__(self, index):

                return chr(ord(str.__getitem__(self, index))+1)

        self.assertEqual(filter(lambda x: x>="3", shiftstr("1234")), "345")

        if have_unicode:

            # test bltinmodule.c::filterunicode()

            self.assertEqual(filter(None, unicode("12")), unicode("12"))

            self.assertEqual(filter(lambda x: x>="3", unicode("1234")), unicode("34"))

            self.assertRaises(TypeError, filter, 42, unicode("12"))

            self.assertRaises(ValueError, filter, lambda x: x >="3", badstr(unicode("1234")))

            class badunicode(unicode):

                def __getitem__(self, index):

                    return 42

            self.assertRaises(TypeError, filter, lambda x: x >=42, badunicode("1234"))

            class weirdunicode(unicode):

                def __getitem__(self, index):

                    return weirdunicode(2*unicode.__getitem__(self, index))

            self.assertEqual(

                filter(lambda x: x>=unicode("33"), weirdunicode("1234")), unicode("3344"))

            class shiftunicode(unicode):

                def __getitem__(self, index):

                    return unichr(ord(unicode.__getitem__(self, index))+1)

            self.assertEqual(

                filter(lambda x: x>=unicode("3"), shiftunicode("1234")),

                unicode("345")

            )

    def test_filter_subclasses(self):

        # test that filter() never returns tuple, str or unicode subclasses

        # and that the result always goes through __getitem__

        funcs = (None, bool, lambda x: True)

        class tuple2(tuple):

            def __getitem__(self, index):

                return 2*tuple.__getitem__(self, index)

        class str2(str):

            def __getitem__(self, index):

                return 2*str.__getitem__(self, index)

        inputs = {

            tuple2: {(): (), (1, 2, 3): (2, 4, 6)},

            str2:   {"": "", "123": "112233"}

        }