#!/usr/bin/env python2.5

""" Test suite for the fixer modules """

# Author: Collin Winter

# Testing imports

try:

    from tests import support

except ImportError:

    import support

# Python imports

import os

import unittest

from itertools import chain

from operator import itemgetter

# Local imports

from lib2to3 import pygram, pytree, refactor, fixer_util

class FixerTestCase(support.TestCase):

    def setUp(self, fix_list=None):

        if fix_list is None:

            fix_list = [self.fixer]

        options = {"print_function" : False}

        self.refactor = support.get_refactorer(fix_list, options)

        self.fixer_log = []

        self.filename = "<string>"

        for fixer in chain(self.refactor.pre_order,

                           self.refactor.post_order):

            fixer.log = self.fixer_log

    def _check(self, before, after):

        before = support.reformat(before)

        after = support.reformat(after)

        tree = self.refactor.refactor_string(before, self.filename)

        self.failUnlessEqual(after, str(tree))

        return tree

    def check(self, before, after, ignore_warnings=False):

        tree = self._check(before, after)

        self.failUnless(tree.was_changed)

        if not ignore_warnings:

            self.failUnlessEqual(self.fixer_log, [])

    def warns(self, before, after, message, unchanged=False):

        tree = self._check(before, after)

        self.failUnless(message in "".join(self.fixer_log))

        if not unchanged:

            self.failUnless(tree.was_changed)

    def warns_unchanged(self, before, message):

        self.warns(before, before, message, unchanged=True)

    def unchanged(self, before, ignore_warnings=False):

        self._check(before, before)

        if not ignore_warnings:

            self.failUnlessEqual(self.fixer_log, [])

    def assert_runs_after(self, *names):

        fixes = [self.fixer]

        fixes.extend(names)

        options = {"print_function" : False}

        r = support.get_refactorer(fixes, options)

        (pre, post) = r.get_fixers()

        n = "fix_" + self.fixer

        if post and post[-1].__class__.__module__.endswith(n):

            # We're the last fixer to run

            return

        if pre and pre[-1].__class__.__module__.endswith(n) and not post:

            # We're the last in pre and post is empty

            return

        self.fail("Fixer run order (%s) is incorrect; %s should be last."\

               %(", ".join([x.__class__.__module__ for x in (pre+post)]), n))

class Test_ne(FixerTestCase):

    fixer = "ne"

    def test_basic(self):

        b = """if x <> y:

            pass"""

        a = """if x != y:

            pass"""

        self.check(b, a)

    def test_no_spaces(self):

        b = """if x<>y:

            pass"""

        a = """if x!=y:

            pass"""

        self.check(b, a)

    def test_chained(self):

        b = """if x<>y<>z:

            pass"""

        a = """if x!=y!=z:

            pass"""

        self.check(b, a)

class Test_has_key(FixerTestCase):

    fixer = "has_key"

    def test_1(self):

        b = """x = d.has_key("x") or d.has_key("y")"""

        a = """x = "x" in d or "y" in d"""

        self.check(b, a)

    def test_2(self):

        b = """x = a.b.c.d.has_key("x") ** 3"""

        a = """x = ("x" in a.b.c.d) ** 3"""

        self.check(b, a)

    def test_3(self):

        b = """x = a.b.has_key(1 + 2).__repr__()"""

        a = """x = (1 + 2 in a.b).__repr__()"""

        self.check(b, a)

    def test_4(self):

        b = """x = a.b.has_key(1 + 2).__repr__() ** -3 ** 4"""

        a = """x = (1 + 2 in a.b).__repr__() ** -3 ** 4"""

        self.check(b, a)

    def test_5(self):

        b = """x = a.has_key(f or g)"""

        a = """x = (f or g) in a"""

        self.check(b, a)

    def test_6(self):

        b = """x = a + b.has_key(c)"""

        a = """x = a + (c in b)"""

        self.check(b, a)

    def test_7(self):

        b = """x = a.has_key(lambda: 12)"""

        a = """x = (lambda: 12) in a"""

        self.check(b, a)

    def test_8(self):

        b = """x = a.has_key(a for a in b)"""

        a = """x = (a for a in b) in a"""

        self.check(b, a)

    def test_9(self):

        b = """if not a.has_key(b): pass"""

        a = """if b not in a: pass"""

        self.check(b, a)

    def test_10(self):

        b = """if not a.has_key(b).__repr__(): pass"""

        a = """if not (b in a).__repr__(): pass"""

        self.check(b, a)

    def test_11(self):

        b = """if not a.has_key(b) ** 2: pass"""

        a = """if not (b in a) ** 2: pass"""

        self.check(b, a)

class Test_apply(FixerTestCase):

    fixer = "apply"

    def test_1(self):

        b = """x = apply(f, g + h)"""

        a = """x = f(*g + h)"""

        self.check(b, a)

    def test_2(self):

        b = """y = apply(f, g, h)"""

        a = """y = f(*g, **h)"""

        self.check(b, a)

    def test_3(self):

        b = """z = apply(fs[0], g or h, h or g)"""

        a = """z = fs[0](*g or h, **h or g)"""

        self.check(b, a)

    def test_4(self):

        b = """apply(f, (x, y) + t)"""

        a = """f(*(x, y) + t)"""

        self.check(b, a)

    def test_5(self):

        b = """apply(f, args,)"""

        a = """f(*args)"""

        self.check(b, a)

    def test_6(self):

        b = """apply(f, args, kwds,)"""

        a = """f(*args, **kwds)"""

        self.check(b, a)

    # Test that complex functions are parenthesized

    def test_complex_1(self):

        b = """x = apply(f+g, args)"""

        a = """x = (f+g)(*args)"""

        self.check(b, a)

    def test_complex_2(self):

        b = """x = apply(f*g, args)"""

        a = """x = (f*g)(*args)"""

        self.check(b, a)

    def test_complex_3(self):

        b = """x = apply(f**g, args)"""

        a = """x = (f**g)(*args)"""

        self.check(b, a)

    # But dotted names etc. not

    def test_dotted_name(self):

        b = """x = apply(f.g, args)"""

        a = """x = f.g(*args)"""

        self.check(b, a)

    def test_subscript(self):

        b = """x = apply(f[x], args)"""

        a = """x = f[x](*args)"""

        self.check(b, a)

    def test_call(self):

        b = """x = apply(f(), args)"""

        a = """x = f()(*args)"""

        self.check(b, a)

    # Extreme case

    def test_extreme(self):

        b = """x = apply(a.b.c.d.e.f, args, kwds)"""

        a = """x = a.b.c.d.e.f(*args, **kwds)"""

        self.check(b, a)

    # XXX Comments in weird places still get lost

    def test_weird_comments(self):

        b = """apply(   # foo

          f, # bar

          args)"""

        a = """f(*args)"""

        self.check(b, a)

    # These should *not* be touched

    def test_unchanged_1(self):

        s = """apply()"""

        self.unchanged(s)

    def test_unchanged_2(self):

        s = """apply(f)"""

        self.unchanged(s)

    def test_unchanged_3(self):

        s = """apply(f,)"""

        self.unchanged(s)

    def test_unchanged_4(self):

        s = """apply(f, args, kwds, extras)"""

        self.unchanged(s)

    def test_unchanged_5(self):

        s = """apply(f, *args, **kwds)"""

        self.unchanged(s)

    def test_unchanged_6(self):

        s = """apply(f, *args)"""

        self.unchanged(s)

    def test_unchanged_7(self):

        s = """apply(func=f, args=args, kwds=kwds)"""

        self.unchanged(s)

    def test_unchanged_8(self):

        s = """apply(f, args=args, kwds=kwds)"""

        self.unchanged(s)

    def test_unchanged_9(self):

        s = """apply(f, args, kwds=kwds)"""

        self.unchanged(s)

    def test_space_1(self):

        a = """apply(  f,  args,   kwds)"""

        b = """f(*args, **kwds)"""

        self.check(a, b)

    def test_space_2(self):

        a = """apply(  f  ,args,kwds   )"""

        b = """f(*args, **kwds)"""

        self.check(a, b)

class Test_intern(FixerTestCase):

    fixer = "intern"

    def test_prefix_preservation(self):

        b = """x =   intern(  a  )"""

        a = """x =   sys.intern(  a  )"""

        self.check(b, a)

        b = """y = intern("b" # test

              )"""

        a = """y = sys.intern("b" # test

              )"""

        self.check(b, a)

        b = """z = intern(a+b+c.d,   )"""

        a = """z = sys.intern(a+b+c.d,   )"""

        self.check(b, a)

    def test(self):

        b = """x = intern(a)"""

        a = """x = sys.intern(a)"""

        self.check(b, a)

        b = """z = intern(a+b+c.d,)"""

        a = """z = sys.intern(a+b+c.d,)"""

        self.check(b, a)

        b = """intern("y%s" % 5).replace("y", "")"""

        a = """sys.intern("y%s" % 5).replace("y", "")"""

        self.check(b, a)

    # These should not be refactored

    def test_unchanged(self):

        s = """intern(a=1)"""

        self.unchanged(s)

        s = """intern(f, g)"""

        self.unchanged(s)

        s = """intern(*h)"""

        self.unchanged(s)

        s = """intern(**i)"""

        self.unchanged(s)

        s = """intern()"""

        self.unchanged(s)

class Test_print(FixerTestCase):

    fixer = "print"

    def test_prefix_preservation(self):

        b = """print 1,   1+1,   1+1+1"""

        a = """print(1,   1+1,   1+1+1)"""

        self.check(b, a)

    def test_idempotency(self):

        s = """print()"""

        self.unchanged(s)

        s = """print('')"""

        self.unchanged(s)

    def test_idempotency_print_as_function(self):

        print_stmt = pygram.python_grammar.keywords.pop("print")

        try:

            s = """print(1, 1+1, 1+1+1)"""

            self.unchanged(s)

            s = """print()"""

            self.unchanged(s)

            s = """print('')"""

            self.unchanged(s)

        finally:

            pygram.python_grammar.keywords["print"] = print_stmt

    def test_1(self):

        b = """print 1, 1+1, 1+1+1"""

        a = """print(1, 1+1, 1+1+1)"""

        self.check(b, a)

    def test_2(self):

        b = """print 1, 2"""

        a = """print(1, 2)"""

        self.check(b, a)

    def test_3(self):

        b = """print"""

        a = """print()"""

        self.check(b, a)

    def test_4(self):

        # from bug 3000

        b = """print whatever; print"""

        a = """print(whatever); print()"""

        self.check(b, a)

    def test_5(self):

        b = """print; print whatever;"""

        a = """print(); print(whatever);"""

    def test_tuple(self):

        b = """print (a, b, c)"""

        a = """print((a, b, c))"""

        self.check(b, a)

    # trailing commas

    def test_trailing_comma_1(self):

        b = """print 1, 2, 3,"""

        a = """print(1, 2, 3, end=' ')"""

        self.check(b, a)

    def test_trailing_comma_2(self):

        b = """print 1, 2,"""

        a = """print(1, 2, end=' ')"""

        self.check(b, a)

    def test_trailing_comma_3(self):

        b = """print 1,"""

        a = """print(1, end=' ')"""

        self.check(b, a)

    # >> stuff

    def test_vargs_without_trailing_comma(self):

        b = """print >>sys.stderr, 1, 2, 3"""

        a = """print(1, 2, 3, file=sys.stderr)"""

        self.check(b, a)

    def test_with_trailing_comma(self):

        b = """print >>sys.stderr, 1, 2,"""

        a = """print(1, 2, end=' ', file=sys.stderr)"""

        self.check(b, a)

    def test_no_trailing_comma(self):

        b = """print >>sys.stderr, 1+1"""

        a = """print(1+1, file=sys.stderr)"""

        self.check(b, a)

    def test_spaces_before_file(self):

        b = """print >>  sys.stderr"""

        a = """print(file=sys.stderr)"""

        self.check(b, a)

    # With from __future__ import print_function

    def test_with_future_print_function(self):

        # XXX: These tests won't actually do anything until the parser

        #      is fixed so it won't crash when it sees print(x=y).

        #      When #2412 is fixed, the try/except block can be taken

        #      out and the tests can be run like normal.

        # MvL: disable entirely for now, so that it doesn't print to stdout

        return

        try:

            s = "from __future__ import print_function\n"\

                "print('Hai!', end=' ')"

            self.unchanged(s)

            b = "print 'Hello, world!'"

            a = "print('Hello, world!')"

            self.check(b, a)

            s = "from __future__ import *\n"\

                "print('Hai!', end=' ')"

            self.unchanged(s)

        except:

            return

        else:

            self.assertFalse(True, "#2421 has been fixed -- printing tests "\

                                   "need to be updated!")

class Test_exec(FixerTestCase):

    fixer = "exec"

    def test_prefix_preservation(self):

        b = """  exec code in ns1,   ns2"""

        a = """  exec(code, ns1,   ns2)"""

        self.check(b, a)

    def test_basic(self):

        b = """exec code"""

        a = """exec(code)"""

        self.check(b, a)

    def test_with_globals(self):

        b = """exec code in ns"""

        a = """exec(code, ns)"""

        self.check(b, a)

    def test_with_globals_locals(self):

        b = """exec code in ns1, ns2"""

        a = """exec(code, ns1, ns2)"""

        self.check(b, a)

    def test_complex_1(self):

        b = """exec (a.b()) in ns"""

        a = """exec((a.b()), ns)"""

        self.check(b, a)

    def test_complex_2(self):

        b = """exec a.b() + c in ns"""

        a = """exec(a.b() + c, ns)"""

        self.check(b, a)

    # These should not be touched

    def test_unchanged_1(self):

        s = """exec(code)"""

        self.unchanged(s)

    def test_unchanged_2(self):

        s = """exec (code)"""

        self.unchanged(s)

    def test_unchanged_3(self):

        s = """exec(code, ns)"""

        self.unchanged(s)

    def test_unchanged_4(self):

        s = """exec(code, ns1, ns2)"""

        self.unchanged(s)

class Test_repr(FixerTestCase):

    fixer = "repr"

    def test_prefix_preservation(self):

        b = """x =   `1 + 2`"""

        a = """x =   repr(1 + 2)"""

        self.check(b, a)

    def test_simple_1(self):

        b = """x = `1 + 2`"""

        a = """x = repr(1 + 2)"""

        self.check(b, a)

    def test_simple_2(self):