test_libfuturize_fixers.py

""" Test suite for the fixer modules.

Based on lib2to3/tests/test_fixers.py

"""
# Support code for test_*.py files, from lib2to3/tests/support.py by Collin Winter:

# Python imports
import sys
import os
import os.path
from itertools import chain
from textwrap import dedent
from operator import itemgetter
from lib2to3 import pygram, pytree, refactor, fixer_util
from lib2to3.pgen2 import driver

# Local imports
from future.tests.base import unittest
from future.builtins import str


test_dir = os.path.dirname(__file__)
proj_dir = os.path.normpath(os.path.join(test_dir, ".."))
# grammar_path = os.path.join(test_dir, "..", "Grammar.txt")
# grammar = driver.load_grammar(grammar_path)
# driver = driver.Driver(grammar, convert=pytree.convert)
#
# def parse_string(string):
#     return driver.parse_string(reformat(string), debug=True)

def run_all_tests(test_mod=None, tests=None):
    if tests is None:
        tests = unittest.TestLoader().loadTestsFromModule(test_mod)
    unittest.TextTestRunner(verbosity=2).run(tests)

def reformat(string):
    return dedent(string) + u"\n\n"

def get_refactorer(fixer_pkg="lib2to3", fixers=None, options=None):
    """
    A convenience function for creating a RefactoringTool for tests.

    fixers is a list of fixers for the RefactoringTool to use. By default
    "lib2to3.fixes.*" is used. options is an optional dictionary of options to
    be passed to the RefactoringTool.
    """
    if fixers is not None:
        fixers = [fixer_pkg + ".fixes.fix_" + fix for fix in fixers]
    else:
        fixers = refactor.get_fixers_from_package(fixer_pkg + ".fixes")
    options = options or {}
    return refactor.RefactoringTool(fixers, options, explicit=True)

def all_project_files():
    for dirpath, dirnames, filenames in os.walk(proj_dir):
        for filename in filenames:
            if filename.endswith(".py"):
                yield os.path.join(dirpath, filename)


class FixerTestCase(unittest.TestCase):

    # Other test cases can subclass this class and replace "fixer_pkg" with
    # their own.
    def setUp(self, fix_list=None, fixer_pkg="libfuturize", options=None):
        if fix_list is None:
            fix_list = [self.fixer]
        self.refactor = get_refactorer(fixer_pkg, fix_list, options)
        self.fixer_log = []
        self.filename = u"<string>"

        for fixer in chain(self.refactor.pre_order,
                           self.refactor.post_order):
            fixer.log = self.fixer_log

    def _check(self, before, after):
        before = reformat(before)
        after = reformat(after)
        tree = self.refactor.refactor_string(before, self.filename)
        self.assertEqual(after, str(tree))
        return tree

    def check(self, before, after, ignore_warnings=False):
        tree = self._check(before, after)
        self.assertTrue(tree.was_changed)
        if not ignore_warnings:
            self.assertEqual(self.fixer_log, [])

    def warns(self, before, after, message, unchanged=False):
        tree = self._check(before, after)
        self.assertTrue(message in "".join(self.fixer_log))
        if not unchanged:
            self.assertTrue(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.assertEqual(self.fixer_log, [])

    def assert_runs_after(self, *names):
        fixes = [self.fixer]
        fixes.extend(names)
        r = get_refactorer("lib2to3", fixes)
        (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))


############### EDIT the tests below ...
#
# class Test_ne(FixerTestCase):
#     fixer = "ne"
#
#     def test_basic(self):
#         b = """if x <> y:
#             pass"""
#
#         a = """if x != y:
#             pass"""
#         self.check(b, a)
#
#
# class Test_print(FixerTestCase):
#     fixer = "print_"
#
#     def test_print(self):
#         b = """print 'Hello world'"""
#         a = """from __future__ import print_function\nprint('Hello world')"""
#         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)
#
#
# class Test_intern(FixerTestCase):
#     fixer = "intern"
#
#     def test_prefix_preservation(self):
#         b = """x =   intern(  a  )"""
#         a = """import sys\nx =   sys.intern(  a  )"""
#         self.check(b, a)
#
#         b = """y = intern("b" # test
#               )"""
#         a = """import sys\ny = sys.intern("b" # test
#               )"""
#         self.check(b, a)
#
#         b = """z = intern(a+b+c.d,   )"""
#         a = """import sys\nz = sys.intern(a+b+c.d,   )"""
#         self.check(b, a)
#
#     def test(self):
#         b = """x = intern(a)"""
#         a = """import sys\nx = sys.intern(a)"""
#         self.check(b, a)
#
#         b = """z = intern(a+b+c.d,)"""
#         a = """import sys\nz = sys.intern(a+b+c.d,)"""
#         self.check(b, a)
#
#         b = """intern("y%s" % 5).replace("y", "")"""
#         a = """import sys\nsys.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_reduce(FixerTestCase):
#     fixer = "reduce"
#
#     def test_simple_call(self):
#         b = "reduce(a, b, c)"
#         a = "from functools import reduce\nreduce(a, b, c)"
#         self.check(b, a)
#
#     def test_bug_7253(self):
#         # fix_tuple_params was being bad and orphaning nodes in the tree.
#         b = "def x(arg): reduce(sum, [])"
#         a = "from functools import reduce\ndef x(arg): reduce(sum, [])"
#         self.check(b, a)
#
#     def test_call_with_lambda(self):
#         b = "reduce(lambda x, y: x + y, seq)"
#         a = "from functools import reduce\nreduce(lambda x, y: x + y, seq)"
#         self.check(b, a)
#
#     def test_unchanged(self):
#         s = "reduce(a)"
#         self.unchanged(s)
#
#         s = "reduce(a, b=42)"
#         self.unchanged(s)
#
#         s = "reduce(a, b, c, d)"
#         self.unchanged(s)
#
#         s = "reduce(**c)"
#         self.unchanged(s)
#
#         s = "reduce()"
#         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):
        self.refactor.driver.grammar = pygram.python_grammar_no_print_statement
        s = """print(1, 1+1, 1+1+1)"""
        self.unchanged(s)

        s = """print()"""
        self.unchanged(s)

        s = """print('')"""
        self.unchanged(s)

    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);"""
        self.check(b, a)

    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)

    def test_trailing_comma_4(self):
        b = """print "a ","""
        a = """print("a ", end=' ')"""
        self.check(b, a)

    def test_trailing_comma_5(self):
        b = r"""print "b\t","""
        a = r"""print("b\t", end='')"""
        self.check(b, a)

    def test_trailing_comma_6(self):
        b = r"""print "c\n","""
        a = r"""print("c\n", end='')"""
        self.check(b, a)

    def test_trailing_comma_7(self):
        b = r"""print "d\r","""
        a = r"""print("d\r", end='')"""
        self.check(b, a)

    def test_trailing_comma_8(self):
        b = r"""print "%s\n" % (1,),"""
        a = r"""print("%s\n" % (1,), end='')"""
        self.check(b, a)


    def test_trailing_comma_9(self):
        b = r"""print r"e\n","""
        a = r"""print(r"e\n", 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)

    def test_with_future_print_function(self):
        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)


# 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):
#         b = """y = `x`"""
#         a = """y = repr(x)"""
#         self.check(b, a)
#
#     def test_complex(self):
#         b = """z = `y`.__repr__()"""
#         a = """z = repr(y).__repr__()"""
#         self.check(b, a)
#
#     def test_tuple(self):
#         b = """x = `1, 2, 3`"""
#         a = """x = repr((1, 2, 3))"""
#         self.check(b, a)
#
#     def test_nested(self):
#         b = """x = `1 + `2``"""
#         a = """x = repr(1 + repr(2))"""
#         self.check(b, a)
#
#     def test_nested_tuples(self):
#         b = """x = `1, 2 + `3, 4``"""
#         a = """x = repr((1, 2 + repr((3, 4))))"""
#         self.check(b, a)
#
# class Test_except(FixerTestCase):
#     fixer = "except"
#
#     def test_prefix_preservation(self):
#         b = """
#             try:
#                 pass
#             except (RuntimeError, ImportError),    e:
#                 pass"""
#         a = """
#             try:
#                 pass
#             except (RuntimeError, ImportError) as    e:
#                 pass"""
#         self.check(b, a)
#
#     def test_simple(self):
#         b = """
#             try:
#                 pass
#             except Foo, e:
#                 pass"""
#         a = """
#             try:
#                 pass
#             except Foo as e:
#                 pass"""
#         self.check(b, a)
#
#     def test_simple_no_space_before_target(self):
#         b = """
#             try:
#                 pass
#             except Foo,e:
#                 pass"""
#         a = """
#             try:
#                 pass
#             except Foo as e:
#                 pass"""
#         self.check(b, a)
#
#     def test_tuple_unpack(self):
#         b = """
#             def foo():
#                 try:
#                     pass
#                 except Exception, (f, e):
#                     pass
#                 except ImportError, e:
#                     pass"""
#
#         a = """
#             def foo():
#                 try:
#                     pass
#                 except Exception as xxx_todo_changeme:
#                     (f, e) = xxx_todo_changeme.args
#                     pass
#                 except ImportError as e:
#                     pass"""
#         self.check(b, a)
#
#     def test_multi_class(self):
#         b = """
#             try:
#                 pass
#             except (RuntimeError, ImportError), e:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except (RuntimeError, ImportError) as e:
#                 pass"""
#         self.check(b, a)
#
#     def test_list_unpack(self):
#         b = """
#             try:
#                 pass
#             except Exception, [a, b]:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except Exception as xxx_todo_changeme:
#                 [a, b] = xxx_todo_changeme.args
#                 pass"""
#         self.check(b, a)
#
#     def test_weird_target_1(self):
#         b = """
#             try:
#                 pass
#             except Exception, d[5]:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except Exception as xxx_todo_changeme:
#                 d[5] = xxx_todo_changeme
#                 pass"""
#         self.check(b, a)
#
#     def test_weird_target_2(self):
#         b = """
#             try:
#                 pass
#             except Exception, a.foo:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except Exception as xxx_todo_changeme:
#                 a.foo = xxx_todo_changeme
#                 pass"""
#         self.check(b, a)
#
#     def test_weird_target_3(self):
#         b = """
#             try:
#                 pass
#             except Exception, a().foo:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except Exception as xxx_todo_changeme:
#                 a().foo = xxx_todo_changeme
#                 pass"""
#         self.check(b, a)
#
#     def test_bare_except(self):
#         b = """
#             try:
#                 pass
#             except Exception, a:
#                 pass
#             except:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except Exception as a:
#                 pass
#             except:
#                 pass"""
#         self.check(b, a)
#
#     def test_bare_except_and_else_finally(self):
#         b = """
#             try:
#                 pass
#             except Exception, a:
#                 pass
#             except:
#                 pass
#             else:
#                 pass
#             finally:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except Exception as a:
#                 pass
#             except:
#                 pass
#             else:
#                 pass
#             finally:
#                 pass"""
#         self.check(b, a)
#
#     def test_multi_fixed_excepts_before_bare_except(self):
#         b = """
#             try:
#                 pass
#             except TypeError, b:
#                 pass
#             except Exception, a:
#                 pass
#             except:
#                 pass"""
#
#         a = """
#             try:
#                 pass
#             except TypeError as b:
#                 pass
#             except Exception as a:
#                 pass
#             except:
#                 pass"""
#         self.check(b, a)
#
#     def test_one_line_suites(self):
#         b = """
#             try: raise TypeError
#             except TypeError, e:
#                 pass
#             """
#         a = """
#             try: raise TypeError
#             except TypeError as e:
#                 pass
#             """
#         self.check(b, a)
#         b = """
#             try:
#                 raise TypeError
#             except TypeError, e: pass
#             """
#         a = """
#             try:
#                 raise TypeError
#             except TypeError as e: pass
#             """
#         self.check(b, a)
#         b = """
#             try: raise TypeError
#             except TypeError, e: pass
#             """
#         a = """
#             try: raise TypeError
#             except TypeError as e: pass
#             """
#         self.check(b, a)
#         b = """
#             try: raise TypeError
#             except TypeError, e: pass
#             else: function()
#             finally: done()
#             """
#         a = """
#             try: raise TypeError
#             except TypeError as e: pass
#             else: function()
#             finally: done()
#             """
#         self.check(b, a)
#
#     # These should not be touched:
#
#     def test_unchanged_1(self):
#         s = """
#             try:
#                 pass
#             except:
#                 pass"""
#         self.unchanged(s)
#
#     def test_unchanged_2(self):
#         s = """
#             try:
#                 pass
#             except Exception:
#                 pass"""
#         self.unchanged(s)
#
#     def test_unchanged_3(self):
#         s = """
#             try:
#                 pass
#             except (Exception, SystemExit):
#                 pass"""
#         self.unchanged(s)

class Test_raise(FixerTestCase):
    fixer = "raise"

    def test_basic(self):
        b = """raise Exception, 5"""
        a = """raise Exception(5)"""
        self.check(b, a)

    def test_prefix_preservation(self):
        b = """raise Exception,5"""
        a = """raise Exception(5)"""
        self.check(b, a)

        b = """raise   Exception,    5"""
        a = """raise   Exception(5)"""
        self.check(b, a)

    def test_with_comments(self):
        b = """raise Exception, 5 # foo"""
        a = """raise Exception(5) # foo"""
        self.check(b, a)

        b = """def foo():
                    raise Exception, 5, 6 # foo"""
        a = """def foo():
                    raise Exception(5).with_traceback(6) # foo"""
        self.check(b, a)

    def test_None_value(self):
        b = """raise Exception(5), None, tb"""
        a = """raise Exception(5).with_traceback(tb)"""
        self.check(b, a)

    def test_tuple_value(self):
        b = """raise Exception, (5, 6, 7)"""
        a = """raise Exception(5, 6, 7)"""
        self.check(b, a)

    def test_tuple_exc_1(self):
        b = """raise (((E1, E2), E3), E4), 5"""
        a = """raise E1(5)"""
        self.check(b, a)

    def test_tuple_exc_2(self):
        b = """raise (E1, (E2, E3), E4), 5"""
        a = """raise E1(5)"""
        self.check(b, a)

    def test_unknown_value(self):
        b = """
        raise E, V"""
        a = """
        from future.utils import raise_
        raise_(E, V)"""
        self.check(b, a)

    def test_unknown_value_with_traceback_with_comments(self):
        b = """
        raise E, Func(arg1, arg2, arg3), tb # foo"""
        a = """
        from future.utils import raise_
        raise_(E, Func(arg1, arg2, arg3), tb) # foo"""
        self.check(b, a)

    def test_unknown_value_with_indent(self):
        b = """
        while True:
            print()  # another expression in the same block triggers different parsing
            raise E, V
        """
        a = """
        from future.utils import raise_
        while True:
            print()  # another expression in the same block triggers different parsing
            raise_(E, V)
        """
        self.check(b, a)

    # These should produce a warning

    def test_string_exc(self):
        s = """raise 'foo'"""
        self.warns_unchanged(s, "Python 3 does not support string exceptions")

    def test_string_exc_val(self):
        s = """raise "foo", 5"""
        self.warns_unchanged(s, "Python 3 does not support string exceptions")

    def test_string_exc_val_tb(self):
        s = """raise "foo", 5, 6"""
        self.warns_unchanged(s, "Python 3 does not support string exceptions")

    # These should result in traceback-assignment

    def test_tb_1(self):
        b = """def foo():
                    raise Exception, 5, 6"""
        a = """def foo():
                    raise Exception(5).with_traceback(6)"""
        self.check(b, a)

    def test_tb_2(self):
        b = """def foo():
                    a = 5
                    raise Exception, 5, 6
                    b = 6"""
        a = """def foo():
                    a = 5
                    raise Exception(5).with_traceback(6)
                    b = 6"""
        self.check(b, a)

    def test_tb_3(self):
        b = """def foo():
                    raise Exception,5,6"""
        a = """def foo():
                    raise Exception(5).with_traceback(6)"""
        self.check(b, a)

    def test_tb_4(self):
        b = """def foo():
                    a = 5
                    raise Exception,5,6
                    b = 6"""
        a = """def foo():
                    a = 5
                    raise Exception(5).with_traceback(6)
                    b = 6"""
        self.check(b, a)

    def test_tb_5(self):
        b = """def foo():
                    raise Exception, (5, 6, 7), 6"""
        a = """def foo():
                    raise Exception(5, 6, 7).with_traceback(6)"""
        self.check(b, a)

    def test_tb_6(self):
        b = """def foo():
                    a = 5
                    raise Exception, (5, 6, 7), 6
                    b = 6"""
        a = """def foo():
                    a = 5
                    raise Exception(5, 6, 7).with_traceback(6)
                    b = 6"""
        self.check(b, a)
#
# class Test_throw(FixerTestCase):
#     fixer = "throw"
#
#     def test_1(self):
#         b = """g.throw(Exception, 5)"""
#         a = """g.throw(Exception(5))"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """g.throw(Exception,5)"""
#         a = """g.throw(Exception(5))"""
#         self.check(b, a)
#
#     def test_3(self):
#         b = """g.throw(Exception, (5, 6, 7))"""
#         a = """g.throw(Exception(5, 6, 7))"""
#         self.check(b, a)
#
#     def test_4(self):
#         b = """5 + g.throw(Exception, 5)"""
#         a = """5 + g.throw(Exception(5))"""
#         self.check(b, a)
#
#     # These should produce warnings
#
#     def test_warn_1(self):
#         s = """g.throw("foo")"""
#         self.warns_unchanged(s, "Python 3 does not support string exceptions")
#
#     def test_warn_2(self):
#         s = """g.throw("foo", 5)"""
#         self.warns_unchanged(s, "Python 3 does not support string exceptions")
#
#     def test_warn_3(self):
#         s = """g.throw("foo", 5, 6)"""
#         self.warns_unchanged(s, "Python 3 does not support string exceptions")
#
#     # These should not be touched
#
#     def test_untouched_1(self):
#         s = """g.throw(Exception)"""
#         self.unchanged(s)
#
#     def test_untouched_2(self):
#         s = """g.throw(Exception(5, 6))"""
#         self.unchanged(s)
#
#     def test_untouched_3(self):
#         s = """5 + g.throw(Exception(5, 6))"""
#         self.unchanged(s)
#
#     # These should result in traceback-assignment
#
#     def test_tb_1(self):
#         b = """def foo():
#                     g.throw(Exception, 5, 6)"""
#         a = """def foo():
#                     g.throw(Exception(5).with_traceback(6))"""
#         self.check(b, a)
#
#     def test_tb_2(self):
#         b = """def foo():
#                     a = 5
#                     g.throw(Exception, 5, 6)
#                     b = 6"""
#         a = """def foo():
#                     a = 5
#                     g.throw(Exception(5).with_traceback(6))
#                     b = 6"""
#         self.check(b, a)
#
#     def test_tb_3(self):
#         b = """def foo():
#                     g.throw(Exception,5,6)"""
#         a = """def foo():
#                     g.throw(Exception(5).with_traceback(6))"""
#         self.check(b, a)
#
#     def test_tb_4(self):
#         b = """def foo():
#                     a = 5
#                     g.throw(Exception,5,6)
#                     b = 6"""
#         a = """def foo():
#                     a = 5
#                     g.throw(Exception(5).with_traceback(6))
#                     b = 6"""
#         self.check(b, a)
#
#     def test_tb_5(self):
#         b = """def foo():
#                     g.throw(Exception, (5, 6, 7), 6)"""
#         a = """def foo():
#                     g.throw(Exception(5, 6, 7).with_traceback(6))"""
#         self.check(b, a)
#
#     def test_tb_6(self):
#         b = """def foo():
#                     a = 5
#                     g.throw(Exception, (5, 6, 7), 6)
#                     b = 6"""
#         a = """def foo():
#                     a = 5
#                     g.throw(Exception(5, 6, 7).with_traceback(6))
#                     b = 6"""
#         self.check(b, a)
#
#     def test_tb_7(self):
#         b = """def foo():
#                     a + g.throw(Exception, 5, 6)"""
#         a = """def foo():
#                     a + g.throw(Exception(5).with_traceback(6))"""
#         self.check(b, a)
#
#     def test_tb_8(self):
#         b = """def foo():
#                     a = 5
#                     a + g.throw(Exception, 5, 6)
#                     b = 6"""
#         a = """def foo():
#                     a = 5
#                     a + g.throw(Exception(5).with_traceback(6))
#                     b = 6"""
#         self.check(b, a)
#
# class Test_long(FixerTestCase):
#     fixer = "long"
#
#     def test_1(self):
#         b = """x = long(x)"""
#         a = """x = int(x)"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """y = isinstance(x, long)"""
#         a = """y = isinstance(x, int)"""
#         self.check(b, a)
#
#     def test_3(self):
#         b = """z = type(x) in (int, long)"""
#         a = """z = type(x) in (int, int)"""
#         self.check(b, a)
#
#     def test_unchanged(self):
#         s = """long = True"""
#         self.unchanged(s)
#
#         s = """s.long = True"""
#         self.unchanged(s)
#
#         s = """def long(): pass"""
#         self.unchanged(s)
#
#         s = """class long(): pass"""
#         self.unchanged(s)
#
#         s = """def f(long): pass"""
#         self.unchanged(s)
#
#         s = """def f(g, long): pass"""
#         self.unchanged(s)
#
#         s = """def f(x, long=True): pass"""
#         self.unchanged(s)
#
#     def test_prefix_preservation(self):
#         b = """x =   long(  x  )"""
#         a = """x =   int(  x  )"""
#         self.check(b, a)
#
#
# class Test_execfile(FixerTestCase):
#     fixer = "execfile"
#
#     def test_conversion(self):
#         b = """execfile("fn")"""
#         a = """exec(compile(open("fn").read(), "fn", 'exec'))"""
#         self.check(b, a)
#
#         b = """execfile("fn", glob)"""
#         a = """exec(compile(open("fn").read(), "fn", 'exec'), glob)"""
#         self.check(b, a)
#
#         b = """execfile("fn", glob, loc)"""
#         a = """exec(compile(open("fn").read(), "fn", 'exec'), glob, loc)"""
#         self.check(b, a)
#
#         b = """execfile("fn", globals=glob)"""
#         a = """exec(compile(open("fn").read(), "fn", 'exec'), globals=glob)"""
#         self.check(b, a)
#
#         b = """execfile("fn", locals=loc)"""
#         a = """exec(compile(open("fn").read(), "fn", 'exec'), locals=loc)"""
#         self.check(b, a)
#
#         b = """execfile("fn", globals=glob, locals=loc)"""
#         a = """exec(compile(open("fn").read(), "fn", 'exec'), globals=glob, locals=loc)"""
#         self.check(b, a)
#
#     def test_spacing(self):
#         b = """execfile( "fn" )"""
#         a = """exec(compile(open( "fn" ).read(), "fn", 'exec'))"""
#         self.check(b, a)
#
#         b = """execfile("fn",  globals = glob)"""
#         a = """exec(compile(open("fn").read(), "fn", 'exec'),  globals = glob)"""
#         self.check(b, a)
#
#
# class Test_isinstance(FixerTestCase):
#     fixer = "isinstance"
#
#     def test_remove_multiple_items(self):
#         b = """isinstance(x, (int, int, int))"""
#         a = """isinstance(x, int)"""
#         self.check(b, a)
#
#         b = """isinstance(x, (int, float, int, int, float))"""
#         a = """isinstance(x, (int, float))"""
#         self.check(b, a)
#
#         b = """isinstance(x, (int, float, int, int, float, str))"""
#         a = """isinstance(x, (int, float, str))"""
#         self.check(b, a)
#
#         b = """isinstance(foo() + bar(), (x(), y(), x(), int, int))"""
#         a = """isinstance(foo() + bar(), (x(), y(), x(), int))"""
#         self.check(b, a)
#
#     def test_prefix_preservation(self):
#         b = """if    isinstance(  foo(), (  bar, bar, baz )) : pass"""
#         a = """if    isinstance(  foo(), (  bar, baz )) : pass"""
#         self.check(b, a)
#
#     def test_unchanged(self):
#         self.unchanged("isinstance(x, (str, int))")
#
# class Test_dict(FixerTestCase):
#     fixer = "dict"
#
#     def test_prefix_preservation(self):
#         b = "if   d. keys  (  )  : pass"
#         a = "if   list(d. keys  (  ))  : pass"
#         self.check(b, a)
#
#         b = "if   d. items  (  )  : pass"
#         a = "if   list(d. items  (  ))  : pass"
#         self.check(b, a)
#
#         b = "if   d. iterkeys  ( )  : pass"
#         a = "if   iter(d. keys  ( ))  : pass"
#         self.check(b, a)
#
#         b = "[i for i in    d.  iterkeys(  )  ]"
#         a = "[i for i in    d.  keys(  )  ]"
#         self.check(b, a)
#
#         b = "if   d. viewkeys  ( )  : pass"
#         a = "if   d. keys  ( )  : pass"
#         self.check(b, a)
#
#         b = "[i for i in    d.  viewkeys(  )  ]"
#         a = "[i for i in    d.  keys(  )  ]"
#         self.check(b, a)
#
#     def test_trailing_comment(self):
#         b = "d.keys() # foo"
#         a = "list(d.keys()) # foo"
#         self.check(b, a)
#
#         b = "d.items()  # foo"
#         a = "list(d.items())  # foo"
#         self.check(b, a)
#
#         b = "d.iterkeys()  # foo"
#         a = "iter(d.keys())  # foo"
#         self.check(b, a)
#
#         b = """[i for i in d.iterkeys() # foo
#                ]"""
#         a = """[i for i in d.keys() # foo
#                ]"""
#         self.check(b, a)
#
#         b = """[i for i in d.iterkeys() # foo
#                ]"""
#         a = """[i for i in d.keys() # foo
#                ]"""
#         self.check(b, a)
#
#         b = "d.viewitems()  # foo"
#         a = "d.items()  # foo"
#         self.check(b, a)
#
#     def test_unchanged(self):
#         for wrapper in fixer_util.consuming_calls:
#             s = "s = %s(d.keys())" % wrapper
#             self.unchanged(s)
#
#             s = "s = %s(d.values())" % wrapper
#             self.unchanged(s)
#
#             s = "s = %s(d.items())" % wrapper
#             self.unchanged(s)
#
#     def test_01(self):
#         b = "d.keys()"
#         a = "list(d.keys())"
#         self.check(b, a)
#
#         b = "a[0].foo().keys()"
#         a = "list(a[0].foo().keys())"
#         self.check(b, a)
#
#     def test_02(self):
#         b = "d.items()"
#         a = "list(d.items())"
#         self.check(b, a)
#
#     def test_03(self):
#         b = "d.values()"
#         a = "list(d.values())"
#         self.check(b, a)
#
#     def test_04(self):
#         b = "d.iterkeys()"
#         a = "iter(d.keys())"
#         self.check(b, a)
#
#     def test_05(self):
#         b = "d.iteritems()"
#         a = "iter(d.items())"
#         self.check(b, a)
#
#     def test_06(self):
#         b = "d.itervalues()"
#         a = "iter(d.values())"
#         self.check(b, a)
#
#     def test_07(self):
#         s = "list(d.keys())"
#         self.unchanged(s)
#
#     def test_08(self):
#         s = "sorted(d.keys())"
#         self.unchanged(s)
#
#     def test_09(self):
#         b = "iter(d.keys())"
#         a = "iter(list(d.keys()))"
#         self.check(b, a)
#
#     def test_10(self):
#         b = "foo(d.keys())"
#         a = "foo(list(d.keys()))"
#         self.check(b, a)
#
#     def test_11(self):
#         b = "for i in d.keys(): print i"
#         a = "for i in list(d.keys()): print i"
#         self.check(b, a)
#
#     def test_12(self):
#         b = "for i in d.iterkeys(): print i"
#         a = "for i in d.keys(): print i"
#         self.check(b, a)
#
#     def test_13(self):
#         b = "[i for i in d.keys()]"
#         a = "[i for i in list(d.keys())]"
#         self.check(b, a)
#
#     def test_14(self):
#         b = "[i for i in d.iterkeys()]"
#         a = "[i for i in d.keys()]"
#         self.check(b, a)
#
#     def test_15(self):
#         b = "(i for i in d.keys())"
#         a = "(i for i in list(d.keys()))"
#         self.check(b, a)
#
#     def test_16(self):
#         b = "(i for i in d.iterkeys())"
#         a = "(i for i in d.keys())"
#         self.check(b, a)
#
#     def test_17(self):
#         b = "iter(d.iterkeys())"
#         a = "iter(d.keys())"
#         self.check(b, a)
#
#     def test_18(self):
#         b = "list(d.iterkeys())"
#         a = "list(d.keys())"
#         self.check(b, a)
#
#     def test_19(self):
#         b = "sorted(d.iterkeys())"
#         a = "sorted(d.keys())"
#         self.check(b, a)
#
#     def test_20(self):
#         b = "foo(d.iterkeys())"
#         a = "foo(iter(d.keys()))"
#         self.check(b, a)
#
#     def test_21(self):
#         b = "print h.iterkeys().next()"
#         a = "print iter(h.keys()).next()"
#         self.check(b, a)
#
#     def test_22(self):
#         b = "print h.keys()[0]"
#         a = "print list(h.keys())[0]"
#         self.check(b, a)
#
#     def test_23(self):
#         b = "print list(h.iterkeys().next())"
#         a = "print list(iter(h.keys()).next())"
#         self.check(b, a)
#
#     def test_24(self):
#         b = "for x in h.keys()[0]: print x"
#         a = "for x in list(h.keys())[0]: print x"
#         self.check(b, a)
#
#     def test_25(self):
#         b = "d.viewkeys()"
#         a = "d.keys()"
#         self.check(b, a)
#
#     def test_26(self):
#         b = "d.viewitems()"
#         a = "d.items()"
#         self.check(b, a)
#
#     def test_27(self):
#         b = "d.viewvalues()"
#         a = "d.values()"
#         self.check(b, a)
#
#     def test_14(self):
#         b = "[i for i in d.viewkeys()]"
#         a = "[i for i in d.keys()]"
#         self.check(b, a)
#
#     def test_15(self):
#         b = "(i for i in d.viewkeys())"
#         a = "(i for i in d.keys())"
#         self.check(b, a)
#
#     def test_17(self):
#         b = "iter(d.viewkeys())"
#         a = "iter(d.keys())"
#         self.check(b, a)
#
#     def test_18(self):
#         b = "list(d.viewkeys())"
#         a = "list(d.keys())"
#         self.check(b, a)
#
#     def test_19(self):
#         b = "sorted(d.viewkeys())"
#         a = "sorted(d.keys())"
#         self.check(b, a)
#
# class Test_xrange(FixerTestCase):
#     fixer = "xrange"
#
#     def test_prefix_preservation(self):
#         b = """x =    xrange(  10  )"""
#         a = """x =    range(  10  )"""
#         self.check(b, a)
#
#         b = """x = xrange(  1  ,  10   )"""
#         a = """x = range(  1  ,  10   )"""
#         self.check(b, a)
#
#         b = """x = xrange(  0  ,  10 ,  2 )"""
#         a = """x = range(  0  ,  10 ,  2 )"""
#         self.check(b, a)
#
#     def test_single_arg(self):
#         b = """x = xrange(10)"""
#         a = """x = range(10)"""
#         self.check(b, a)
#
#     def test_two_args(self):
#         b = """x = xrange(1, 10)"""
#         a = """x = range(1, 10)"""
#         self.check(b, a)
#
#     def test_three_args(self):
#         b = """x = xrange(0, 10, 2)"""
#         a = """x = range(0, 10, 2)"""
#         self.check(b, a)
#
#     def test_wrap_in_list(self):
#         b = """x = range(10, 3, 9)"""
#         a = """x = list(range(10, 3, 9))"""
#         self.check(b, a)
#
#         b = """x = foo(range(10, 3, 9))"""
#         a = """x = foo(list(range(10, 3, 9)))"""
#         self.check(b, a)
#
#         b = """x = range(10, 3, 9) + [4]"""
#         a = """x = list(range(10, 3, 9)) + [4]"""
#         self.check(b, a)
#
#         b = """x = range(10)[::-1]"""
#         a = """x = list(range(10))[::-1]"""
#         self.check(b, a)
#
#         b = """x = range(10)  [3]"""
#         a = """x = list(range(10))  [3]"""
#         self.check(b, a)
#
#     def test_xrange_in_for(self):
#         b = """for i in xrange(10):\n    j=i"""
#         a = """for i in range(10):\n    j=i"""
#         self.check(b, a)
#
#         b = """[i for i in xrange(10)]"""
#         a = """[i for i in range(10)]"""
#         self.check(b, a)
#
#     def test_range_in_for(self):
#         self.unchanged("for i in range(10): pass")
#         self.unchanged("[i for i in range(10)]")
#
#     def test_in_contains_test(self):
#         self.unchanged("x in range(10, 3, 9)")
#
#     def test_in_consuming_context(self):
#         for call in fixer_util.consuming_calls:
#             self.unchanged("a = %s(range(10))" % call)
#
# class Test_xrange_with_reduce(FixerTestCase):
#
#     def setUp(self):
#         super(Test_xrange_with_reduce, self).setUp(["xrange", "reduce"])
#
#     def test_double_transform(self):
#         b = """reduce(x, xrange(5))"""
#         a = """from functools import reduce
# reduce(x, range(5))"""
#         self.check(b, a)
#
# class Test_raw_input(FixerTestCase):
#     fixer = "raw_input"
#
#     def test_prefix_preservation(self):
#         b = """x =    raw_input(   )"""
#         a = """x =    input(   )"""
#         self.check(b, a)
#
#         b = """x = raw_input(   ''   )"""
#         a = """x = input(   ''   )"""
#         self.check(b, a)
#
#     def test_1(self):
#         b = """x = raw_input()"""
#         a = """x = input()"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """x = raw_input('')"""
#         a = """x = input('')"""
#         self.check(b, a)
#
#     def test_3(self):
#         b = """x = raw_input('prompt')"""
#         a = """x = input('prompt')"""
#         self.check(b, a)
#
#     def test_4(self):
#         b = """x = raw_input(foo(a) + 6)"""
#         a = """x = input(foo(a) + 6)"""
#         self.check(b, a)
#
#     def test_5(self):
#         b = """x = raw_input(invite).split()"""
#         a = """x = input(invite).split()"""
#         self.check(b, a)
#
#     def test_6(self):
#         b = """x = raw_input(invite) . split ()"""
#         a = """x = input(invite) . split ()"""
#         self.check(b, a)
#
#     def test_8(self):
#         b = "x = int(raw_input())"
#         a = "x = int(input())"
#         self.check(b, a)
#
# class Test_funcattrs(FixerTestCase):
#     fixer = "funcattrs"
#
#     attrs = ["closure", "doc", "name", "defaults", "code", "globals", "dict"]
#
#     def test(self):
#         for attr in self.attrs:
#             b = "a.func_%s" % attr
#             a = "a.__%s__" % attr
#             self.check(b, a)
#
#             b = "self.foo.func_%s.foo_bar" % attr
#             a = "self.foo.__%s__.foo_bar" % attr
#             self.check(b, a)
#
#     def test_unchanged(self):
#         for attr in self.attrs:
#             s = "foo(func_%s + 5)" % attr
#             self.unchanged(s)
#
#             s = "f(foo.__%s__)" % attr
#             self.unchanged(s)
#
#             s = "f(foo.__%s__.foo)" % attr
#             self.unchanged(s)
#
# class Test_xreadlines(FixerTestCase):
#     fixer = "xreadlines"
#
#     def test_call(self):
#         b = "for x in f.xreadlines(): pass"
#         a = "for x in f: pass"
#         self.check(b, a)
#
#         b = "for x in foo().xreadlines(): pass"
#         a = "for x in foo(): pass"
#         self.check(b, a)
#
#         b = "for x in (5 + foo()).xreadlines(): pass"
#         a = "for x in (5 + foo()): pass"
#         self.check(b, a)
#
#     def test_attr_ref(self):
#         b = "foo(f.xreadlines + 5)"
#         a = "foo(f.__iter__ + 5)"
#         self.check(b, a)
#
#         b = "foo(f().xreadlines + 5)"
#         a = "foo(f().__iter__ + 5)"
#         self.check(b, a)
#
#         b = "foo((5 + f()).xreadlines + 5)"
#         a = "foo((5 + f()).__iter__ + 5)"
#         self.check(b, a)
#
#     def test_unchanged(self):
#         s = "for x in f.xreadlines(5): pass"
#         self.unchanged(s)
#
#         s = "for x in f.xreadlines(k=5): pass"
#         self.unchanged(s)
#
#         s = "for x in f.xreadlines(*k, **v): pass"
#         self.unchanged(s)
#
#         s = "foo(xreadlines)"
#         self.unchanged(s)
#
#
# class ImportsFixerTests:
#
#     def test_import_module(self):
#         for old, new in self.modules.items():
#             b = "import %s" % old
#             a = "import %s" % new
#             self.check(b, a)
#
#             b = "import foo, %s, bar" % old
#             a = "import foo, %s, bar" % new
#             self.check(b, a)
#
#     def test_import_from(self):
#         for old, new in self.modules.items():
#             b = "from %s import foo" % old
#             a = "from %s import foo" % new
#             self.check(b, a)
#
#             b = "from %s import foo, bar" % old
#             a = "from %s import foo, bar" % new
#             self.check(b, a)
#
#             b = "from %s import (yes, no)" % old
#             a = "from %s import (yes, no)" % new
#             self.check(b, a)
#
#     def test_import_module_as(self):
#         for old, new in self.modules.items():
#             b = "import %s as foo_bar" % old
#             a = "import %s as foo_bar" % new
#             self.check(b, a)
#
#             b = "import %s as foo_bar" % old
#             a = "import %s as foo_bar" % new
#             self.check(b, a)
#
#     def test_import_from_as(self):
#         for old, new in self.modules.items():
#             b = "from %s import foo as bar" % old
#             a = "from %s import foo as bar" % new
#             self.check(b, a)
#
#     def test_star(self):
#         for old, new in self.modules.items():
#             b = "from %s import *" % old
#             a = "from %s import *" % new
#             self.check(b, a)
#
#     def test_import_module_usage(self):
#         for old, new in self.modules.items():
#             b = """
#                 import %s
#                 foo(%s.bar)
#                 """ % (old, old)
#             a = """
#                 import %s
#                 foo(%s.bar)
#                 """ % (new, new)
#             self.check(b, a)
#
#             b = """
#                 from %s import x
#                 %s = 23
#                 """ % (old, old)
#             a = """
#                 from %s import x
#                 %s = 23
#                 """ % (new, old)
#             self.check(b, a)
#
#             s = """
#                 def f():
#                     %s.method()
#                 """ % (old,)
#             self.unchanged(s)
#
#             # test nested usage
#             b = """
#                 import %s
#                 %s.bar(%s.foo)
#                 """ % (old, old, old)
#             a = """
#                 import %s
#                 %s.bar(%s.foo)
#                 """ % (new, new, new)
#             self.check(b, a)
#
#             b = """
#                 import %s
#                 x.%s
#                 """ % (old, old)
#             a = """
#                 import %s
#                 x.%s
#                 """ % (new, old)
#             self.check(b, a)
#
#
# class Test_imports(FixerTestCase, ImportsFixerTests):
#     fixer = "imports"
#
#     def test_multiple_imports(self):
#         b = """import urlparse, cStringIO"""
#         a = """import urllib.parse, io"""
#         self.check(b, a)
#
#     def test_multiple_imports_as(self):
#         b = """
#             import copy_reg as bar, HTMLParser as foo, urlparse
#             s = urlparse.spam(bar.foo())
#             """
#         a = """
#             import copyreg as bar, html.parser as foo, urllib.parse
#             s = urllib.parse.spam(bar.foo())
#             """
#         self.check(b, a)
#
#
# class Test_imports2(FixerTestCase, ImportsFixerTests):
#     fixer = "imports2"
#
#
# class Test_imports_fixer_order(FixerTestCase, ImportsFixerTests):
#
#     def setUp(self):
#         super(Test_imports_fixer_order, self).setUp(['imports', 'imports2'])
#         from ..fixes.fix_imports2 import MAPPING as mapping2
#         self.modules = mapping2.copy()
#         from ..fixes.fix_imports import MAPPING as mapping1
#         for key in ('dbhash', 'dumbdbm', 'dbm', 'gdbm'):
#             self.modules[key] = mapping1[key]
#
#     def test_after_local_imports_refactoring(self):
#         for fix in ("imports", "imports2"):
#             self.fixer = fix
#             self.assert_runs_after("import")
#
#
# class Test_urllib(FixerTestCase):
#     fixer = "urllib"
#     from ..fixes.fix_urllib import MAPPING as modules
#
#     def test_import_module(self):
#         for old, changes in self.modules.items():
#             b = "import %s" % old
#             a = "import %s" % ", ".join(map(itemgetter(0), changes))
#             self.check(b, a)
#
#     def test_import_from(self):
#         for old, changes in self.modules.items():
#             all_members = []
#             for new, members in changes:
#                 for member in members:
#                     all_members.append(member)
#                     b = "from %s import %s" % (old, member)
#                     a = "from %s import %s" % (new, member)
#                     self.check(b, a)
#
#                     s = "from foo import %s" % member
#                     self.unchanged(s)
#
#                 b = "from %s import %s" % (old, ", ".join(members))
#                 a = "from %s import %s" % (new, ", ".join(members))
#                 self.check(b, a)
#
#                 s = "from foo import %s" % ", ".join(members)
#                 self.unchanged(s)
#
#             # test the breaking of a module into multiple replacements
#             b = "from %s import %s" % (old, ", ".join(all_members))
#             a = "\n".join(["from %s import %s" % (new, ", ".join(members))
#                             for (new, members) in changes])
#             self.check(b, a)
#
#     def test_import_module_as(self):
#         for old in self.modules:
#             s = "import %s as foo" % old
#             self.warns_unchanged(s, "This module is now multiple modules")
#
#     def test_import_from_as(self):
#         for old, changes in self.modules.items():
#             for new, members in changes:
#                 for member in members:
#                     b = "from %s import %s as foo_bar" % (old, member)
#                     a = "from %s import %s as foo_bar" % (new, member)
#                     self.check(b, a)
#                     b = "from %s import %s as blah, %s" % (old, member, member)
#                     a = "from %s import %s as blah, %s" % (new, member, member)
#                     self.check(b, a)
#
#     def test_star(self):
#         for old in self.modules:
#             s = "from %s import *" % old
#             self.warns_unchanged(s, "Cannot handle star imports")
#
#     def test_indented(self):
#         b = """
# def foo():
#     from urllib import urlencode, urlopen
# """
#         a = """
# def foo():
#     from urllib.parse import urlencode
#     from urllib.request import urlopen
# """
#         self.check(b, a)
#
#         b = """
# def foo():
#     other()
#     from urllib import urlencode, urlopen
# """
#         a = """
# def foo():
#     other()
#     from urllib.parse import urlencode
#     from urllib.request import urlopen
# """
#         self.check(b, a)
#
#
#
#     def test_import_module_usage(self):
#         for old, changes in self.modules.items():
#             for new, members in changes:
#                 for member in members:
#                     new_import = ", ".join([n for (n, mems)
#                                             in self.modules[old]])
#                     b = """
#                         import %s
#                         foo(%s.%s)
#                         """ % (old, old, member)
#                     a = """
#                         import %s
#                         foo(%s.%s)
#                         """ % (new_import, new, member)
#                     self.check(b, a)
#                     b = """
#                         import %s
#                         %s.%s(%s.%s)
#                         """ % (old, old, member, old, member)
#                     a = """
#                         import %s
#                         %s.%s(%s.%s)
#                         """ % (new_import, new, member, new, member)
#                     self.check(b, a)
#
#
# class Test_input(FixerTestCase):
#     fixer = "input"
#
#     def test_prefix_preservation(self):
#         b = """x =   input(   )"""
#         a = """x =   eval(input(   ))"""
#         self.check(b, a)
#
#         b = """x = input(   ''   )"""
#         a = """x = eval(input(   ''   ))"""
#         self.check(b, a)
#
#     def test_trailing_comment(self):
#         b = """x = input()  #  foo"""
#         a = """x = eval(input())  #  foo"""
#         self.check(b, a)
#
#     def test_idempotency(self):
#         s = """x = eval(input())"""
#         self.unchanged(s)
#
#         s = """x = eval(input(''))"""
#         self.unchanged(s)
#
#         s = """x = eval(input(foo(5) + 9))"""
#         self.unchanged(s)
#
#     def test_1(self):
#         b = """x = input()"""
#         a = """x = eval(input())"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """x = input('')"""
#         a = """x = eval(input(''))"""
#         self.check(b, a)
#
#     def test_3(self):
#         b = """x = input('prompt')"""
#         a = """x = eval(input('prompt'))"""
#         self.check(b, a)
#
#     def test_4(self):
#         b = """x = input(foo(5) + 9)"""
#         a = """x = eval(input(foo(5) + 9))"""
#         self.check(b, a)
#
# class Test_tuple_params(FixerTestCase):
#     fixer = "tuple_params"
#
#     def test_unchanged_1(self):
#         s = """def foo(): pass"""
#         self.unchanged(s)
#
#     def test_unchanged_2(self):
#         s = """def foo(a, b, c): pass"""
#         self.unchanged(s)
#
#     def test_unchanged_3(self):
#         s = """def foo(a=3, b=4, c=5): pass"""
#         self.unchanged(s)
#
#     def test_1(self):
#         b = """
#             def foo(((a, b), c)):
#                 x = 5"""
#
#         a = """
#             def foo(xxx_todo_changeme):
#                 ((a, b), c) = xxx_todo_changeme
#                 x = 5"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """
#             def foo(((a, b), c), d):
#                 x = 5"""
#
#         a = """
#             def foo(xxx_todo_changeme, d):
#                 ((a, b), c) = xxx_todo_changeme
#                 x = 5"""
#         self.check(b, a)
#
#     def test_3(self):
#         b = """
#             def foo(((a, b), c), d) -> e:
#                 x = 5"""
#
#         a = """
#             def foo(xxx_todo_changeme, d) -> e:
#                 ((a, b), c) = xxx_todo_changeme
#                 x = 5"""
#         self.check(b, a)
#
#     def test_semicolon(self):
#         b = """
#             def foo(((a, b), c)): x = 5; y = 7"""
#
#         a = """
#             def foo(xxx_todo_changeme): ((a, b), c) = xxx_todo_changeme; x = 5; y = 7"""
#         self.check(b, a)
#
#     def test_keywords(self):
#         b = """
#             def foo(((a, b), c), d, e=5) -> z:
#                 x = 5"""
#
#         a = """
#             def foo(xxx_todo_changeme, d, e=5) -> z:
#                 ((a, b), c) = xxx_todo_changeme
#                 x = 5"""
#         self.check(b, a)
#
#     def test_varargs(self):
#         b = """
#             def foo(((a, b), c), d, *vargs, **kwargs) -> z:
#                 x = 5"""
#
#         a = """
#             def foo(xxx_todo_changeme, d, *vargs, **kwargs) -> z:
#                 ((a, b), c) = xxx_todo_changeme
#                 x = 5"""
#         self.check(b, a)
#
#     def test_multi_1(self):
#         b = """
#             def foo(((a, b), c), (d, e, f)) -> z:
#                 x = 5"""
#
#         a = """
#             def foo(xxx_todo_changeme, xxx_todo_changeme1) -> z:
#                 ((a, b), c) = xxx_todo_changeme
#                 (d, e, f) = xxx_todo_changeme1
#                 x = 5"""
#         self.check(b, a)
#
#     def test_multi_2(self):
#         b = """
#             def foo(x, ((a, b), c), d, (e, f, g), y) -> z:
#                 x = 5"""
#
#         a = """
#             def foo(x, xxx_todo_changeme, d, xxx_todo_changeme1, y) -> z:
#                 ((a, b), c) = xxx_todo_changeme
#                 (e, f, g) = xxx_todo_changeme1
#                 x = 5"""
#         self.check(b, a)
#
#     def test_docstring(self):
#         b = """
#             def foo(((a, b), c), (d, e, f)) -> z:
#                 "foo foo foo foo"
#                 x = 5"""
#
#         a = """
#             def foo(xxx_todo_changeme, xxx_todo_changeme1) -> z:
#                 "foo foo foo foo"
#                 ((a, b), c) = xxx_todo_changeme
#                 (d, e, f) = xxx_todo_changeme1
#                 x = 5"""
#         self.check(b, a)
#
#     def test_lambda_no_change(self):
#         s = """lambda x: x + 5"""
#         self.unchanged(s)
#
#     def test_lambda_parens_single_arg(self):
#         b = """lambda (x): x + 5"""
#         a = """lambda x: x + 5"""
#         self.check(b, a)
#
#         b = """lambda(x): x + 5"""
#         a = """lambda x: x + 5"""
#         self.check(b, a)
#
#         b = """lambda ((((x)))): x + 5"""
#         a = """lambda x: x + 5"""
#         self.check(b, a)
#
#         b = """lambda((((x)))): x + 5"""
#         a = """lambda x: x + 5"""
#         self.check(b, a)
#
#     def test_lambda_simple(self):
#         b = """lambda (x, y): x + f(y)"""
#         a = """lambda x_y: x_y[0] + f(x_y[1])"""
#         self.check(b, a)
#
#         b = """lambda(x, y): x + f(y)"""
#         a = """lambda x_y: x_y[0] + f(x_y[1])"""
#         self.check(b, a)
#
#         b = """lambda (((x, y))): x + f(y)"""
#         a = """lambda x_y: x_y[0] + f(x_y[1])"""
#         self.check(b, a)
#
#         b = """lambda(((x, y))): x + f(y)"""
#         a = """lambda x_y: x_y[0] + f(x_y[1])"""
#         self.check(b, a)
#
#     def test_lambda_one_tuple(self):
#         b = """lambda (x,): x + f(x)"""
#         a = """lambda x1: x1[0] + f(x1[0])"""
#         self.check(b, a)
#
#         b = """lambda (((x,))): x + f(x)"""
#         a = """lambda x1: x1[0] + f(x1[0])"""
#         self.check(b, a)
#
#     def test_lambda_simple_multi_use(self):
#         b = """lambda (x, y): x + x + f(x) + x"""
#         a = """lambda x_y: x_y[0] + x_y[0] + f(x_y[0]) + x_y[0]"""
#         self.check(b, a)
#
#     def test_lambda_simple_reverse(self):
#         b = """lambda (x, y): y + x"""
#         a = """lambda x_y: x_y[1] + x_y[0]"""
#         self.check(b, a)
#
#     def test_lambda_nested(self):
#         b = """lambda (x, (y, z)): x + y + z"""
#         a = """lambda x_y_z: x_y_z[0] + x_y_z[1][0] + x_y_z[1][1]"""
#         self.check(b, a)
#
#         b = """lambda (((x, (y, z)))): x + y + z"""
#         a = """lambda x_y_z: x_y_z[0] + x_y_z[1][0] + x_y_z[1][1]"""
#         self.check(b, a)
#
#     def test_lambda_nested_multi_use(self):
#         b = """lambda (x, (y, z)): x + y + f(y)"""
#         a = """lambda x_y_z: x_y_z[0] + x_y_z[1][0] + f(x_y_z[1][0])"""
#         self.check(b, a)
#
# class Test_methodattrs(FixerTestCase):
#     fixer = "methodattrs"
#
#     attrs = ["func", "self", "class"]
#
#     def test(self):
#         for attr in self.attrs:
#             b = "a.im_%s" % attr
#             if attr == "class":
#                 a = "a.__self__.__class__"
#             else:
#                 a = "a.__%s__" % attr
#             self.check(b, a)
#
#             b = "self.foo.im_%s.foo_bar" % attr
#             if attr == "class":
#                 a = "self.foo.__self__.__class__.foo_bar"
#             else:
#                 a = "self.foo.__%s__.foo_bar" % attr
#             self.check(b, a)
#
#     def test_unchanged(self):
#         for attr in self.attrs:
#             s = "foo(im_%s + 5)" % attr
#             self.unchanged(s)
#
#             s = "f(foo.__%s__)" % attr
#             self.unchanged(s)
#
#             s = "f(foo.__%s__.foo)" % attr
#             self.unchanged(s)
#
# class Test_next(FixerTestCase):
#     fixer = "next"
#
#     def test_1(self):
#         b = """it.next()"""
#         a = """next(it)"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """a.b.c.d.next()"""
#         a = """next(a.b.c.d)"""
#         self.check(b, a)
#
#     def test_3(self):
#         b = """(a + b).next()"""
#         a = """next((a + b))"""
#         self.check(b, a)
#
#     def test_4(self):
#         b = """a().next()"""
#         a = """next(a())"""
#         self.check(b, a)
#
#     def test_5(self):
#         b = """a().next() + b"""
#         a = """next(a()) + b"""
#         self.check(b, a)
#
#     def test_6(self):
#         b = """c(      a().next() + b)"""
#         a = """c(      next(a()) + b)"""
#         self.check(b, a)
#
#     def test_prefix_preservation_1(self):
#         b = """
#             for a in b:
#                 foo(a)
#                 a.next()
#             """
#         a = """
#             for a in b:
#                 foo(a)
#                 next(a)
#             """
#         self.check(b, a)
#
#     def test_prefix_preservation_2(self):
#         b = """
#             for a in b:
#                 foo(a) # abc
#                 # def
#                 a.next()
#             """
#         a = """
#             for a in b:
#                 foo(a) # abc
#                 # def
#                 next(a)
#             """
#         self.check(b, a)
#
#     def test_prefix_preservation_3(self):
#         b = """
#             next = 5
#             for a in b:
#                 foo(a)
#                 a.next()
#             """
#         a = """
#             next = 5
#             for a in b:
#                 foo(a)
#                 a.__next__()
#             """
#         self.check(b, a, ignore_warnings=True)
#
#     def test_prefix_preservation_4(self):
#         b = """
#             next = 5
#             for a in b:
#                 foo(a) # abc
#                 # def
#                 a.next()
#             """
#         a = """
#             next = 5
#             for a in b:
#                 foo(a) # abc
#                 # def
#                 a.__next__()
#             """
#         self.check(b, a, ignore_warnings=True)
#
#     def test_prefix_preservation_5(self):
#         b = """
#             next = 5
#             for a in b:
#                 foo(foo(a), # abc
#                     a.next())
#             """
#         a = """
#             next = 5
#             for a in b:
#                 foo(foo(a), # abc
#                     a.__next__())
#             """
#         self.check(b, a, ignore_warnings=True)
#
#     def test_prefix_preservation_6(self):
#         b = """
#             for a in b:
#                 foo(foo(a), # abc
#                     a.next())
#             """
#         a = """
#             for a in b:
#                 foo(foo(a), # abc
#                     next(a))
#             """
#         self.check(b, a)
#
#     def test_method_1(self):
#         b = """
#             class A:
#                 def next(self):
#                     pass
#             """
#         a = """
#             class A:
#                 def __next__(self):
#                     pass
#             """
#         self.check(b, a)
#
#     def test_method_2(self):
#         b = """
#             class A(object):
#                 def next(self):
#                     pass
#             """
#         a = """
#             class A(object):
#                 def __next__(self):
#                     pass
#             """
#         self.check(b, a)
#
#     def test_method_3(self):
#         b = """
#             class A:
#                 def next(x):
#                     pass
#             """
#         a = """
#             class A:
#                 def __next__(x):
#                     pass
#             """
#         self.check(b, a)
#
#     def test_method_4(self):
#         b = """
#             class A:
#                 def __init__(self, foo):
#                     self.foo = foo
#
#                 def next(self):
#                     pass
#
#                 def __iter__(self):
#                     return self
#             """
#         a = """
#             class A:
#                 def __init__(self, foo):
#                     self.foo = foo
#
#                 def __next__(self):
#                     pass
#
#                 def __iter__(self):
#                     return self
#             """
#         self.check(b, a)
#
#     def test_method_unchanged(self):
#         s = """
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.unchanged(s)
#
#     def test_shadowing_assign_simple(self):
#         s = """
#             next = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_assign_tuple_1(self):
#         s = """
#             (next, a) = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_assign_tuple_2(self):
#         s = """
#             (a, (b, (next, c)), a) = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_assign_list_1(self):
#         s = """
#             [next, a] = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_assign_list_2(self):
#         s = """
#             [a, [b, [next, c]], a] = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_builtin_assign(self):
#         s = """
#             def foo():
#                 __builtin__.next = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_builtin_assign_in_tuple(self):
#         s = """
#             def foo():
#                 (a, __builtin__.next) = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_builtin_assign_in_list(self):
#         s = """
#             def foo():
#                 [a, __builtin__.next] = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_assign_to_next(self):
#         s = """
#             def foo():
#                 A.next = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.unchanged(s)
#
#     def test_assign_to_next_in_tuple(self):
#         s = """
#             def foo():
#                 (a, A.next) = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.unchanged(s)
#
#     def test_assign_to_next_in_list(self):
#         s = """
#             def foo():
#                 [a, A.next] = foo
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.unchanged(s)
#
#     def test_shadowing_import_1(self):
#         s = """
#             import foo.bar as next
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_import_2(self):
#         s = """
#             import bar, bar.foo as next
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_import_3(self):
#         s = """
#             import bar, bar.foo as next, baz
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_import_from_1(self):
#         s = """
#             from x import next
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_import_from_2(self):
#         s = """
#             from x.a import next
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_import_from_3(self):
#         s = """
#             from x import a, next, b
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_import_from_4(self):
#         s = """
#             from x.a import a, next, b
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_funcdef_1(self):
#         s = """
#             def next(a):
#                 pass
#
#             class A:
#                 def next(self, a, b):
#                     pass
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_funcdef_2(self):
#         b = """
#             def next(a):
#                 pass
#
#             class A:
#                 def next(self):
#                     pass
#
#             it.next()
#             """
#         a = """
#             def next(a):
#                 pass
#
#             class A:
#                 def __next__(self):
#                     pass
#
#             it.__next__()
#             """
#         self.warns(b, a, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_global_1(self):
#         s = """
#             def f():
#                 global next
#                 next = 5
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_global_2(self):
#         s = """
#             def f():
#                 global a, next, b
#                 next = 5
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_for_simple(self):
#         s = """
#             for next in it():
#                 pass
#
#             b = 5
#             c = 6
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_for_tuple_1(self):
#         s = """
#             for next, b in it():
#                 pass
#
#             b = 5
#             c = 6
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_shadowing_for_tuple_2(self):
#         s = """
#             for a, (next, c), b in it():
#                 pass
#
#             b = 5
#             c = 6
#             """
#         self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
#
#     def test_noncall_access_1(self):
#         b = """gnext = g.next"""
#         a = """gnext = g.__next__"""
#         self.check(b, a)
#
#     def test_noncall_access_2(self):
#         b = """f(g.next + 5)"""
#         a = """f(g.__next__ + 5)"""
#         self.check(b, a)
#
#     def test_noncall_access_3(self):
#         b = """f(g().next + 5)"""
#         a = """f(g().__next__ + 5)"""
#         self.check(b, a)
#
# class Test_nonzero(FixerTestCase):
#     fixer = "nonzero"
#
#     def test_1(self):
#         b = """
#             class A:
#                 def __nonzero__(self):
#                     pass
#             """
#         a = """
#             class A:
#                 def __bool__(self):
#                     pass
#             """
#         self.check(b, a)
#
#     def test_2(self):
#         b = """
#             class A(object):
#                 def __nonzero__(self):
#                     pass
#             """
#         a = """
#             class A(object):
#                 def __bool__(self):
#                     pass
#             """
#         self.check(b, a)
#
#     def test_unchanged_1(self):
#         s = """
#             class A(object):
#                 def __bool__(self):
#                     pass
#             """
#         self.unchanged(s)
#
#     def test_unchanged_2(self):
#         s = """
#             class A(object):
#                 def __nonzero__(self, a):
#                     pass
#             """
#         self.unchanged(s)
#
#     def test_unchanged_func(self):
#         s = """
#             def __nonzero__(self):
#                 pass
#             """
#         self.unchanged(s)
#
# class Test_numliterals(FixerTestCase):
#     fixer = "numliterals"
#
#     def test_octal_1(self):
#         b = """0755"""
#         a = """0o755"""
#         self.check(b, a)
#
#     def test_long_int_1(self):
#         b = """a = 12L"""
#         a = """a = 12"""
#         self.check(b, a)
#
#     def test_long_int_2(self):
#         b = """a = 12l"""
#         a = """a = 12"""
#         self.check(b, a)
#
#     def test_long_hex(self):
#         b = """b = 0x12l"""
#         a = """b = 0x12"""
#         self.check(b, a)
#
#     def test_comments_and_spacing(self):
#         b = """b =   0x12L"""
#         a = """b =   0x12"""
#         self.check(b, a)
#
#         b = """b = 0755 # spam"""
#         a = """b = 0o755 # spam"""
#         self.check(b, a)
#
#     def test_unchanged_int(self):
#         s = """5"""
#         self.unchanged(s)
#
#     def test_unchanged_float(self):
#         s = """5.0"""
#         self.unchanged(s)
#
#     def test_unchanged_octal(self):
#         s = """0o755"""
#         self.unchanged(s)
#
#     def test_unchanged_hex(self):
#         s = """0xABC"""
#         self.unchanged(s)
#
#     def test_unchanged_exp(self):
#         s = """5.0e10"""
#         self.unchanged(s)
#
#     def test_unchanged_complex_int(self):
#         s = """5 + 4j"""
#         self.unchanged(s)
#
#     def test_unchanged_complex_float(self):
#         s = """5.4 + 4.9j"""
#         self.unchanged(s)
#
#     def test_unchanged_complex_bare(self):
#         s = """4j"""
#         self.unchanged(s)
#         s = """4.4j"""
#         self.unchanged(s)
#
# class Test_renames(FixerTestCase):
#     fixer = "renames"
#
#     modules = {"sys":  ("maxint", "maxsize"),
#               }
#
#     def test_import_from(self):
#         for mod, (old, new) in self.modules.items():
#             b = "from %s import %s" % (mod, old)
#             a = "from %s import %s" % (mod, new)
#             self.check(b, a)
#
#             s = "from foo import %s" % old
#             self.unchanged(s)
#
#     def test_import_from_as(self):
#         for mod, (old, new) in self.modules.items():
#             b = "from %s import %s as foo_bar" % (mod, old)
#             a = "from %s import %s as foo_bar" % (mod, new)
#             self.check(b, a)
#
#     def test_import_module_usage(self):
#         for mod, (old, new) in self.modules.items():
#             b = """
#                 import %s
#                 foo(%s, %s.%s)
#                 """ % (mod, mod, mod, old)
#             a = """
#                 import %s
#                 foo(%s, %s.%s)
#                 """ % (mod, mod, mod, new)
#             self.check(b, a)
#
#     def XXX_test_from_import_usage(self):
#         # not implemented yet
#         for mod, (old, new) in self.modules.items():
#             b = """
#                 from %s import %s
#                 foo(%s, %s)
#                 """ % (mod, old, mod, old)
#             a = """
#                 from %s import %s
#                 foo(%s, %s)
#                 """ % (mod, new, mod, new)
#             self.check(b, a)
#
# class Test_unicode(FixerTestCase):
#     fixer = "unicode"
#
#     def test_whitespace(self):
#         b = """unicode( x)"""
#         a = """str( x)"""
#         self.check(b, a)
#
#         b = """ unicode(x )"""
#         a = """ str(x )"""
#         self.check(b, a)
#
#         b = """ u'h'"""
#         a = """ 'h'"""
#         self.check(b, a)
#
#     def test_unicode_call(self):
#         b = """unicode(x, y, z)"""
#         a = """str(x, y, z)"""
#         self.check(b, a)
#
#     def test_unichr(self):
#         b = """unichr(u'h')"""
#         a = """chr('h')"""
#         self.check(b, a)
#
#     def test_unicode_literal_1(self):
#         b = '''u"x"'''
#         a = '''"x"'''
#         self.check(b, a)
#
#     def test_unicode_literal_2(self):
#         b = """ur'x'"""
#         a = """r'x'"""
#         self.check(b, a)
#
#     def test_unicode_literal_3(self):
#         b = """UR'''x''' """
#         a = """R'''x''' """
#         self.check(b, a)
#
# class Test_callable(FixerTestCase):
#     fixer = "callable"
#
#     def test_prefix_preservation(self):
#         b = """callable(    x)"""
#         a = """import collections\nisinstance(    x, collections.Callable)"""
#         self.check(b, a)
#
#         b = """if     callable(x): pass"""
#         a = """import collections
# if     isinstance(x, collections.Callable): pass"""
#         self.check(b, a)
#
#     def test_callable_call(self):
#         b = """callable(x)"""
#         a = """import collections\nisinstance(x, collections.Callable)"""
#         self.check(b, a)
#
#     def test_global_import(self):
#         b = """
# def spam(foo):
#     callable(foo)"""[1:]
#         a = """
# import collections
# def spam(foo):
#     isinstance(foo, collections.Callable)"""[1:]
#         self.check(b, a)
#
#         b = """
# import collections
# def spam(foo):
#     callable(foo)"""[1:]
#         # same output if it was already imported
#         self.check(b, a)
#
#         b = """
# from collections import *
# def spam(foo):
#     callable(foo)"""[1:]
#         a = """
# from collections import *
# import collections
# def spam(foo):
#     isinstance(foo, collections.Callable)"""[1:]
#         self.check(b, a)
#
#         b = """
# do_stuff()
# do_some_other_stuff()
# assert callable(do_stuff)"""[1:]
#         a = """
# import collections
# do_stuff()
# do_some_other_stuff()
# assert isinstance(do_stuff, collections.Callable)"""[1:]
#         self.check(b, a)
#
#         b = """
# if isinstance(do_stuff, Callable):
#     assert callable(do_stuff)
#     do_stuff(do_stuff)
#     if not callable(do_stuff):
#         exit(1)
#     else:
#         assert callable(do_stuff)
# else:
#     assert not callable(do_stuff)"""[1:]
#         a = """
# import collections
# if isinstance(do_stuff, Callable):
#     assert isinstance(do_stuff, collections.Callable)
#     do_stuff(do_stuff)
#     if not isinstance(do_stuff, collections.Callable):
#         exit(1)
#     else:
#         assert isinstance(do_stuff, collections.Callable)
# else:
#     assert not isinstance(do_stuff, collections.Callable)"""[1:]
#         self.check(b, a)
#
#     def test_callable_should_not_change(self):
#         a = """callable(*x)"""
#         self.unchanged(a)
#
#         a = """callable(x, y)"""
#         self.unchanged(a)
#
#         a = """callable(x, kw=y)"""
#         self.unchanged(a)
#
#         a = """callable()"""
#         self.unchanged(a)
#
# class Test_filter(FixerTestCase):
#     fixer = "filter"
#
#     def test_prefix_preservation(self):
#         b = """x =   filter(    foo,     'abc'   )"""
#         a = """x =   list(filter(    foo,     'abc'   ))"""
#         self.check(b, a)
#
#         b = """x =   filter(  None , 'abc'  )"""
#         a = """x =   [_f for _f in 'abc' if _f]"""
#         self.check(b, a)
#
#     def test_filter_basic(self):
#         b = """x = filter(None, 'abc')"""
#         a = """x = [_f for _f in 'abc' if _f]"""
#         self.check(b, a)
#
#         b = """x = len(filter(f, 'abc'))"""
#         a = """x = len(list(filter(f, 'abc')))"""
#         self.check(b, a)
#
#         b = """x = filter(lambda x: x%2 == 0, range(10))"""
#         a = """x = [x for x in range(10) if x%2 == 0]"""
#         self.check(b, a)
#
#         # Note the parens around x
#         b = """x = filter(lambda (x): x%2 == 0, range(10))"""
#         a = """x = [x for x in range(10) if x%2 == 0]"""
#         self.check(b, a)
#
#         # XXX This (rare) case is not supported
# ##         b = """x = filter(f, 'abc')[0]"""
# ##         a = """x = list(filter(f, 'abc'))[0]"""
# ##         self.check(b, a)
#
#     def test_filter_nochange(self):
#         a = """b.join(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """(a + foo(5)).join(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """iter(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """list(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """list(filter(f, 'abc'))[0]"""
#         self.unchanged(a)
#         a = """set(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """set(filter(f, 'abc')).pop()"""
#         self.unchanged(a)
#         a = """tuple(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """any(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """all(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """sum(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """sorted(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """sorted(filter(f, 'abc'), key=blah)"""
#         self.unchanged(a)
#         a = """sorted(filter(f, 'abc'), key=blah)[0]"""
#         self.unchanged(a)
#         a = """enumerate(filter(f, 'abc'))"""
#         self.unchanged(a)
#         a = """enumerate(filter(f, 'abc'), start=1)"""
#         self.unchanged(a)
#         a = """for i in filter(f, 'abc'): pass"""
#         self.unchanged(a)
#         a = """[x for x in filter(f, 'abc')]"""
#         self.unchanged(a)
#         a = """(x for x in filter(f, 'abc'))"""
#         self.unchanged(a)
#
#     def test_future_builtins(self):
#         a = "from future_builtins import spam, filter; filter(f, 'ham')"
#         self.unchanged(a)
#
#         b = """from future_builtins import spam; x = filter(f, 'abc')"""
#         a = """from future_builtins import spam; x = list(filter(f, 'abc'))"""
#         self.check(b, a)
#
#         a = "from future_builtins import *; filter(f, 'ham')"
#         self.unchanged(a)
#
# class Test_map(FixerTestCase):
#     fixer = "map"
#
#     def check(self, b, a):
#         self.unchanged("from future_builtins import map; " + b, a)
#         super(Test_map, self).check(b, a)
#
#     def test_prefix_preservation(self):
#         b = """x =    map(   f,    'abc'   )"""
#         a = """x =    list(map(   f,    'abc'   ))"""
#         self.check(b, a)
#
#     def test_trailing_comment(self):
#         b = """x = map(f, 'abc')   #   foo"""
#         a = """x = list(map(f, 'abc'))   #   foo"""
#         self.check(b, a)
#
#     def test_None_with_multiple_arguments(self):
#         s = """x = map(None, a, b, c)"""
#         self.warns_unchanged(s, "cannot convert map(None, ...) with "
#                              "multiple arguments")
#
#     def test_map_basic(self):
#         b = """x = map(f, 'abc')"""
#         a = """x = list(map(f, 'abc'))"""
#         self.check(b, a)
#
#         b = """x = len(map(f, 'abc', 'def'))"""
#         a = """x = len(list(map(f, 'abc', 'def')))"""
#         self.check(b, a)
#
#         b = """x = map(None, 'abc')"""
#         a = """x = list('abc')"""
#         self.check(b, a)
#
#         b = """x = map(lambda x: x+1, range(4))"""
#         a = """x = [x+1 for x in range(4)]"""
#         self.check(b, a)
#
#         # Note the parens around x
#         b = """x = map(lambda (x): x+1, range(4))"""
#         a = """x = [x+1 for x in range(4)]"""
#         self.check(b, a)
#
#         b = """
#             foo()
#             # foo
#             map(f, x)
#             """
#         a = """
#             foo()
#             # foo
#             list(map(f, x))
#             """
#         self.warns(b, a, "You should use a for loop here")
#
#         # XXX This (rare) case is not supported
# ##         b = """x = map(f, 'abc')[0]"""
# ##         a = """x = list(map(f, 'abc'))[0]"""
# ##         self.check(b, a)
#
#     def test_map_nochange(self):
#         a = """b.join(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """(a + foo(5)).join(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """iter(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """list(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """list(map(f, 'abc'))[0]"""
#         self.unchanged(a)
#         a = """set(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """set(map(f, 'abc')).pop()"""
#         self.unchanged(a)
#         a = """tuple(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """any(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """all(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """sum(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """sorted(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """sorted(map(f, 'abc'), key=blah)"""
#         self.unchanged(a)
#         a = """sorted(map(f, 'abc'), key=blah)[0]"""
#         self.unchanged(a)
#         a = """enumerate(map(f, 'abc'))"""
#         self.unchanged(a)
#         a = """enumerate(map(f, 'abc'), start=1)"""
#         self.unchanged(a)
#         a = """for i in map(f, 'abc'): pass"""
#         self.unchanged(a)
#         a = """[x for x in map(f, 'abc')]"""
#         self.unchanged(a)
#         a = """(x for x in map(f, 'abc'))"""
#         self.unchanged(a)
#
#     def test_future_builtins(self):
#         a = "from future_builtins import spam, map, eggs; map(f, 'ham')"
#         self.unchanged(a)
#
#         b = """from future_builtins import spam, eggs; x = map(f, 'abc')"""
#         a = """from future_builtins import spam, eggs; x = list(map(f, 'abc'))"""
#         self.check(b, a)
#
#         a = "from future_builtins import *; map(f, 'ham')"
#         self.unchanged(a)
#
# class Test_zip(FixerTestCase):
#     fixer = "zip"
#
#     def check(self, b, a):
#         self.unchanged("from future_builtins import zip; " + b, a)
#         super(Test_zip, self).check(b, a)
#
#     def test_zip_basic(self):
#         b = """x = zip(a, b, c)"""
#         a = """x = list(zip(a, b, c))"""
#         self.check(b, a)
#
#         b = """x = len(zip(a, b))"""
#         a = """x = len(list(zip(a, b)))"""
#         self.check(b, a)
#
#     def test_zip_nochange(self):
#         a = """b.join(zip(a, b))"""
#         self.unchanged(a)
#         a = """(a + foo(5)).join(zip(a, b))"""
#         self.unchanged(a)
#         a = """iter(zip(a, b))"""
#         self.unchanged(a)
#         a = """list(zip(a, b))"""
#         self.unchanged(a)
#         a = """list(zip(a, b))[0]"""
#         self.unchanged(a)
#         a = """set(zip(a, b))"""
#         self.unchanged(a)
#         a = """set(zip(a, b)).pop()"""
#         self.unchanged(a)
#         a = """tuple(zip(a, b))"""
#         self.unchanged(a)
#         a = """any(zip(a, b))"""
#         self.unchanged(a)
#         a = """all(zip(a, b))"""
#         self.unchanged(a)
#         a = """sum(zip(a, b))"""
#         self.unchanged(a)
#         a = """sorted(zip(a, b))"""
#         self.unchanged(a)
#         a = """sorted(zip(a, b), key=blah)"""
#         self.unchanged(a)
#         a = """sorted(zip(a, b), key=blah)[0]"""
#         self.unchanged(a)
#         a = """enumerate(zip(a, b))"""
#         self.unchanged(a)
#         a = """enumerate(zip(a, b), start=1)"""
#         self.unchanged(a)
#         a = """for i in zip(a, b): pass"""
#         self.unchanged(a)
#         a = """[x for x in zip(a, b)]"""
#         self.unchanged(a)
#         a = """(x for x in zip(a, b))"""
#         self.unchanged(a)
#
#     def test_future_builtins(self):
#         a = "from future_builtins import spam, zip, eggs; zip(a, b)"
#         self.unchanged(a)
#
#         b = """from future_builtins import spam, eggs; x = zip(a, b)"""
#         a = """from future_builtins import spam, eggs; x = list(zip(a, b))"""
#         self.check(b, a)
#
#         a = "from future_builtins import *; zip(a, b)"
#         self.unchanged(a)
#
# class Test_standarderror(FixerTestCase):
#     fixer = "standarderror"
#
#     def test(self):
#         b = """x =    StandardError()"""
#         a = """x =    Exception()"""
#         self.check(b, a)
#
#         b = """x = StandardError(a, b, c)"""
#         a = """x = Exception(a, b, c)"""
#         self.check(b, a)
#
#         b = """f(2 + StandardError(a, b, c))"""
#         a = """f(2 + Exception(a, b, c))"""
#         self.check(b, a)
#
# class Test_types(FixerTestCase):
#     fixer = "types"
#
#     def test_basic_types_convert(self):
#         b = """types.StringType"""
#         a = """bytes"""
#         self.check(b, a)
#
#         b = """types.DictType"""
#         a = """dict"""
#         self.check(b, a)
#
#         b = """types . IntType"""
#         a = """int"""
#         self.check(b, a)
#
#         b = """types.ListType"""
#         a = """list"""
#         self.check(b, a)
#
#         b = """types.LongType"""
#         a = """int"""
#         self.check(b, a)
#
#         b = """types.NoneType"""
#         a = """type(None)"""
#         self.check(b, a)
#
# class Test_idioms(FixerTestCase):
#     fixer = "idioms"
#
#     def test_while(self):
#         b = """while 1: foo()"""
#         a = """while True: foo()"""
#         self.check(b, a)
#
#         b = """while   1: foo()"""
#         a = """while   True: foo()"""
#         self.check(b, a)
#
#         b = """
#             while 1:
#                 foo()
#             """
#         a = """
#             while True:
#                 foo()
#             """
#         self.check(b, a)
#
#     def test_while_unchanged(self):
#         s = """while 11: foo()"""
#         self.unchanged(s)
#
#         s = """while 0: foo()"""
#         self.unchanged(s)
#
#         s = """while foo(): foo()"""
#         self.unchanged(s)
#
#         s = """while []: foo()"""
#         self.unchanged(s)
#
#     def test_eq_simple(self):
#         b = """type(x) == T"""
#         a = """isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   type(x) == T: pass"""
#         a = """if   isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_eq_reverse(self):
#         b = """T == type(x)"""
#         a = """isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   T == type(x): pass"""
#         a = """if   isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_eq_expression(self):
#         b = """type(x+y) == d.get('T')"""
#         a = """isinstance(x+y, d.get('T'))"""
#         self.check(b, a)
#
#         b = """type(   x  +  y) == d.get('T')"""
#         a = """isinstance(x  +  y, d.get('T'))"""
#         self.check(b, a)
#
#     def test_is_simple(self):
#         b = """type(x) is T"""
#         a = """isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   type(x) is T: pass"""
#         a = """if   isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_is_reverse(self):
#         b = """T is type(x)"""
#         a = """isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   T is type(x): pass"""
#         a = """if   isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_is_expression(self):
#         b = """type(x+y) is d.get('T')"""
#         a = """isinstance(x+y, d.get('T'))"""
#         self.check(b, a)
#
#         b = """type(   x  +  y) is d.get('T')"""
#         a = """isinstance(x  +  y, d.get('T'))"""
#         self.check(b, a)
#
#     def test_is_not_simple(self):
#         b = """type(x) is not T"""
#         a = """not isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   type(x) is not T: pass"""
#         a = """if   not isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_is_not_reverse(self):
#         b = """T is not type(x)"""
#         a = """not isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   T is not type(x): pass"""
#         a = """if   not isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_is_not_expression(self):
#         b = """type(x+y) is not d.get('T')"""
#         a = """not isinstance(x+y, d.get('T'))"""
#         self.check(b, a)
#
#         b = """type(   x  +  y) is not d.get('T')"""
#         a = """not isinstance(x  +  y, d.get('T'))"""
#         self.check(b, a)
#
#     def test_ne_simple(self):
#         b = """type(x) != T"""
#         a = """not isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   type(x) != T: pass"""
#         a = """if   not isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_ne_reverse(self):
#         b = """T != type(x)"""
#         a = """not isinstance(x, T)"""
#         self.check(b, a)
#
#         b = """if   T != type(x): pass"""
#         a = """if   not isinstance(x, T): pass"""
#         self.check(b, a)
#
#     def test_ne_expression(self):
#         b = """type(x+y) != d.get('T')"""
#         a = """not isinstance(x+y, d.get('T'))"""
#         self.check(b, a)
#
#         b = """type(   x  +  y) != d.get('T')"""
#         a = """not isinstance(x  +  y, d.get('T'))"""
#         self.check(b, a)
#
#     def test_type_unchanged(self):
#         a = """type(x).__name__"""
#         self.unchanged(a)
#
#     def test_sort_list_call(self):
#         b = """
#             v = list(t)
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(t)
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             v = list(foo(b) + d)
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(foo(b) + d)
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             while x:
#                 v = list(t)
#                 v.sort()
#                 foo(v)
#             """
#         a = """
#             while x:
#                 v = sorted(t)
#                 foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             v = list(t)
#             # foo
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(t)
#             # foo
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = r"""
#             v = list(   t)
#             v.sort()
#             foo(v)
#             """
#         a = r"""
#             v = sorted(   t)
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = r"""
#             try:
#                 m = list(s)
#                 m.sort()
#             except: pass
#             """
#
#         a = r"""
#             try:
#                 m = sorted(s)
#             except: pass
#             """
#         self.check(b, a)
#
#         b = r"""
#             try:
#                 m = list(s)
#                 # foo
#                 m.sort()
#             except: pass
#             """
#
#         a = r"""
#             try:
#                 m = sorted(s)
#                 # foo
#             except: pass
#             """
#         self.check(b, a)
#
#         b = r"""
#             m = list(s)
#             # more comments
#             m.sort()"""
#
#         a = r"""
#             m = sorted(s)
#             # more comments"""
#         self.check(b, a)
#
#     def test_sort_simple_expr(self):
#         b = """
#             v = t
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(t)
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             v = foo(b)
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(foo(b))
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             v = b.keys()
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(b.keys())
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             v = foo(b) + d
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(foo(b) + d)
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             while x:
#                 v = t
#                 v.sort()
#                 foo(v)
#             """
#         a = """
#             while x:
#                 v = sorted(t)
#                 foo(v)
#             """
#         self.check(b, a)
#
#         b = """
#             v = t
#             # foo
#             v.sort()
#             foo(v)
#             """
#         a = """
#             v = sorted(t)
#             # foo
#             foo(v)
#             """
#         self.check(b, a)
#
#         b = r"""
#             v =   t
#             v.sort()
#             foo(v)
#             """
#         a = r"""
#             v =   sorted(t)
#             foo(v)
#             """
#         self.check(b, a)
#
#     def test_sort_unchanged(self):
#         s = """
#             v = list(t)
#             w.sort()
#             foo(w)
#             """
#         self.unchanged(s)
#
#         s = """
#             v = list(t)
#             v.sort(u)
#             foo(v)
#             """
#         self.unchanged(s)
#
# class Test_basestring(FixerTestCase):
#     fixer = "basestring"
#
#     def test_basestring(self):
#         b = """isinstance(x, basestring)"""
#         a = """isinstance(x, str)"""
#         self.check(b, a)
#
# class Test_buffer(FixerTestCase):
#     fixer = "buffer"
#
#     def test_buffer(self):
#         b = """x = buffer(y)"""
#         a = """x = memoryview(y)"""
#         self.check(b, a)
#
#     def test_slicing(self):
#         b = """buffer(y)[4:5]"""
#         a = """memoryview(y)[4:5]"""
#         self.check(b, a)
#
# class Test_future(FixerTestCase):
#     fixer = "future"
#
#     def test_future(self):
#         b = """from __future__ import braces"""
#         a = """"""
#         self.check(b, a)
#
#         b = """# comment\nfrom __future__ import braces"""
#         a = """# comment\n"""
#         self.check(b, a)
#
#         b = """from __future__ import braces\n# comment"""
#         a = """\n# comment"""
#         self.check(b, a)
#
#     def test_run_order(self):
#         self.assert_runs_after('print')
#
# class Test_itertools(FixerTestCase):
#     fixer = "itertools"
#
#     def checkall(self, before, after):
#         # Because we need to check with and without the itertools prefix
#         # and on each of the three functions, these loops make it all
#         # much easier
#         for i in ('itertools.', ''):
#             for f in ('map', 'filter', 'zip'):
#                 b = before %(i+'i'+f)
#                 a = after %(f)
#                 self.check(b, a)
#
#     def test_0(self):
#         # A simple example -- test_1 covers exactly the same thing,
#         # but it's not quite as clear.
#         b = "itertools.izip(a, b)"
#         a = "zip(a, b)"
#         self.check(b, a)
#
#     def test_1(self):
#         b = """%s(f, a)"""
#         a = """%s(f, a)"""
#         self.checkall(b, a)
#
#     def test_qualified(self):
#         b = """itertools.ifilterfalse(a, b)"""
#         a = """itertools.filterfalse(a, b)"""
#         self.check(b, a)
#
#         b = """itertools.izip_longest(a, b)"""
#         a = """itertools.zip_longest(a, b)"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """ifilterfalse(a, b)"""
#         a = """filterfalse(a, b)"""
#         self.check(b, a)
#
#         b = """izip_longest(a, b)"""
#         a = """zip_longest(a, b)"""
#         self.check(b, a)
#
#     def test_space_1(self):
#         b = """    %s(f, a)"""
#         a = """    %s(f, a)"""
#         self.checkall(b, a)
#
#     def test_space_2(self):
#         b = """    itertools.ifilterfalse(a, b)"""
#         a = """    itertools.filterfalse(a, b)"""
#         self.check(b, a)
#
#         b = """    itertools.izip_longest(a, b)"""
#         a = """    itertools.zip_longest(a, b)"""
#         self.check(b, a)
#
#     def test_run_order(self):
#         self.assert_runs_after('map', 'zip', 'filter')
#
#
# class Test_itertools_imports(FixerTestCase):
#     fixer = 'itertools_imports'
#
#     def test_reduced(self):
#         b = "from itertools import imap, izip, foo"
#         a = "from itertools import foo"
#         self.check(b, a)
#
#         b = "from itertools import bar, imap, izip, foo"
#         a = "from itertools import bar, foo"
#         self.check(b, a)
#
#         b = "from itertools import chain, imap, izip"
#         a = "from itertools import chain"
#         self.check(b, a)
#
#     def test_comments(self):
#         b = "#foo\nfrom itertools import imap, izip"
#         a = "#foo\n"
#         self.check(b, a)
#
#     def test_none(self):
#         b = "from itertools import imap, izip"
#         a = ""
#         self.check(b, a)
#
#         b = "from itertools import izip"
#         a = ""
#         self.check(b, a)
#
#     def test_import_as(self):
#         b = "from itertools import izip, bar as bang, imap"
#         a = "from itertools import bar as bang"
#         self.check(b, a)
#
#         b = "from itertools import izip as _zip, imap, bar"
#         a = "from itertools import bar"
#         self.check(b, a)
#
#         b = "from itertools import imap as _map"
#         a = ""
#         self.check(b, a)
#
#         b = "from itertools import imap as _map, izip as _zip"
#         a = ""
#         self.check(b, a)
#
#         s = "from itertools import bar as bang"
#         self.unchanged(s)
#
#     def test_ifilter_and_zip_longest(self):
#         for name in "filterfalse", "zip_longest":
#             b = "from itertools import i%s" % (name,)
#             a = "from itertools import %s" % (name,)
#             self.check(b, a)
#
#             b = "from itertools import imap, i%s, foo" % (name,)
#             a = "from itertools import %s, foo" % (name,)
#             self.check(b, a)
#
#             b = "from itertools import bar, i%s, foo" % (name,)
#             a = "from itertools import bar, %s, foo" % (name,)
#             self.check(b, a)
#
#     def test_import_star(self):
#         s = "from itertools import *"
#         self.unchanged(s)
#
#
#     def test_unchanged(self):
#         s = "from itertools import foo"
#         self.unchanged(s)
#
#
# class Test_import(FixerTestCase):
#     fixer = "import"
#
#     def setUp(self):
#         super(Test_import, self).setUp()
#         # Need to replace fix_import's exists method
#         # so we can check that it's doing the right thing
#         self.files_checked = []
#         self.present_files = set()
#         self.always_exists = True
#         def fake_exists(name):
#             self.files_checked.append(name)
#             return self.always_exists or (name in self.present_files)
#
#         from lib2to3.fixes import fix_import
#         fix_import.exists = fake_exists
#
#     def tearDown(self):
#         from lib2to3.fixes import fix_import
#         fix_import.exists = os.path.exists
#
#     def check_both(self, b, a):
#         self.always_exists = True
#         super(Test_import, self).check(b, a)
#         self.always_exists = False
#         super(Test_import, self).unchanged(b)
#
#     def test_files_checked(self):
#         def p(path):
#             # Takes a unix path and returns a path with correct separators
#             return os.path.pathsep.join(path.split("/"))
#
#         self.always_exists = False
#         self.present_files = set(['__init__.py'])
#         expected_extensions = ('.py', os.path.sep, '.pyc', '.so', '.sl', '.pyd')
#         names_to_test = (p("/spam/eggs.py"), "ni.py", p("../../shrubbery.py"))
#
#         for name in names_to_test:
#             self.files_checked = []
#             self.filename = name
#             self.unchanged("import jam")
#
#             if os.path.dirname(name):
#                 name = os.path.dirname(name) + '/jam'
#             else:
#                 name = 'jam'
#             expected_checks = set(name + ext for ext in expected_extensions)
#             expected_checks.add("__init__.py")
#
#             self.assertEqual(set(self.files_checked), expected_checks)
#
#     def test_not_in_package(self):
#         s = "import bar"
#         self.always_exists = False
#         self.present_files = set(["bar.py"])
#         self.unchanged(s)
#
#     def test_with_absolute_import_enabled(self):
#         s = "from __future__ import absolute_import\nimport bar"
#         self.always_exists = False
#         self.present_files = set(["__init__.py", "bar.py"])
#         self.unchanged(s)
#
#     def test_in_package(self):
#         b = "import bar"
#         a = "from . import bar"
#         self.always_exists = False
#         self.present_files = set(["__init__.py", "bar.py"])
#         self.check(b, a)
#
#     def test_import_from_package(self):
#         b = "import bar"
#         a = "from . import bar"
#         self.always_exists = False
#         self.present_files = set(["__init__.py", "bar" + os.path.sep])
#         self.check(b, a)
#
#     def test_already_relative_import(self):
#         s = "from . import bar"
#         self.unchanged(s)
#
#     def test_comments_and_indent(self):
#         b = "import bar # Foo"
#         a = "from . import bar # Foo"
#         self.check(b, a)
#
#     def test_from(self):
#         b = "from foo import bar, baz"
#         a = "from .foo import bar, baz"
#         self.check_both(b, a)
#
#         b = "from foo import bar"
#         a = "from .foo import bar"
#         self.check_both(b, a)
#
#         b = "from foo import (bar, baz)"
#         a = "from .foo import (bar, baz)"
#         self.check_both(b, a)
#
#     def test_dotted_from(self):
#         b = "from green.eggs import ham"
#         a = "from .green.eggs import ham"
#         self.check_both(b, a)
#
#     def test_from_as(self):
#         b = "from green.eggs import ham as spam"
#         a = "from .green.eggs import ham as spam"
#         self.check_both(b, a)
#
#     def test_import(self):
#         b = "import foo"
#         a = "from . import foo"
#         self.check_both(b, a)
#
#         b = "import foo, bar"
#         a = "from . import foo, bar"
#         self.check_both(b, a)
#
#         b = "import foo, bar, x"
#         a = "from . import foo, bar, x"
#         self.check_both(b, a)
#
#         b = "import x, y, z"
#         a = "from . import x, y, z"
#         self.check_both(b, a)
#
#     def test_import_as(self):
#         b = "import foo as x"
#         a = "from . import foo as x"
#         self.check_both(b, a)
#
#         b = "import a as b, b as c, c as d"
#         a = "from . import a as b, b as c, c as d"
#         self.check_both(b, a)
#
#     def test_local_and_absolute(self):
#         self.always_exists = False
#         self.present_files = set(["foo.py", "__init__.py"])
#
#         s = "import foo, bar"
#         self.warns_unchanged(s, "absolute and local imports together")
#
#     def test_dotted_import(self):
#         b = "import foo.bar"
#         a = "from . import foo.bar"
#         self.check_both(b, a)
#
#     def test_dotted_import_as(self):
#         b = "import foo.bar as bang"
#         a = "from . import foo.bar as bang"
#         self.check_both(b, a)
#
#     def test_prefix(self):
#         b = """
#         # prefix
#         import foo.bar
#         """
#         a = """
#         # prefix
#         from . import foo.bar
#         """
#         self.check_both(b, a)
#
#
# class Test_set_literal(FixerTestCase):
#
#     fixer = "set_literal"
#
#     def test_basic(self):
#         b = """set([1, 2, 3])"""
#         a = """{1, 2, 3}"""
#         self.check(b, a)
#
#         b = """set((1, 2, 3))"""
#         a = """{1, 2, 3}"""
#         self.check(b, a)
#
#         b = """set((1,))"""
#         a = """{1}"""
#         self.check(b, a)
#
#         b = """set([1])"""
#         self.check(b, a)
#
#         b = """set((a, b))"""
#         a = """{a, b}"""
#         self.check(b, a)
#
#         b = """set([a, b])"""
#         self.check(b, a)
#
#         b = """set((a*234, f(args=23)))"""
#         a = """{a*234, f(args=23)}"""
#         self.check(b, a)
#
#         b = """set([a*23, f(23)])"""
#         a = """{a*23, f(23)}"""
#         self.check(b, a)
#
#         b = """set([a-234**23])"""
#         a = """{a-234**23}"""
#         self.check(b, a)
#
#     def test_listcomps(self):
#         b = """set([x for x in y])"""
#         a = """{x for x in y}"""
#         self.check(b, a)
#
#         b = """set([x for x in y if x == m])"""
#         a = """{x for x in y if x == m}"""
#         self.check(b, a)
#
#         b = """set([x for x in y for a in b])"""
#         a = """{x for x in y for a in b}"""
#         self.check(b, a)
#
#         b = """set([f(x) - 23 for x in y])"""
#         a = """{f(x) - 23 for x in y}"""
#         self.check(b, a)
#
#     def test_whitespace(self):
#         b = """set( [1, 2])"""
#         a = """{1, 2}"""
#         self.check(b, a)
#
#         b = """set([1 ,  2])"""
#         a = """{1 ,  2}"""
#         self.check(b, a)
#
#         b = """set([ 1 ])"""
#         a = """{ 1 }"""
#         self.check(b, a)
#
#         b = """set( [1] )"""
#         a = """{1}"""
#         self.check(b, a)
#
#         b = """set([  1,  2  ])"""
#         a = """{  1,  2  }"""
#         self.check(b, a)
#
#         b = """set([x  for x in y ])"""
#         a = """{x  for x in y }"""
#         self.check(b, a)
#
#         b = """set(
#                    [1, 2]
#                )
#             """
#         a = """{1, 2}\n"""
#         self.check(b, a)
#
#     def test_comments(self):
#         b = """set((1, 2)) # Hi"""
#         a = """{1, 2} # Hi"""
#         self.check(b, a)
#
#         # This isn't optimal behavior, but the fixer is optional.
#         b = """
#             # Foo
#             set( # Bar
#                (1, 2)
#             )
#             """
#         a = """
#             # Foo
#             {1, 2}
#             """
#         self.check(b, a)
#
#     def test_unchanged(self):
#         s = """set()"""
#         self.unchanged(s)
#
#         s = """set(a)"""
#         self.unchanged(s)
#
#         s = """set(a, b, c)"""
#         self.unchanged(s)
#
#         # Don't transform generators because they might have to be lazy.
#         s = """set(x for x in y)"""
#         self.unchanged(s)
#
#         s = """set(x for x in y if z)"""
#         self.unchanged(s)
#
#         s = """set(a*823-23**2 + f(23))"""
#         self.unchanged(s)
#
#
# class Test_sys_exc(FixerTestCase):
#     fixer = "sys_exc"
#
#     def test_0(self):
#         b = "sys.exc_type"
#         a = "sys.exc_info()[0]"
#         self.check(b, a)
#
#     def test_1(self):
#         b = "sys.exc_value"
#         a = "sys.exc_info()[1]"
#         self.check(b, a)
#
#     def test_2(self):
#         b = "sys.exc_traceback"
#         a = "sys.exc_info()[2]"
#         self.check(b, a)
#
#     def test_3(self):
#         b = "sys.exc_type # Foo"
#         a = "sys.exc_info()[0] # Foo"
#         self.check(b, a)
#
#     def test_4(self):
#         b = "sys.  exc_type"
#         a = "sys.  exc_info()[0]"
#         self.check(b, a)
#
#     def test_5(self):
#         b = "sys  .exc_type"
#         a = "sys  .exc_info()[0]"
#         self.check(b, a)
#
#
# class Test_paren(FixerTestCase):
#     fixer = "paren"
#
#     def test_0(self):
#         b = """[i for i in 1, 2 ]"""
#         a = """[i for i in (1, 2) ]"""
#         self.check(b, a)
#
#     def test_1(self):
#         b = """[i for i in 1, 2, ]"""
#         a = """[i for i in (1, 2,) ]"""
#         self.check(b, a)
#
#     def test_2(self):
#         b = """[i for i  in     1, 2 ]"""
#         a = """[i for i  in     (1, 2) ]"""
#         self.check(b, a)
#
#     def test_3(self):
#         b = """[i for i in 1, 2 if i]"""
#         a = """[i for i in (1, 2) if i]"""
#         self.check(b, a)
#
#     def test_4(self):
#         b = """[i for i in 1,    2    ]"""
#         a = """[i for i in (1,    2)    ]"""
#         self.check(b, a)
#
#     def test_5(self):
#         b = """(i for i in 1, 2)"""
#         a = """(i for i in (1, 2))"""
#         self.check(b, a)
#
#     def test_6(self):
#         b = """(i for i in 1   ,2   if i)"""
#         a = """(i for i in (1   ,2)   if i)"""
#         self.check(b, a)
#
#     def test_unchanged_0(self):
#         s = """[i for i in (1, 2)]"""
#         self.unchanged(s)
#
#     def test_unchanged_1(self):
#         s = """[i for i in foo()]"""
#         self.unchanged(s)
#
#     def test_unchanged_2(self):
#         s = """[i for i in (1, 2) if nothing]"""
#         self.unchanged(s)
#
#     def test_unchanged_3(self):
#         s = """(i for i in (1, 2))"""
#         self.unchanged(s)
#
#     def test_unchanged_4(self):
#         s = """[i for i in m]"""
#         self.unchanged(s)
#
# class Test_metaclass(FixerTestCase):
#
#     fixer = 'metaclass'
#
#     def test_unchanged(self):
#         self.unchanged("class X(): pass")
#         self.unchanged("class X(object): pass")
#         self.unchanged("class X(object1, object2): pass")
#         self.unchanged("class X(object1, object2, object3): pass")
#         self.unchanged("class X(metaclass=Meta): pass")
#         self.unchanged("class X(b, arg=23, metclass=Meta): pass")
#         self.unchanged("class X(b, arg=23, metaclass=Meta, other=42): pass")
#
#         s = """
#         class X:
#             def __metaclass__(self): pass
#         """
#         self.unchanged(s)
#
#         s = """
#         class X:
#             a[23] = 74
#         """
#         self.unchanged(s)
#
#     def test_comments(self):
#         b = """
#         class X:
#             # hi
#             __metaclass__ = AppleMeta
#         """
#         a = """
#         class X(metaclass=AppleMeta):
#             # hi
#             pass
#         """
#         self.check(b, a)
#
#         b = """
#         class X:
#             __metaclass__ = Meta
#             # Bedtime!
#         """
#         a = """
#         class X(metaclass=Meta):
#             pass
#             # Bedtime!
#         """
#         self.check(b, a)
#
#     def test_meta(self):
#         # no-parent class, odd body
#         b = """
#         class X():
#             __metaclass__ = Q
#             pass
#         """
#         a = """
#         class X(metaclass=Q):
#             pass
#         """
#         self.check(b, a)
#
#         # one parent class, no body
#         b = """class X(object): __metaclass__ = Q"""
#         a = """class X(object, metaclass=Q): pass"""
#         self.check(b, a)
#
#
#         # one parent, simple body
#         b = """
#         class X(object):
#             __metaclass__ = Meta
#             bar = 7
#         """
#         a = """
#         class X(object, metaclass=Meta):
#             bar = 7
#         """
#         self.check(b, a)
#
#         b = """
#         class X:
#             __metaclass__ = Meta; x = 4; g = 23
#         """
#         a = """
#         class X(metaclass=Meta):
#             x = 4; g = 23
#         """
#         self.check(b, a)
#
#         # one parent, simple body, __metaclass__ last
#         b = """
#         class X(object):
#             bar = 7
#             __metaclass__ = Meta
#         """
#         a = """
#         class X(object, metaclass=Meta):
#             bar = 7
#         """
#         self.check(b, a)
#
#         # redefining __metaclass__
#         b = """
#         class X():
#             __metaclass__ = A
#             __metaclass__ = B
#             bar = 7
#         """
#         a = """
#         class X(metaclass=B):
#             bar = 7
#         """
#         self.check(b, a)
#
#         # multiple inheritance, simple body
#         b = """
#         class X(clsA, clsB):
#             __metaclass__ = Meta
#             bar = 7
#         """
#         a = """
#         class X(clsA, clsB, metaclass=Meta):
#             bar = 7
#         """
#         self.check(b, a)
#
#         # keywords in the class statement
#         b = """class m(a, arg=23): __metaclass__ = Meta"""
#         a = """class m(a, arg=23, metaclass=Meta): pass"""
#         self.check(b, a)
#
#         b = """
#         class X(expression(2 + 4)):
#             __metaclass__ = Meta
#         """
#         a = """
#         class X(expression(2 + 4), metaclass=Meta):
#             pass
#         """
#         self.check(b, a)
#
#         b = """
#         class X(expression(2 + 4), x**4):
#             __metaclass__ = Meta
#         """
#         a = """
#         class X(expression(2 + 4), x**4, metaclass=Meta):
#             pass
#         """
#         self.check(b, a)
#
#         b = """
#         class X:
#             __metaclass__ = Meta
#             save.py = 23
#         """
#         a = """
#         class X(metaclass=Meta):
#             save.py = 23
#         """
#         self.check(b, a)
#
#
# class Test_getcwdu(FixerTestCase):
#
#     fixer = 'getcwdu'
#
#     def test_basic(self):
#         b = """os.getcwdu"""
#         a = """os.getcwd"""
#         self.check(b, a)
#
#         b = """os.getcwdu()"""
#         a = """os.getcwd()"""
#         self.check(b, a)
#
#         b = """meth = os.getcwdu"""
#         a = """meth = os.getcwd"""
#         self.check(b, a)
#
#         b = """os.getcwdu(args)"""
#         a = """os.getcwd(args)"""
#         self.check(b, a)
#
#     def test_comment(self):
#         b = """os.getcwdu() # Foo"""
#         a = """os.getcwd() # Foo"""
#         self.check(b, a)
#
#     def test_unchanged(self):
#         s = """os.getcwd()"""
#         self.unchanged(s)
#
#         s = """getcwdu()"""
#         self.unchanged(s)
#
#         s = """os.getcwdb()"""
#         self.unchanged(s)
#
#     def test_indentation(self):
#         b = """
#             if 1:
#                 os.getcwdu()
#             """
#         a = """
#             if 1:
#                 os.getcwd()
#             """
#         self.check(b, a)
#
#     def test_multilation(self):
#         b = """os .getcwdu()"""
#         a = """os .getcwd()"""
#         self.check(b, a)
#
#         b = """os.  getcwdu"""
#         a = """os.  getcwd"""
#         self.check(b, a)
#
#         b = """os.getcwdu (  )"""
#         a = """os.getcwd (  )"""
#         self.check(b, a)
#
#
# class Test_operator(FixerTestCase):
#
#     fixer = "operator"
#
#     def test_operator_isCallable(self):
#         b = "operator.isCallable(x)"
#         a = "hasattr(x, '__call__')"
#         self.check(b, a)
#
#     def test_operator_sequenceIncludes(self):
#         b = "operator.sequenceIncludes(x, y)"
#         a = "operator.contains(x, y)"
#         self.check(b, a)
#
#         b = "operator .sequenceIncludes(x, y)"
#         a = "operator .contains(x, y)"
#         self.check(b, a)
#
#         b = "operator.  sequenceIncludes(x, y)"
#         a = "operator.  contains(x, y)"
#         self.check(b, a)
#
#     def test_operator_isSequenceType(self):
#         b = "operator.isSequenceType(x)"
#         a = "import collections\nisinstance(x, collections.Sequence)"
#         self.check(b, a)
#
#     def test_operator_isMappingType(self):
#         b = "operator.isMappingType(x)"
#         a = "import collections\nisinstance(x, collections.Mapping)"
#         self.check(b, a)
#
#     def test_operator_isNumberType(self):
#         b = "operator.isNumberType(x)"
#         a = "import numbers\nisinstance(x, numbers.Number)"
#         self.check(b, a)
#
#     def test_operator_repeat(self):
#         b = "operator.repeat(x, n)"
#         a = "operator.mul(x, n)"
#         self.check(b, a)
#
#         b = "operator .repeat(x, n)"
#         a = "operator .mul(x, n)"
#         self.check(b, a)
#
#         b = "operator.  repeat(x, n)"
#         a = "operator.  mul(x, n)"
#         self.check(b, a)
#
#     def test_operator_irepeat(self):
#         b = "operator.irepeat(x, n)"
#         a = "operator.imul(x, n)"
#         self.check(b, a)
#
#         b = "operator .irepeat(x, n)"
#         a = "operator .imul(x, n)"
#         self.check(b, a)
#
#         b = "operator.  irepeat(x, n)"
#         a = "operator.  imul(x, n)"
#         self.check(b, a)
#
#     def test_bare_isCallable(self):
#         s = "isCallable(x)"
#         t = "You should use 'hasattr(x, '__call__')' here."
#         self.warns_unchanged(s, t)
#
#     def test_bare_sequenceIncludes(self):
#         s = "sequenceIncludes(x, y)"
#         t = "You should use 'operator.contains(x, y)' here."
#         self.warns_unchanged(s, t)
#
#     def test_bare_operator_isSequenceType(self):
#         s = "isSequenceType(z)"
#         t = "You should use 'isinstance(z, collections.Sequence)' here."
#         self.warns_unchanged(s, t)
#
#     def test_bare_operator_isMappingType(self):
#         s = "isMappingType(x)"
#         t = "You should use 'isinstance(x, collections.Mapping)' here."
#         self.warns_unchanged(s, t)
#
#     def test_bare_operator_isNumberType(self):
#         s = "isNumberType(y)"
#         t = "You should use 'isinstance(y, numbers.Number)' here."
#         self.warns_unchanged(s, t)
#
#     def test_bare_operator_repeat(self):
#         s = "repeat(x, n)"
#         t = "You should use 'operator.mul(x, n)' here."
#         self.warns_unchanged(s, t)
#
#     def test_bare_operator_irepeat(self):
#         s = "irepeat(y, 187)"
#         t = "You should use 'operator.imul(y, 187)' here."
#         self.warns_unchanged(s, t)
#
#
# class Test_exitfunc(FixerTestCase):
#
#     fixer = "exitfunc"
#
#     def test_simple(self):
#         b = """
#             import sys
#             sys.exitfunc = my_atexit
#             """
#         a = """
#             import sys
#             import atexit
#             atexit.register(my_atexit)
#             """
#         self.check(b, a)
#
#     def test_names_import(self):
#         b = """
#             import sys, crumbs
#             sys.exitfunc = my_func
#             """
#         a = """
#             import sys, crumbs, atexit
#             atexit.register(my_func)
#             """
#         self.check(b, a)
#
#     def test_complex_expression(self):
#         b = """
#             import sys
#             sys.exitfunc = do(d)/a()+complex(f=23, g=23)*expression
#             """
#         a = """
#             import sys
#             import atexit
#             atexit.register(do(d)/a()+complex(f=23, g=23)*expression)
#             """
#         self.check(b, a)
#
#     def test_comments(self):
#         b = """
#             import sys # Foo
#             sys.exitfunc = f # Blah
#             """
#         a = """
#             import sys
#             import atexit # Foo
#             atexit.register(f) # Blah
#             """
#         self.check(b, a)
#
#         b = """
#             import apples, sys, crumbs, larry # Pleasant comments
#             sys.exitfunc = func
#             """
#         a = """
#             import apples, sys, crumbs, larry, atexit # Pleasant comments
#             atexit.register(func)
#             """
#         self.check(b, a)
#
#     def test_in_a_function(self):
#         b = """
#             import sys
#             def f():
#                 sys.exitfunc = func
#             """
#         a = """
#             import sys
#             import atexit
#             def f():
#                 atexit.register(func)
#              """
#         self.check(b, a)
#
#     def test_no_sys_import(self):
#         b = """sys.exitfunc = f"""
#         a = """atexit.register(f)"""
#         msg = ("Can't find sys import; Please add an atexit import at the "
#             "top of your file.")
#         self.warns(b, a, msg)
#
#
#     def test_unchanged(self):
#         s = """f(sys.exitfunc)"""
#         self.unchanged(s)