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
import re
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


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, unicode(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)
# 
#     # >> 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 = """raise E, (5, 6) % (a, b) # foo"""
#         a = """raise E((5, 6) % (a, b)) # 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_detection(self):
#         b = """raise E, (5, 6) % (a, b)"""
#         a = """raise E((5, 6) % (a, b))"""
#         self.check(b, a)
# 
#     def test_tuple_exc_1(self):
#         b = """raise (((E1, E2), E3), E4), V"""
#         a = """raise E1(V)"""
#         self.check(b, a)
# 
#     def test_tuple_exc_2(self):
#         b = """raise (E1, (E2, E3), E4), V"""
#         a = """raise E1(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  )"""