"""
   Test cases for codeop.py
   Nick Mathewson
"""
import unittest
import warnings
from test.support import subTests, warnings_helper
from textwrap import dedent
import functools

from codeop import compile_command, CommandCompiler, Compile
from codeop import PyCF_DONT_IMPLY_DEDENT, PyCF_ONLY_AST
import ast


WRAPPING_COMPILERS = [compile_command, CommandCompiler()]
RAW_COMPILERS = [Compile()]
COMPILERS = WRAPPING_COMPILERS + RAW_COMPILERS


class CodeopTests(unittest.TestCase):
    def assertValid(self, str, symbol='single', *, compiler):
        '''succeed iff str is a valid piece of code'''
        expected = compile(str, "<input>", symbol, PyCF_DONT_IMPLY_DEDENT)
        self.assertEqual(compiler(str, "<input>", symbol), expected)

    def assertIncomplete(self, str, symbol='single', *, compiler):
        '''succeed iff str is the start of a valid piece of code'''
        if compiler in WRAPPING_COMPILERS:
            self.assertEqual(compiler(str, "<input>", symbol=symbol), None)
        else:
            # Compile has should raise like built-in compile
            with self.assertRaises(SyntaxError) as cm_original_error:
                compile(str, "<input>", symbol, compiler.flags)
            expected_error = cm_original_error.exception
            with self.assertRaises(type(expected_error)) as cm_wrapped_error:
                compiler(str, "<input>", symbol=symbol)
            self.assertEqual(
                expected_error.args,
                cm_wrapped_error.exception.args
            )

    def assertInvalid(self, str, symbol='single', is_syntax=1, *, compiler):
        '''succeed iff str is the start of an invalid piece of code'''
        try:
            compiler(str,"<input>", symbol=symbol)
            self.fail("No exception raised for invalid code")
        except SyntaxError:
            self.assertTrue(is_syntax)
        except OverflowError:
            self.assertTrue(not is_syntax)

    @subTests('compiler', WRAPPING_COMPILERS)
    def test_empty(self, compiler):
        self.assertEqual(
            compiler("", "<input>", 'single'),
            compile("pass", "<input>", 'single', PyCF_DONT_IMPLY_DEDENT))
        self.assertEqual(
            compiler("\n", "<input>", 'single'),
            compile("pass", "<input>", 'single', PyCF_DONT_IMPLY_DEDENT))

    @subTests('compiler', COMPILERS)
    def test_valid(self, compiler):
        av = functools.partial(self.assertValid, compiler=compiler)
        av("a = 1")
        av("\na = 1")
        av("a = 1\n")
        av("a = 1\n\n")
        av("\n\na = 1\n\n")

        av("def x():\n  pass\n")
        av("if 1:\n pass\n")

        av("\n\nif 1: pass\n")
        av("\n\nif 1: pass\n\n")

        av("def x():\n\n pass\n")
        av("def x():\n  pass\n  \n")
        av("def x():\n  pass\n \n")

        av("pass\n")
        av("3**3\n")

        av("if 9==3:\n   pass\nelse:\n   pass\n")
        av("if 1:\n pass\n if 1:\n  pass\n else:\n  pass\n")

        av("#a\n#b\na = 3\n")
        av("#a\n\n   \na=3\n")
        av("a=3\n\n")
        av("a = 9+ \\\n3")

        av("3**3","eval")
        av("(lambda z: \n z**3)","eval")

        av("9+ \\\n3","eval")
        av("9+ \\\n3\n","eval")

        av("\n\na**3","eval")
        av("\n \na**3","eval")
        av("#a\n#b\na**3","eval")

        av("\n\na = 1\n\n")
        av("\n\nif 1: a=1\n\n")

        av("if 1:\n pass\n if 1:\n  pass\n else:\n  pass\n")
        av("#a\n\n   \na=3\n\n")

        av("\n\na**3","eval")
        av("\n \na**3","eval")
        av("#a\n#b\na**3","eval")

        av("def f():\n try: pass\n finally: [x for x in (1,2)]\n")
        av("def f():\n pass\n#foo\n")
        av("@a.b.c\ndef f():\n pass\n")

    @subTests('symbol', ('single', 'exec'))
    @subTests('prefix', ('', 'f', 't'))
    def test_incomplete_string_diagnostics(self, symbol, prefix):
        opening = f'    á = {prefix}"""first\n'
        source = 'if True:\n' + opening + 'second'
        with self.assertRaises(_IncompleteInputError) as cm:
            Compile()(source, '<input>', symbol)
        text = opening + 'second' + ('\n' if symbol == 'exec' else '')
        self.assertEqual(cm.exception.args, (
            'incomplete input', ('<input>', 2, 9, text, 2, -1)))

    @subTests('compiler', COMPILERS)
    @subTests('newline', ('\n', '\r', '\r\n'))
    def test_unterminated_trailing_line(self, compiler, newline):
        for head, symbol in (('1', 'eval'), ('if 1: pass', 'single'),
                             ('if 1:\n pass', 'single')):
            for tail in (' ', '\t', '\f ', '\n '):
                source = head + newline + tail
                with self.subTest(source=source, symbol=symbol):
                    if compiler in RAW_COMPILERS:
                        with self.assertRaises(_IncompleteInputError):
                            compiler(source, '<input>', symbol)
                    else:
                        self.assertIsNone(compiler(source, '<input>', symbol))
                    self.assertValid(source + '\n', symbol, compiler=compiler)
            for tail in ('\f', ' \f', '\n\f'):
                with self.subTest(head=head, tail=tail, symbol=symbol):
                    self.assertValid(head + newline + tail, symbol,
                                     compiler=compiler)

        for tail in ('# comment', ' # comment'):
            self.assertValid('if 1: pass' + newline + tail, compiler=compiler)
            self.assertValid('1' + newline + tail, 'eval', compiler=compiler)

        for head in ('1', 'if 1: pass', 'if 1:\n pass'):
            for tail in (' ', '\t', '\f', '# comment'):
                self.assertValid(head + newline + tail, 'exec',
                                 compiler=compiler)

    @subTests('symbol', ('single', 'exec', 'eval'))
    def test_unfinished_token_in_invalid_position(self, symbol):
        for source in ('a b', '(a b', '1 """', '(1 """',
                       'f"{lambda:\\', 't"{lambda:\\'):
            for compiler in COMPILERS:
                with self.subTest(source=source, compiler=compiler):
                    with self.assertRaises(SyntaxError) as cm:
                        compiler(source, '<input>', symbol)
                    self.assertNotIsInstance(cm.exception, _IncompleteInputError)

    @subTests('symbol', ('single', 'exec', 'eval'))
    def test_invalid_partial_string_diagnostic(self, symbol):
        with self.assertRaisesRegex(SyntaxError, 'invalid syntax'):
            Compile()('a"""', '<input>', symbol)

    @subTests('symbol', ('single', 'exec', 'eval'))
    @subTests('prefix', ('', 'r', 'b', 'f', 't', 'rf', 'rt'))
    def test_string_continuation(self, symbol, prefix):
        source = prefix + '"first\\'
        compile(source + '\nsecond"\n', '<input>', symbol)
        self.assertIsNone(compile_command(source, symbol=symbol))
        with self.assertRaises(_IncompleteInputError):
            Compile()(source, '<input>', symbol)

    @subTests('symbol', ('single', 'exec', 'eval'))
    @subTests('newline', ('\n', '\r', '\r\n'))
    def test_continued_final_line(self, symbol, newline):
        source = '1\\' + newline
        compile(source + '+ 2\n', '<input>', symbol)
        self.assertIsNone(compile_command(source, symbol=symbol))
        with self.assertRaises(_IncompleteInputError):
            Compile()(source, '<input>', symbol)
        with self.assertRaises(SyntaxError) as cm:
            Compile()('1 + \\' + newline, '<input>', symbol)
        # Appending LF to CR completes the CRLF line terminator.
        if newline != '\r':
            self.assertNotIsInstance(cm.exception, _IncompleteInputError)

    @subTests('symbol', ('single', 'exec'))
    def test_eof_before_nested_body(self, symbol):
        for source in ('if True:\n    if True:',
                       'if True:\n    def f():',
                       'match 1:\n    case 1:'):
            for tail in ('', '\n', '\n\n'):
                with self.subTest(source=source, tail=tail):
                    compile(source + tail + '\n        pass\n', '<input>', symbol)
                    self.assertIsNone(compile_command(source + tail, symbol=symbol))
                    with self.assertRaises(_IncompleteInputError):
                        Compile()(source + tail, '<input>', symbol)

    def test_incomplete_suite_semantic_errors(self):
        cases = (
            ('if True: break', "'break' outside loop"),
            ('if True: return 1', "'return' outside function"),
            ('def f(x, x):\n    pass', 'duplicate parameter'),
        )
        for source, message in cases:
            for compiler in COMPILERS:
                with self.subTest(source=source, compiler=compiler):
                    with self.assertRaises(SyntaxError) as cm:
                        compiler(source, '<input>', 'single')
                    self.assertNotIsInstance(cm.exception, _IncompleteInputError)
                    if compiler in RAW_COMPILERS:
                        self.assertIn(message, str(cm.exception))

    @subTests('compiler', COMPILERS)
    def test_incomplete(self, compiler):
        ai = functools.partial(self.assertIncomplete, compiler=compiler)

        ai("(a **")
        ai("(a,b,")
        ai("(a,b,(")
        ai("(a,b,(")
        ai("a = (")
        ai("a = {")
        ai("b + {")

        ai("print([1,\n2,")
        ai("print({1:1,\n2:3,")
        ai("print((1,\n2,")

        ai("if 9==3:\n   pass\nelse:")
        ai("if 9==3:\n   pass\nelse:\n")
        ai("if 9==3:\n   pass\nelse:\n   pass")
        ai("if 1:")
        ai("if 1:\n")
        ai("if 1:\n pass\n if 1:\n  pass\n else:")
        ai("if 1:\n pass\n if 1:\n  pass\n else:\n")
        ai("if 1:\n pass\n if 1:\n  pass\n else:\n  pass")

        ai("def x():")
        ai("def x():\n")
        ai("def x():\n\n")

        ai("def x():\n  pass")
        ai("def x():\n  pass\n ")
        ai("def x():\n  pass\n  ")
        ai("\n\ndef x():\n  pass")

        ai("a = 9+ \\")
        ai("a = 'a\\")
        ai("a = '''xy")

        ai("","eval")
        ai("\n","eval")
        ai("(","eval")
        ai("(9+","eval")
        ai("9+ \\","eval")
        ai("lambda z: \\","eval")

        ai("if True:\n if True:\n  if True:   \n")

        ai("@a(")
        ai("@a(b")
        ai("@a(b,")
        ai("@a(b,c")
        ai("@a(b,c,")

        ai("from a import (")
        ai("from a import (b")
        ai("from a import (b,")
        ai("from a import (b,c")
        ai("from a import (b,c,")

        ai("[")
        ai("[a")
        ai("[a,")
        ai("[a,b")
        ai("[a,b,")

        ai("{")
        ai("{a")
        ai("{a:")
        ai("{a:b")
        ai("{a:b,")
        ai("{a:b,c")
        ai("{a:b,c:")
        ai("{a:b,c:d")
        ai("{a:b,c:d,")

        ai("a(")
        ai("a(b")
        ai("a(b,")
        ai("a(b,c")
        ai("a(b,c,")

        ai("a[")
        ai("a[b")
        ai("a[b,")
        ai("a[b:")
        ai("a[b:c")
        ai("a[b:c:")
        ai("a[b:c:d")

        ai("def a(")
        ai("def a(b")
        ai("def a(b,")
        ai("def a(b,c")
        ai("def a(b,c,")

        ai("(")
        ai("(a")
        ai("(a,")
        ai("(a,b")
        ai("(a,b,")

        ai("if a:\n pass\nelif b:")
        ai("if a:\n pass\nelif b:\n pass\nelse:")

        ai("while a:")
        ai("while a:\n pass\nelse:")

        ai("for a in b:")
        ai("for a in b:\n pass\nelse:")

        ai("try:")
        ai("try:\n pass\nexcept:")
        ai("try:\n pass\nfinally:")
        ai("try:\n pass\nexcept:\n pass\nfinally:")

        ai("with a:")
        ai("with a as b:")

        ai("class a:")
        ai("class a(")
        ai("class a(b")
        ai("class a(b,")
        ai("class a():")

        ai("[x for")
        ai("[x for x in")
        ai("[x for x in (")

        ai("(x for")
        ai("(x for x in")
        ai("(x for x in (")

        ai('a = f"""')
        ai('a = \\')

    @subTests('compiler', COMPILERS)
    def test_invalid(self, compiler):
        ai = functools.partial(self.assertInvalid, compiler=compiler)
        ai("a b")

        ai("a @")
        ai("a b @")
        ai("a ** @")

        ai("a = ")
        ai("a = 9 +")

        ai("def x():\n\npass\n")

        ai("\n\n if 1: pass\n\npass")

        ai("a = 9+ \\\n")
        ai("a = 'a\\ ")
        ai("a = 'a\\\n")

        ai("a = 1","eval")
        ai("]","eval")
        ai("())","eval")
        ai("[}","eval")
        ai("9+","eval")
        ai("lambda z:","eval")
        ai("a b","eval")

        ai("return 2.3")
        ai("if (a == 1 and b = 2): pass")

        ai("del 1")
        ai("del (1,)")
        ai("del [1]")
        ai("del '1'")

        ai("[i for i in range(10)] = (1, 2, 3)")

    @subTests('compiler', COMPILERS)
    def test_invalid_exec(self, compiler):
        ai = functools.partial(self.assertInvalid, compiler=compiler)
        ai("raise = 4", symbol="exec")
        ai('def a-b', symbol='exec')
        ai('await?', symbol='exec')
        ai('=!=', symbol='exec')
        ai('a await raise b', symbol='exec')
        ai('a await raise b?+1', symbol='exec')

    @subTests('compiler', COMPILERS)
    def test_filename(self, compiler):
        self.assertEqual(
            compiler("a = 1\n", "abc", "single").co_filename,
            compile("a = 1\n", "abc", 'single').co_filename
        )
        self.assertNotEqual(
            compiler("a = 1\n", "abc", "single").co_filename,
            compile("a = 1\n", "def", 'single').co_filename
        )

    def assertReturnsModule(self, code, compiler):
        retval = compiler(code, "<input>", 'exec', PyCF_ONLY_AST)
        self.assertIsInstance(retval, ast.Module)

    @subTests('compiler', RAW_COMPILERS)
    def test_ast_return_value(self, compiler):
        validate_ast = self.assertReturnsModule
        validate_ast("x = 5", compiler)
        validate_ast("\nx = 5", compiler)
        validate_ast("x = 5\n", compiler)
        validate_ast("x = 5\n\n", compiler)
        validate_ast("\n\nx = 5\n\n", compiler)

    @subTests('compiler', COMPILERS)
    def test_warning(self, compiler):
        # Test that the warning is only returned once.
        with warnings_helper.check_warnings(
                ('"is" with \'str\' literal', SyntaxWarning),
                ('"\\\\e" is an invalid escape sequence', SyntaxWarning),
                ) as w:
            compiler(r"'\e' is 0", "<input>", "single")
        self.assertEqual(len(w.warnings), 2)

        # bpo-41520: check SyntaxWarning treated as an SyntaxError
        with warnings.catch_warnings(), self.assertRaises(SyntaxError):
            warnings.simplefilter('error', SyntaxWarning)
            compiler('1 is 1', "<input>", 'exec')

        # Check SyntaxWarning treated as an SyntaxError
        with warnings.catch_warnings(), self.assertRaises(SyntaxError):
            warnings.simplefilter('error', SyntaxWarning)
            compiler(r"'\e'", "<input>", 'exec')

    @subTests('compiler', WRAPPING_COMPILERS)
    def test_incomplete_warning(self, compiler):
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter('always')
        compiler("'\\e' + (")
        self.assertEqual(w, [])

    @subTests('compiler', RAW_COMPILERS)
    def test_raw_raises_error(self, compiler):
        warnings_cm = warnings_helper.check_warnings(
            ('"\\\\e" is an invalid esceape sequence', SyntaxWarning)
        )
        with self.assertRaises(SyntaxError), warnings_cm as w:
            compiler("'\\e' + (", "<input>", 'single')
        self.assertEqual(len(w.warnings), 1)

    @subTests('compiler', COMPILERS)
    def test_invalid_warning(self, compiler):
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter('always')
            self.assertInvalid("'\\e' 1", compiler=compiler)
        self.assertEqual(len(w), 1)
        for warning in w:
            self.assertEqual(warning.category, SyntaxWarning)
            self.assertRegex(str(warning), 'invalid escape sequence')
            self.assertEqual(warning.filename, '<input>')

    @subTests('compiler', COMPILERS)
    def test_syntax_errors(self, compiler):
        code = dedent("""\
                def foo(x,x):
                   pass
            """)
        message = "duplicate parameter 'x' in function definition"
        with self.assertRaisesRegex(SyntaxError, message):
            compiler(code, "<input>", 'exec')

    @subTests('compiler', RAW_COMPILERS)
    def test_future_imports(self, compiler):
        original_flags = compiler.flags
        compiler('from __future__ import annotations', "<input>", 'single')
        self.assertGreater(compiler.flags, original_flags)
        # reset flags to ensure test has no side-effects
        compiler.flags = original_flags


if __name__ == "__main__":
    unittest.main()