# Python test set -- part 1, grammar.

# This just tests whether the parser accepts them all.

# NOTE: When you run this test as a script from the command line, you

# get warnings about certain hex/oct constants.  Since those are

# issued by the parser, you can't suppress them by adding a

# filterwarnings() call to this module.  Therefore, to shut up the

# regression test, the filterwarnings() call has been added to

# regrtest.py.

from test.test_support import run_unittest, check_syntax_error

import unittest

import sys

# testing import *

from sys import *

class TokenTests(unittest.TestCase):

    def testBackslash(self):

        # Backslash means line continuation:

        x = 1 \

        + 1

        self.assertEquals(x, 2, 'backslash for line continuation')

        # Backslash does not means continuation in comments :\

        x = 0

        self.assertEquals(x, 0, 'backslash ending comment')

    def testPlainIntegers(self):

        self.assertEquals(0xff, 255)

        self.assertEquals(0377, 255)

        self.assertEquals(2147483647, 017777777777)

        # "0x" is not a valid literal

        self.assertRaises(SyntaxError, eval, "0x")

        from sys import maxint

        if maxint == 2147483647:

            self.assertEquals(-2147483647-1, -020000000000)

            # XXX -2147483648

            self.assert_(037777777777 > 0)

            self.assert_(0xffffffff > 0)

            for s in '2147483648', '040000000000', '0x100000000':

                try:

                    x = eval(s)

                except OverflowError:

                    self.fail("OverflowError on huge integer literal %r" % s)

        elif maxint == 9223372036854775807:

            self.assertEquals(-9223372036854775807-1, -01000000000000000000000)

            self.assert_(01777777777777777777777 > 0)

            self.assert_(0xffffffffffffffff > 0)

            for s in '9223372036854775808', '02000000000000000000000', \

                     '0x10000000000000000':

                try:

                    x = eval(s)

                except OverflowError:

                    self.fail("OverflowError on huge integer literal %r" % s)

        else:

            self.fail('Weird maxint value %r' % maxint)

    def testLongIntegers(self):

        x = 0L

        x = 0l

        x = 0xffffffffffffffffL

        x = 0xffffffffffffffffl

        x = 077777777777777777L

        x = 077777777777777777l

        x = 123456789012345678901234567890L

        x = 123456789012345678901234567890l

    def testFloats(self):

        x = 3.14

        x = 314.

        x = 0.314

        # XXX x = 000.314

        x = .314

        x = 3e14

        x = 3E14

        x = 3e-14

        x = 3e+14

        x = 3.e14

        x = .3e14

        x = 3.1e4

    def testStringLiterals(self):

        x = ''; y = ""; self.assert_(len(x) == 0 and x == y)

        x = '\''; y = "'"; self.assert_(len(x) == 1 and x == y and ord(x) == 39)

        x = '"'; y = "\""; self.assert_(len(x) == 1 and x == y and ord(x) == 34)

        x = "doesn't \"shrink\" does it"

        y = 'doesn\'t "shrink" does it'

        self.assert_(len(x) == 24 and x == y)

        x = "does \"shrink\" doesn't it"

        y = 'does "shrink" doesn\'t it'

        self.assert_(len(x) == 24 and x == y)

        x = """

The "quick"

brown fox

jumps over

the 'lazy' dog.

"""

        y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n'

        self.assertEquals(x, y)

        y = '''

The "quick"

brown fox

jumps over

the 'lazy' dog.

'''

        self.assertEquals(x, y)

        y = "\n\

The \"quick\"\n\

brown fox\n\

jumps over\n\

the 'lazy' dog.\n\

"

        self.assertEquals(x, y)

        y = '\n\

The \"quick\"\n\

brown fox\n\

jumps over\n\

the \'lazy\' dog.\n\

'

        self.assertEquals(x, y)

class GrammarTests(unittest.TestCase):

    # single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE

    # XXX can't test in a script -- this rule is only used when interactive

    # file_input: (NEWLINE | stmt)* ENDMARKER

    # Being tested as this very moment this very module

    # expr_input: testlist NEWLINE

    # XXX Hard to test -- used only in calls to input()

    def testEvalInput(self):

        # testlist ENDMARKER

        x = eval('1, 0 or 1')

    def testFuncdef(self):

        ### 'def' NAME parameters ':' suite

        ### parameters: '(' [varargslist] ')'

        ### varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' ('**'|'*' '*') NAME]

        ###            | ('**'|'*' '*') NAME)

        ###            | fpdef ['=' test] (',' fpdef ['=' test])* [',']

        ### fpdef: NAME | '(' fplist ')'

        ### fplist: fpdef (',' fpdef)* [',']

        ### arglist: (argument ',')* (argument | *' test [',' '**' test] | '**' test)

        ### argument: [test '='] test   # Really [keyword '='] test

        def f1(): pass

        f1()

        f1(*())

        f1(*(), **{})

        def f2(one_argument): pass

        def f3(two, arguments): pass

        def f4(two, (compound, (argument, list))): pass

        def f5((compound, first), two): pass

        self.assertEquals(f2.func_code.co_varnames, ('one_argument',))

        self.assertEquals(f3.func_code.co_varnames, ('two', 'arguments'))

        if sys.platform.startswith('java'):

            self.assertEquals(f4.func_code.co_varnames,

                   ('two', '(compound, (argument, list))', 'compound', 'argument',

                                'list',))

            self.assertEquals(f5.func_code.co_varnames,

                   ('(compound, first)', 'two', 'compound', 'first'))

        else:

            self.assertEquals(f4.func_code.co_varnames,

                  ('two', '.1', 'compound', 'argument',  'list'))

            self.assertEquals(f5.func_code.co_varnames,

                  ('.0', 'two', 'compound', 'first'))

        def a1(one_arg,): pass

        def a2(two, args,): pass

        def v0(*rest): pass

        def v1(a, *rest): pass

        def v2(a, b, *rest): pass

        def v3(a, (b, c), *rest): return a, b, c, rest

        f1()

        f2(1)

        f2(1,)

        f3(1, 2)

        f3(1, 2,)

        f4(1, (2, (3, 4)))

        v0()

        v0(1)

        v0(1,)

        v0(1,2)

        v0(1,2,3,4,5,6,7,8,9,0)

        v1(1)

        v1(1,)

        v1(1,2)

        v1(1,2,3)

        v1(1,2,3,4,5,6,7,8,9,0)

        v2(1,2)

        v2(1,2,3)

        v2(1,2,3,4)

        v2(1,2,3,4,5,6,7,8,9,0)

        v3(1,(2,3))

        v3(1,(2,3),4)

        v3(1,(2,3),4,5,6,7,8,9,0)

        # ceval unpacks the formal arguments into the first argcount names;

        # thus, the names nested inside tuples must appear after these names.

        if sys.platform.startswith('java'):

            self.assertEquals(v3.func_code.co_varnames, ('a', '(b, c)', 'rest', 'b', 'c'))

        else:

            self.assertEquals(v3.func_code.co_varnames, ('a', '.1', 'rest', 'b', 'c'))

        self.assertEquals(v3(1, (2, 3), 4), (1, 2, 3, (4,)))

        def d01(a=1): pass

        d01()

        d01(1)

        d01(*(1,))

        d01(**{'a':2})

        def d11(a, b=1): pass

        d11(1)

        d11(1, 2)

        d11(1, **{'b':2})

        def d21(a, b, c=1): pass

        d21(1, 2)

        d21(1, 2, 3)

        d21(*(1, 2, 3))

        d21(1, *(2, 3))

        d21(1, 2, *(3,))

        d21(1, 2, **{'c':3})

        def d02(a=1, b=2): pass

        d02()

        d02(1)

        d02(1, 2)

        d02(*(1, 2))

        d02(1, *(2,))

        d02(1, **{'b':2})

        d02(**{'a': 1, 'b': 2})

        def d12(a, b=1, c=2): pass

        d12(1)

        d12(1, 2)

        d12(1, 2, 3)

        def d22(a, b, c=1, d=2): pass

        d22(1, 2)

        d22(1, 2, 3)

        d22(1, 2, 3, 4)

        def d01v(a=1, *rest): pass

        d01v()

        d01v(1)

        d01v(1, 2)

        d01v(*(1, 2, 3, 4))

        d01v(*(1,))

        d01v(**{'a':2})

        def d11v(a, b=1, *rest): pass

        d11v(1)

        d11v(1, 2)

        d11v(1, 2, 3)

        def d21v(a, b, c=1, *rest): pass

        d21v(1, 2)

        d21v(1, 2, 3)

        d21v(1, 2, 3, 4)

        d21v(*(1, 2, 3, 4))

        d21v(1, 2, **{'c': 3})

        def d02v(a=1, b=2, *rest): pass

        d02v()

        d02v(1)

        d02v(1, 2)

        d02v(1, 2, 3)

        d02v(1, *(2, 3, 4))

        d02v(**{'a': 1, 'b': 2})

        def d12v(a, b=1, c=2, *rest): pass

        d12v(1)

        d12v(1, 2)

        d12v(1, 2, 3)

        d12v(1, 2, 3, 4)

        d12v(*(1, 2, 3, 4))

        d12v(1, 2, *(3, 4, 5))

        d12v(1, *(2,), **{'c': 3})

        def d22v(a, b, c=1, d=2, *rest): pass

        d22v(1, 2)

        d22v(1, 2, 3)

        d22v(1, 2, 3, 4)

        d22v(1, 2, 3, 4, 5)

        d22v(*(1, 2, 3, 4))

        d22v(1, 2, *(3, 4, 5))

        d22v(1, *(2, 3), **{'d': 4})

        def d31v((x)): pass

        d31v(1)

        def d32v((x,)): pass

        d32v((1,))

        # keyword arguments after *arglist

        def f(*args, **kwargs):

            return args, kwargs

        self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4),

                                                    {'x':2, 'y':5}))

        self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)")

        self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)")

        # Check ast errors in *args and *kwargs

        check_syntax_error(self, "f(*g(1=2))")

        check_syntax_error(self, "f(**g(1=2))")

    def testLambdef(self):

        ### lambdef: 'lambda' [varargslist] ':' test

        l1 = lambda : 0

        self.assertEquals(l1(), 0)

        l2 = lambda : a[d] # XXX just testing the expression

        l3 = lambda : [2 < x for x in [-1, 3, 0L]]

        self.assertEquals(l3(), [0, 1, 0])

        l4 = lambda x = lambda y = lambda z=1 : z : y() : x()

        self.assertEquals(l4(), 1)

        l5 = lambda x, y, z=2: x + y + z

        self.assertEquals(l5(1, 2), 5)

        self.assertEquals(l5(1, 2, 3), 6)

        check_syntax_error(self, "lambda x: x = 2")

        check_syntax_error(self, "lambda (None,): None")

    ### stmt: simple_stmt | compound_stmt

    # Tested below

    def testSimpleStmt(self):

        ### simple_stmt: small_stmt (';' small_stmt)* [';']

        x = 1; pass; del x

        def foo():

            # verify statments that end with semi-colons

            x = 1; pass; del x;

        foo()

    ### small_stmt: expr_stmt | print_stmt  | pass_stmt | del_stmt | flow_stmt | import_stmt | global_stmt | access_stmt | exec_stmt

    # Tested below

    def testExprStmt(self):

        # (exprlist '=')* exprlist

        1

        1, 2, 3

        x = 1

        x = 1, 2, 3

        x = y = z = 1, 2, 3

        x, y, z = 1, 2, 3

        abc = a, b, c = x, y, z = xyz = 1, 2, (3, 4)

        check_syntax_error(self, "x + 1 = 1")

        check_syntax_error(self, "a + 1 = b + 2")

    def testPrintStmt(self):

        # 'print' (test ',')* [test]

        import StringIO

        # Can't test printing to real stdout without comparing output

        # which is not available in unittest.

        save_stdout = sys.stdout

        sys.stdout = StringIO.StringIO()

        print 1, 2, 3

        print 1, 2, 3,

        print

        print 0 or 1, 0 or 1,

        print 0 or 1

        # 'print' '>>' test ','

        print >> sys.stdout, 1, 2, 3

        print >> sys.stdout, 1, 2, 3,

        print >> sys.stdout

        print >> sys.stdout, 0 or 1, 0 or 1,

        print >> sys.stdout, 0 or 1

        # test printing to an instance

        class Gulp:

            def write(self, msg): pass

        gulp = Gulp()

        print >> gulp, 1, 2, 3

        print >> gulp, 1, 2, 3,

        print >> gulp

        print >> gulp, 0 or 1, 0 or 1,

        print >> gulp, 0 or 1

        # test print >> None

        def driver():

            oldstdout = sys.stdout

            sys.stdout = Gulp()

            try:

                tellme(Gulp())

                tellme()

            finally:

                sys.stdout = oldstdout

        # we should see this once

        def tellme(file=sys.stdout):

            print >> file, 'hello world'

        driver()

        # we should not see this at all

        def tellme(file=None):

            print >> file, 'goodbye universe'

        driver()

        self.assertEqual(sys.stdout.getvalue(), '''\

1 2 3

1 2 3

1 1 1

1 2 3

1 2 3

1 1 1

hello world

''')

        sys.stdout = save_stdout

        # syntax errors

        check_syntax_error(self, 'print ,')

        check_syntax_error(self, 'print >> x,')

    def testDelStmt(self):

        # 'del' exprlist

        abc = [1,2,3]

        x, y, z = abc

        xyz = x, y, z

        del abc

        del x, y, (z, xyz)

    def testPassStmt(self):

        # 'pass'

        pass

    # flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt

    # Tested below

    def testBreakStmt(self):

        # 'break'

        while 1: break

    def testContinueStmt(self):

        # 'continue'

        i = 1

        while i: i = 0; continue

        msg = ""

        while not msg:

            msg = "ok"

            try:

                continue

                msg = "continue failed to continue inside try"

            except:

                msg = "continue inside try called except block"

        if msg != "ok":

            self.fail(msg)

        msg = ""

        while not msg:

            msg = "finally block not called"

            try:

                continue

            finally:

                msg = "ok"

        if msg != "ok":

            self.fail(msg)

    def test_break_continue_loop(self):

        # This test warrants an explanation. It is a test specifically for SF bugs

        # #463359 and #462937. The bug is that a 'break' statement executed or

        # exception raised inside a try/except inside a loop, *after* a continue

        # statement has been executed in that loop, will cause the wrong number of

        # arguments to be popped off the stack and the instruction pointer reset to

        # a very small number (usually 0.) Because of this, the following test

        # *must* written as a function, and the tracking vars *must* be function

        # arguments with default values. Otherwise, the test will loop and loop.

        def test_inner(extra_burning_oil = 1, count=0):

            big_hippo = 2

            while big_hippo:

                count += 1

                try:

                    if extra_burning_oil and big_hippo == 1:

                        extra_burning_oil -= 1

                        break

                    big_hippo -= 1

                    continue

                except:

                    raise

            if count > 2 or big_hippo <> 1:

                self.fail("continue then break in try/except in loop broken!")

        test_inner()

    def testReturn(self):

        # 'return' [testlist]

        def g1(): return

        def g2(): return 1

        g1()

        x = g2()

        check_syntax_error(self, "class foo:return 1")

    def testYield(self):

        check_syntax_error(self, "class foo:yield 1")

    def testRaise(self):

        # 'raise' test [',' test]

        try: raise RuntimeError, 'just testing'

        except RuntimeError: pass

        try: raise KeyboardInterrupt

        except KeyboardInterrupt: pass

    def testImport(self):

        # 'import' dotted_as_names

        import sys

        import time, sys

        # 'from' dotted_name 'import' ('*' | '(' import_as_names ')' | import_as_names)

        from time import time

        from time import (time)

        # not testable inside a function, but already done at top of the module

        # from sys import *

        from sys import path, argv

        from sys import (path, argv)

        from sys import (path, argv,)

    def testGlobal(self):

        # 'global' NAME (',' NAME)*

        global a

        global a, b

        global one, two, three, four, five, six, seven, eight, nine, ten

    def testExec(self):

        # 'exec' expr ['in' expr [',' expr]]

        z = None

        del z

        exec 'z=1+1\n'

        if z != 2: self.fail('exec \'z=1+1\'\\n')

        del z

        exec 'z=1+1'

        if z != 2: self.fail('exec \'z=1+1\'')

        z = None

        del z

        import types