1""" Test suite for the fixer modules """
2
3# Python imports
4import os
5import unittest
6from itertools import chain
7from operator import itemgetter
8
9# Local imports
10from lib2to3 import pygram, pytree, refactor, fixer_util
11from lib2to3.tests import support
12
13
14class FixerTestCase(support.TestCase):
15
16    # Other test cases can subclass this class and replace "fixer_pkg" with
17    # their own.
18    def setUp(self, fix_list=None, fixer_pkg="lib2to3", options=None):
19        if fix_list is None:
20            fix_list = [self.fixer]
21        self.refactor = support.get_refactorer(fixer_pkg, fix_list, options)
22        self.fixer_log = []
23        self.filename = u"<string>"
24
25        for fixer in chain(self.refactor.pre_order,
26                           self.refactor.post_order):
27            fixer.log = self.fixer_log
28
29    def _check(self, before, after):
30        before = support.reformat(before)
31        after = support.reformat(after)
32        tree = self.refactor.refactor_string(before, self.filename)
33        self.assertEqual(after, unicode(tree))
34        return tree
35
36    def check(self, before, after, ignore_warnings=False):
37        tree = self._check(before, after)
38        self.assertTrue(tree.was_changed)
39        if not ignore_warnings:
40            self.assertEqual(self.fixer_log, [])
41
42    def warns(self, before, after, message, unchanged=False):
43        tree = self._check(before, after)
44        self.assertTrue(message in "".join(self.fixer_log))
45        if not unchanged:
46            self.assertTrue(tree.was_changed)
47
48    def warns_unchanged(self, before, message):
49        self.warns(before, before, message, unchanged=True)
50
51    def unchanged(self, before, ignore_warnings=False):
52        self._check(before, before)
53        if not ignore_warnings:
54            self.assertEqual(self.fixer_log, [])
55
56    def assert_runs_after(self, *names):
57        fixes = [self.fixer]
58        fixes.extend(names)
59        r = support.get_refactorer("lib2to3", fixes)
60        (pre, post) = r.get_fixers()
61        n = "fix_" + self.fixer
62        if post and post[-1].__class__.__module__.endswith(n):
63            # We're the last fixer to run
64            return
65        if pre and pre[-1].__class__.__module__.endswith(n) and not post:
66            # We're the last in pre and post is empty
67            return
68        self.fail("Fixer run order (%s) is incorrect; %s should be last."\
69               %(", ".join([x.__class__.__module__ for x in (pre+post)]), n))
70
71class Test_ne(FixerTestCase):
72    fixer = "ne"
73
74    def test_basic(self):
75        b = """if x <> y:
76            pass"""
77
78        a = """if x != y:
79            pass"""
80        self.check(b, a)
81
82    def test_no_spaces(self):
83        b = """if x<>y:
84            pass"""
85
86        a = """if x!=y:
87            pass"""
88        self.check(b, a)
89
90    def test_chained(self):
91        b = """if x<>y<>z:
92            pass"""
93
94        a = """if x!=y!=z:
95            pass"""
96        self.check(b, a)
97
98class Test_has_key(FixerTestCase):
99    fixer = "has_key"
100
101    def test_1(self):
102        b = """x = d.has_key("x") or d.has_key("y")"""
103        a = """x = "x" in d or "y" in d"""
104        self.check(b, a)
105
106    def test_2(self):
107        b = """x = a.b.c.d.has_key("x") ** 3"""
108        a = """x = ("x" in a.b.c.d) ** 3"""
109        self.check(b, a)
110
111    def test_3(self):
112        b = """x = a.b.has_key(1 + 2).__repr__()"""
113        a = """x = (1 + 2 in a.b).__repr__()"""
114        self.check(b, a)
115
116    def test_4(self):
117        b = """x = a.b.has_key(1 + 2).__repr__() ** -3 ** 4"""
118        a = """x = (1 + 2 in a.b).__repr__() ** -3 ** 4"""
119        self.check(b, a)
120
121    def test_5(self):
122        b = """x = a.has_key(f or g)"""
123        a = """x = (f or g) in a"""
124        self.check(b, a)
125
126    def test_6(self):
127        b = """x = a + b.has_key(c)"""
128        a = """x = a + (c in b)"""
129        self.check(b, a)
130
131    def test_7(self):
132        b = """x = a.has_key(lambda: 12)"""
133        a = """x = (lambda: 12) in a"""
134        self.check(b, a)
135
136    def test_8(self):
137        b = """x = a.has_key(a for a in b)"""
138        a = """x = (a for a in b) in a"""
139        self.check(b, a)
140
141    def test_9(self):
142        b = """if not a.has_key(b): pass"""
143        a = """if b not in a: pass"""
144        self.check(b, a)
145
146    def test_10(self):
147        b = """if not a.has_key(b).__repr__(): pass"""
148        a = """if not (b in a).__repr__(): pass"""
149        self.check(b, a)
150
151    def test_11(self):
152        b = """if not a.has_key(b) ** 2: pass"""
153        a = """if not (b in a) ** 2: pass"""
154        self.check(b, a)
155
156class Test_apply(FixerTestCase):
157    fixer = "apply"
158
159    def test_1(self):
160        b = """x = apply(f, g + h)"""
161        a = """x = f(*g + h)"""
162        self.check(b, a)
163
164    def test_2(self):
165        b = """y = apply(f, g, h)"""
166        a = """y = f(*g, **h)"""
167        self.check(b, a)
168
169    def test_3(self):
170        b = """z = apply(fs[0], g or h, h or g)"""
171        a = """z = fs[0](*g or h, **h or g)"""
172        self.check(b, a)
173
174    def test_4(self):
175        b = """apply(f, (x, y) + t)"""
176        a = """f(*(x, y) + t)"""
177        self.check(b, a)
178
179    def test_5(self):
180        b = """apply(f, args,)"""
181        a = """f(*args)"""
182        self.check(b, a)
183
184    def test_6(self):
185        b = """apply(f, args, kwds,)"""
186        a = """f(*args, **kwds)"""
187        self.check(b, a)
188
189    # Test that complex functions are parenthesized
190
191    def test_complex_1(self):
192        b = """x = apply(f+g, args)"""
193        a = """x = (f+g)(*args)"""
194        self.check(b, a)
195
196    def test_complex_2(self):
197        b = """x = apply(f*g, args)"""
198        a = """x = (f*g)(*args)"""
199        self.check(b, a)
200
201    def test_complex_3(self):
202        b = """x = apply(f**g, args)"""
203        a = """x = (f**g)(*args)"""
204        self.check(b, a)
205
206    # But dotted names etc. not
207
208    def test_dotted_name(self):
209        b = """x = apply(f.g, args)"""
210        a = """x = f.g(*args)"""
211        self.check(b, a)
212
213    def test_subscript(self):
214        b = """x = apply(f[x], args)"""
215        a = """x = f[x](*args)"""
216        self.check(b, a)
217
218    def test_call(self):
219        b = """x = apply(f(), args)"""
220        a = """x = f()(*args)"""
221        self.check(b, a)
222
223    # Extreme case
224    def test_extreme(self):
225        b = """x = apply(a.b.c.d.e.f, args, kwds)"""
226        a = """x = a.b.c.d.e.f(*args, **kwds)"""
227        self.check(b, a)
228
229    # XXX Comments in weird places still get lost
230    def test_weird_comments(self):
231        b = """apply(   # foo
232          f, # bar
233          args)"""
234        a = """f(*args)"""
235        self.check(b, a)
236
237    # These should *not* be touched
238
239    def test_unchanged_1(self):
240        s = """apply()"""
241        self.unchanged(s)
242
243    def test_unchanged_2(self):
244        s = """apply(f)"""
245        self.unchanged(s)
246
247    def test_unchanged_3(self):
248        s = """apply(f,)"""
249        self.unchanged(s)
250
251    def test_unchanged_4(self):
252        s = """apply(f, args, kwds, extras)"""
253        self.unchanged(s)
254
255    def test_unchanged_5(self):
256        s = """apply(f, *args, **kwds)"""
257        self.unchanged(s)
258
259    def test_unchanged_6(self):
260        s = """apply(f, *args)"""
261        self.unchanged(s)
262
263    def test_unchanged_7(self):
264        s = """apply(func=f, args=args, kwds=kwds)"""
265        self.unchanged(s)
266
267    def test_unchanged_8(self):
268        s = """apply(f, args=args, kwds=kwds)"""
269        self.unchanged(s)
270
271    def test_unchanged_9(self):
272        s = """apply(f, args, kwds=kwds)"""
273        self.unchanged(s)
274
275    def test_space_1(self):
276        a = """apply(  f,  args,   kwds)"""
277        b = """f(*args, **kwds)"""
278        self.check(a, b)
279
280    def test_space_2(self):
281        a = """apply(  f  ,args,kwds   )"""
282        b = """f(*args, **kwds)"""
283        self.check(a, b)
284
285class Test_intern(FixerTestCase):
286    fixer = "intern"
287
288    def test_prefix_preservation(self):
289        b = """x =   intern(  a  )"""
290        a = """import sys\nx =   sys.intern(  a  )"""
291        self.check(b, a)
292
293        b = """y = intern("b" # test
294              )"""
295        a = """import sys\ny = sys.intern("b" # test
296              )"""
297        self.check(b, a)
298
299        b = """z = intern(a+b+c.d,   )"""
300        a = """import sys\nz = sys.intern(a+b+c.d,   )"""
301        self.check(b, a)
302
303    def test(self):
304        b = """x = intern(a)"""
305        a = """import sys\nx = sys.intern(a)"""
306        self.check(b, a)
307
308        b = """z = intern(a+b+c.d,)"""
309        a = """import sys\nz = sys.intern(a+b+c.d,)"""
310        self.check(b, a)
311
312        b = """intern("y%s" % 5).replace("y", "")"""
313        a = """import sys\nsys.intern("y%s" % 5).replace("y", "")"""
314        self.check(b, a)
315
316    # These should not be refactored
317
318    def test_unchanged(self):
319        s = """intern(a=1)"""
320        self.unchanged(s)
321
322        s = """intern(f, g)"""
323        self.unchanged(s)
324
325        s = """intern(*h)"""
326        self.unchanged(s)
327
328        s = """intern(**i)"""
329        self.unchanged(s)
330
331        s = """intern()"""
332        self.unchanged(s)
333
334class Test_reduce(FixerTestCase):
335    fixer = "reduce"
336
337    def test_simple_call(self):
338        b = "reduce(a, b, c)"
339        a = "from functools import reduce\nreduce(a, b, c)"
340        self.check(b, a)
341
342    def test_bug_7253(self):
343        # fix_tuple_params was being bad and orphaning nodes in the tree.
344        b = "def x(arg): reduce(sum, [])"
345        a = "from functools import reduce\ndef x(arg): reduce(sum, [])"
346        self.check(b, a)
347
348    def test_call_with_lambda(self):
349        b = "reduce(lambda x, y: x + y, seq)"
350        a = "from functools import reduce\nreduce(lambda x, y: x + y, seq)"
351        self.check(b, a)
352
353    def test_unchanged(self):
354        s = "reduce(a)"
355        self.unchanged(s)
356
357        s = "reduce(a, b=42)"
358        self.unchanged(s)
359
360        s = "reduce(a, b, c, d)"
361        self.unchanged(s)
362
363        s = "reduce(**c)"
364        self.unchanged(s)
365
366        s = "reduce()"
367        self.unchanged(s)
368
369class Test_print(FixerTestCase):
370    fixer = "print"
371
372    def test_prefix_preservation(self):
373        b = """print 1,   1+1,   1+1+1"""
374        a = """print(1,   1+1,   1+1+1)"""
375        self.check(b, a)
376
377    def test_idempotency(self):
378        s = """print()"""
379        self.unchanged(s)
380
381        s = """print('')"""
382        self.unchanged(s)
383
384    def test_idempotency_print_as_function(self):
385        self.refactor.driver.grammar = pygram.python_grammar_no_print_statement
386        s = """print(1, 1+1, 1+1+1)"""
387        self.unchanged(s)
388
389        s = """print()"""
390        self.unchanged(s)
391
392        s = """print('')"""
393        self.unchanged(s)
394
395    def test_1(self):
396        b = """print 1, 1+1, 1+1+1"""
397        a = """print(1, 1+1, 1+1+1)"""
398        self.check(b, a)
399
400    def test_2(self):
401        b = """print 1, 2"""
402        a = """print(1, 2)"""
403        self.check(b, a)
404
405    def test_3(self):
406        b = """print"""
407        a = """print()"""
408        self.check(b, a)
409
410    def test_4(self):
411        # from bug 3000
412        b = """print whatever; print"""
413        a = """print(whatever); print()"""
414        self.check(b, a)
415
416    def test_5(self):
417        b = """print; print whatever;"""
418        a = """print(); print(whatever);"""
419        self.check(b, a)
420
421    def test_tuple(self):
422        b = """print (a, b, c)"""
423        a = """print((a, b, c))"""
424        self.check(b, a)
425
426    # trailing commas
427
428    def test_trailing_comma_1(self):
429        b = """print 1, 2, 3,"""
430        a = """print(1, 2, 3, end=' ')"""
431        self.check(b, a)
432
433    def test_trailing_comma_2(self):
434        b = """print 1, 2,"""
435        a = """print(1, 2, end=' ')"""
436        self.check(b, a)
437
438    def test_trailing_comma_3(self):
439        b = """print 1,"""
440        a = """print(1, end=' ')"""
441        self.check(b, a)
442
443    # >> stuff
444
445    def test_vargs_without_trailing_comma(self):
446        b = """print >>sys.stderr, 1, 2, 3"""
447        a = """print(1, 2, 3, file=sys.stderr)"""
448        self.check(b, a)
449
450    def test_with_trailing_comma(self):
451        b = """print >>sys.stderr, 1, 2,"""
452        a = """print(1, 2, end=' ', file=sys.stderr)"""
453        self.check(b, a)
454
455    def test_no_trailing_comma(self):
456        b = """print >>sys.stderr, 1+1"""
457        a = """print(1+1, file=sys.stderr)"""
458        self.check(b, a)
459
460    def test_spaces_before_file(self):
461        b = """print >>  sys.stderr"""
462        a = """print(file=sys.stderr)"""
463        self.check(b, a)
464
465    def test_with_future_print_function(self):
466        s = "from __future__ import print_function\n" \
467            "print('Hai!', end=' ')"
468        self.unchanged(s)
469
470        b = "print 'Hello, world!'"
471        a = "print('Hello, world!')"
472        self.check(b, a)
473
474
475class Test_exec(FixerTestCase):
476    fixer = "exec"
477
478    def test_prefix_preservation(self):
479        b = """  exec code in ns1,   ns2"""
480        a = """  exec(code, ns1,   ns2)"""
481        self.check(b, a)
482
483    def test_basic(self):
484        b = """exec code"""
485        a = """exec(code)"""
486        self.check(b, a)
487
488    def test_with_globals(self):
489        b = """exec code in ns"""
490        a = """exec(code, ns)"""
491        self.check(b, a)
492
493    def test_with_globals_locals(self):
494        b = """exec code in ns1, ns2"""
495        a = """exec(code, ns1, ns2)"""
496        self.check(b, a)
497
498    def test_complex_1(self):
499        b = """exec (a.b()) in ns"""
500        a = """exec((a.b()), ns)"""
501        self.check(b, a)
502
503    def test_complex_2(self):
504        b = """exec a.b() + c in ns"""
505        a = """exec(a.b() + c, ns)"""
506        self.check(b, a)
507
508    # These should not be touched
509
510    def test_unchanged_1(self):
511        s = """exec(code)"""
512        self.unchanged(s)
513
514    def test_unchanged_2(self):
515        s = """exec (code)"""
516        self.unchanged(s)
517
518    def test_unchanged_3(self):
519        s = """exec(code, ns)"""
520        self.unchanged(s)
521
522    def test_unchanged_4(self):
523        s = """exec(code, ns1, ns2)"""
524        self.unchanged(s)
525
526class Test_repr(FixerTestCase):
527    fixer = "repr"
528
529    def test_prefix_preservation(self):
530        b = """x =   `1 + 2`"""
531        a = """x =   repr(1 + 2)"""
532        self.check(b, a)
533
534    def test_simple_1(self):
535        b = """x = `1 + 2`"""
536        a = """x = repr(1 + 2)"""
537        self.check(b, a)
538
539    def test_simple_2(self):
540        b = """y = `x`"""
541        a = """y = repr(x)"""
542        self.check(b, a)
543
544    def test_complex(self):
545        b = """z = `y`.__repr__()"""
546        a = """z = repr(y).__repr__()"""
547        self.check(b, a)
548
549    def test_tuple(self):
550        b = """x = `1, 2, 3`"""
551        a = """x = repr((1, 2, 3))"""
552        self.check(b, a)
553
554    def test_nested(self):
555        b = """x = `1 + `2``"""
556        a = """x = repr(1 + repr(2))"""
557        self.check(b, a)
558
559    def test_nested_tuples(self):
560        b = """x = `1, 2 + `3, 4``"""
561        a = """x = repr((1, 2 + repr((3, 4))))"""
562        self.check(b, a)
563
564class Test_except(FixerTestCase):
565    fixer = "except"
566
567    def test_prefix_preservation(self):
568        b = """
569            try:
570                pass
571            except (RuntimeError, ImportError),    e:
572                pass"""
573        a = """
574            try:
575                pass
576            except (RuntimeError, ImportError) as    e:
577                pass"""
578        self.check(b, a)
579
580    def test_simple(self):
581        b = """
582            try:
583                pass
584            except Foo, e:
585                pass"""
586        a = """
587            try:
588                pass
589            except Foo as e:
590                pass"""
591        self.check(b, a)
592
593    def test_simple_no_space_before_target(self):
594        b = """
595            try:
596                pass
597            except Foo,e:
598                pass"""
599        a = """
600            try:
601                pass
602            except Foo as e:
603                pass"""
604        self.check(b, a)
605
606    def test_tuple_unpack(self):
607        b = """
608            def foo():
609                try:
610                    pass
611                except Exception, (f, e):
612                    pass
613                except ImportError, e:
614                    pass"""
615
616        a = """
617            def foo():
618                try:
619                    pass
620                except Exception as xxx_todo_changeme:
621                    (f, e) = xxx_todo_changeme.args
622                    pass
623                except ImportError as e:
624                    pass"""
625        self.check(b, a)
626
627    def test_multi_class(self):
628        b = """
629            try:
630                pass
631            except (RuntimeError, ImportError), e:
632                pass"""
633
634        a = """
635            try:
636                pass
637            except (RuntimeError, ImportError) as e:
638                pass"""
639        self.check(b, a)
640
641    def test_list_unpack(self):
642        b = """
643            try:
644                pass
645            except Exception, [a, b]:
646                pass"""
647
648        a = """
649            try:
650                pass
651            except Exception as xxx_todo_changeme:
652                [a, b] = xxx_todo_changeme.args
653                pass"""
654        self.check(b, a)
655
656    def test_weird_target_1(self):
657        b = """
658            try:
659                pass
660            except Exception, d[5]:
661                pass"""
662
663        a = """
664            try:
665                pass
666            except Exception as xxx_todo_changeme:
667                d[5] = xxx_todo_changeme
668                pass"""
669        self.check(b, a)
670
671    def test_weird_target_2(self):
672        b = """
673            try:
674                pass
675            except Exception, a.foo:
676                pass"""
677
678        a = """
679            try:
680                pass
681            except Exception as xxx_todo_changeme:
682                a.foo = xxx_todo_changeme
683                pass"""
684        self.check(b, a)
685
686    def test_weird_target_3(self):
687        b = """
688            try:
689                pass
690            except Exception, a().foo:
691                pass"""
692
693        a = """
694            try:
695                pass
696            except Exception as xxx_todo_changeme:
697                a().foo = xxx_todo_changeme
698                pass"""
699        self.check(b, a)
700
701    def test_bare_except(self):
702        b = """
703            try:
704                pass
705            except Exception, a:
706                pass
707            except:
708                pass"""
709
710        a = """
711            try:
712                pass
713            except Exception as a:
714                pass
715            except:
716                pass"""
717        self.check(b, a)
718
719    def test_bare_except_and_else_finally(self):
720        b = """
721            try:
722                pass
723            except Exception, a:
724                pass
725            except:
726                pass
727            else:
728                pass
729            finally:
730                pass"""
731
732        a = """
733            try:
734                pass
735            except Exception as a:
736                pass
737            except:
738                pass
739            else:
740                pass
741            finally:
742                pass"""
743        self.check(b, a)
744
745    def test_multi_fixed_excepts_before_bare_except(self):
746        b = """
747            try:
748                pass
749            except TypeError, b:
750                pass
751            except Exception, a:
752                pass
753            except:
754                pass"""
755
756        a = """
757            try:
758                pass
759            except TypeError as b:
760                pass
761            except Exception as a:
762                pass
763            except:
764                pass"""
765        self.check(b, a)
766
767    def test_one_line_suites(self):
768        b = """
769            try: raise TypeError
770            except TypeError, e:
771                pass
772            """
773        a = """
774            try: raise TypeError
775            except TypeError as e:
776                pass
777            """
778        self.check(b, a)
779        b = """
780            try:
781                raise TypeError
782            except TypeError, e: pass
783            """
784        a = """
785            try:
786                raise TypeError
787            except TypeError as e: pass
788            """
789        self.check(b, a)
790        b = """
791            try: raise TypeError
792            except TypeError, e: pass
793            """
794        a = """
795            try: raise TypeError
796            except TypeError as e: pass
797            """
798        self.check(b, a)
799        b = """
800            try: raise TypeError
801            except TypeError, e: pass
802            else: function()
803            finally: done()
804            """
805        a = """
806            try: raise TypeError
807            except TypeError as e: pass
808            else: function()
809            finally: done()
810            """
811        self.check(b, a)
812
813    # These should not be touched:
814
815    def test_unchanged_1(self):
816        s = """
817            try:
818                pass
819            except:
820                pass"""
821        self.unchanged(s)
822
823    def test_unchanged_2(self):
824        s = """
825            try:
826                pass
827            except Exception:
828                pass"""
829        self.unchanged(s)
830
831    def test_unchanged_3(self):
832        s = """
833            try:
834                pass
835            except (Exception, SystemExit):
836                pass"""
837        self.unchanged(s)
838
839class Test_raise(FixerTestCase):
840    fixer = "raise"
841
842    def test_basic(self):
843        b = """raise Exception, 5"""
844        a = """raise Exception(5)"""
845        self.check(b, a)
846
847    def test_prefix_preservation(self):
848        b = """raise Exception,5"""
849        a = """raise Exception(5)"""
850        self.check(b, a)
851
852        b = """raise   Exception,    5"""
853        a = """raise   Exception(5)"""
854        self.check(b, a)
855
856    def test_with_comments(self):
857        b = """raise Exception, 5 # foo"""
858        a = """raise Exception(5) # foo"""
859        self.check(b, a)
860
861        b = """raise E, (5, 6) % (a, b) # foo"""
862        a = """raise E((5, 6) % (a, b)) # foo"""
863        self.check(b, a)
864
865        b = """def foo():
866                    raise Exception, 5, 6 # foo"""
867        a = """def foo():
868                    raise Exception(5).with_traceback(6) # foo"""
869        self.check(b, a)
870
871    def test_None_value(self):
872        b = """raise Exception(5), None, tb"""
873        a = """raise Exception(5).with_traceback(tb)"""
874        self.check(b, a)
875
876    def test_tuple_value(self):
877        b = """raise Exception, (5, 6, 7)"""
878        a = """raise Exception(5, 6, 7)"""
879        self.check(b, a)
880
881    def test_tuple_detection(self):
882        b = """raise E, (5, 6) % (a, b)"""
883        a = """raise E((5, 6) % (a, b))"""
884        self.check(b, a)
885
886    def test_tuple_exc_1(self):
887        b = """raise (((E1, E2), E3), E4), V"""
888        a = """raise E1(V)"""
889        self.check(b, a)
890
891    def test_tuple_exc_2(self):
892        b = """raise (E1, (E2, E3), E4), V"""
893        a = """raise E1(V)"""
894        self.check(b, a)
895
896    # These should produce a warning
897
898    def test_string_exc(self):
899        s = """raise 'foo'"""
900        self.warns_unchanged(s, "Python 3 does not support string exceptions")
901
902    def test_string_exc_val(self):
903        s = """raise "foo", 5"""
904        self.warns_unchanged(s, "Python 3 does not support string exceptions")
905
906    def test_string_exc_val_tb(self):
907        s = """raise "foo", 5, 6"""
908        self.warns_unchanged(s, "Python 3 does not support string exceptions")
909
910    # These should result in traceback-assignment
911
912    def test_tb_1(self):
913        b = """def foo():
914                    raise Exception, 5, 6"""
915        a = """def foo():
916                    raise Exception(5).with_traceback(6)"""
917        self.check(b, a)
918
919    def test_tb_2(self):
920        b = """def foo():
921                    a = 5
922                    raise Exception, 5, 6
923                    b = 6"""
924        a = """def foo():
925                    a = 5
926                    raise Exception(5).with_traceback(6)
927                    b = 6"""
928        self.check(b, a)
929
930    def test_tb_3(self):
931        b = """def foo():
932                    raise Exception,5,6"""
933        a = """def foo():
934                    raise Exception(5).with_traceback(6)"""
935        self.check(b, a)
936
937    def test_tb_4(self):
938        b = """def foo():
939                    a = 5
940                    raise Exception,5,6
941                    b = 6"""
942        a = """def foo():
943                    a = 5
944                    raise Exception(5).with_traceback(6)
945                    b = 6"""
946        self.check(b, a)
947
948    def test_tb_5(self):
949        b = """def foo():
950                    raise Exception, (5, 6, 7), 6"""
951        a = """def foo():
952                    raise Exception(5, 6, 7).with_traceback(6)"""
953        self.check(b, a)
954
955    def test_tb_6(self):
956        b = """def foo():
957                    a = 5
958                    raise Exception, (5, 6, 7), 6
959                    b = 6"""
960        a = """def foo():
961                    a = 5
962                    raise Exception(5, 6, 7).with_traceback(6)
963                    b = 6"""
964        self.check(b, a)
965
966class Test_throw(FixerTestCase):
967    fixer = "throw"
968
969    def test_1(self):
970        b = """g.throw(Exception, 5)"""
971        a = """g.throw(Exception(5))"""
972        self.check(b, a)
973
974    def test_2(self):
975        b = """g.throw(Exception,5)"""
976        a = """g.throw(Exception(5))"""
977        self.check(b, a)
978
979    def test_3(self):
980        b = """g.throw(Exception, (5, 6, 7))"""
981        a = """g.throw(Exception(5, 6, 7))"""
982        self.check(b, a)
983
984    def test_4(self):
985        b = """5 + g.throw(Exception, 5)"""
986        a = """5 + g.throw(Exception(5))"""
987        self.check(b, a)
988
989    # These should produce warnings
990
991    def test_warn_1(self):
992        s = """g.throw("foo")"""
993        self.warns_unchanged(s, "Python 3 does not support string exceptions")
994
995    def test_warn_2(self):
996        s = """g.throw("foo", 5)"""
997        self.warns_unchanged(s, "Python 3 does not support string exceptions")
998
999    def test_warn_3(self):
1000        s = """g.throw("foo", 5, 6)"""
1001        self.warns_unchanged(s, "Python 3 does not support string exceptions")
1002
1003    # These should not be touched
1004
1005    def test_untouched_1(self):
1006        s = """g.throw(Exception)"""
1007        self.unchanged(s)
1008
1009    def test_untouched_2(self):
1010        s = """g.throw(Exception(5, 6))"""
1011        self.unchanged(s)
1012
1013    def test_untouched_3(self):
1014        s = """5 + g.throw(Exception(5, 6))"""
1015        self.unchanged(s)
1016
1017    # These should result in traceback-assignment
1018
1019    def test_tb_1(self):
1020        b = """def foo():
1021                    g.throw(Exception, 5, 6)"""
1022        a = """def foo():
1023                    g.throw(Exception(5).with_traceback(6))"""
1024        self.check(b, a)
1025
1026    def test_tb_2(self):
1027        b = """def foo():
1028                    a = 5
1029                    g.throw(Exception, 5, 6)
1030                    b = 6"""
1031        a = """def foo():
1032                    a = 5
1033                    g.throw(Exception(5).with_traceback(6))
1034                    b = 6"""
1035        self.check(b, a)
1036
1037    def test_tb_3(self):
1038        b = """def foo():
1039                    g.throw(Exception,5,6)"""
1040        a = """def foo():
1041                    g.throw(Exception(5).with_traceback(6))"""
1042        self.check(b, a)
1043
1044    def test_tb_4(self):
1045        b = """def foo():
1046                    a = 5
1047                    g.throw(Exception,5,6)
1048                    b = 6"""
1049        a = """def foo():
1050                    a = 5
1051                    g.throw(Exception(5).with_traceback(6))
1052                    b = 6"""
1053        self.check(b, a)
1054
1055    def test_tb_5(self):
1056        b = """def foo():
1057                    g.throw(Exception, (5, 6, 7), 6)"""
1058        a = """def foo():
1059                    g.throw(Exception(5, 6, 7).with_traceback(6))"""
1060        self.check(b, a)
1061
1062    def test_tb_6(self):
1063        b = """def foo():
1064                    a = 5
1065                    g.throw(Exception, (5, 6, 7), 6)
1066                    b = 6"""
1067        a = """def foo():
1068                    a = 5
1069                    g.throw(Exception(5, 6, 7).with_traceback(6))
1070                    b = 6"""
1071        self.check(b, a)
1072
1073    def test_tb_7(self):
1074        b = """def foo():
1075                    a + g.throw(Exception, 5, 6)"""
1076        a = """def foo():
1077                    a + g.throw(Exception(5).with_traceback(6))"""
1078        self.check(b, a)
1079
1080    def test_tb_8(self):
1081        b = """def foo():
1082                    a = 5
1083                    a + g.throw(Exception, 5, 6)
1084                    b = 6"""
1085        a = """def foo():
1086                    a = 5
1087                    a + g.throw(Exception(5).with_traceback(6))
1088                    b = 6"""
1089        self.check(b, a)
1090
1091class Test_long(FixerTestCase):
1092    fixer = "long"
1093
1094    def test_1(self):
1095        b = """x = long(x)"""
1096        a = """x = int(x)"""
1097        self.check(b, a)
1098
1099    def test_2(self):
1100        b = """y = isinstance(x, long)"""
1101        a = """y = isinstance(x, int)"""
1102        self.check(b, a)
1103
1104    def test_3(self):
1105        b = """z = type(x) in (int, long)"""
1106        a = """z = type(x) in (int, int)"""
1107        self.check(b, a)
1108
1109    def test_unchanged(self):
1110        s = """long = True"""
1111        self.unchanged(s)
1112
1113        s = """s.long = True"""
1114        self.unchanged(s)
1115
1116        s = """def long(): pass"""
1117        self.unchanged(s)
1118
1119        s = """class long(): pass"""
1120        self.unchanged(s)
1121
1122        s = """def f(long): pass"""
1123        self.unchanged(s)
1124
1125        s = """def f(g, long): pass"""
1126        self.unchanged(s)
1127
1128        s = """def f(x, long=True): pass"""
1129        self.unchanged(s)
1130
1131    def test_prefix_preservation(self):
1132        b = """x =   long(  x  )"""
1133        a = """x =   int(  x  )"""
1134        self.check(b, a)
1135
1136
1137class Test_execfile(FixerTestCase):
1138    fixer = "execfile"
1139
1140    def test_conversion(self):
1141        b = """execfile("fn")"""
1142        a = """exec(compile(open("fn").read(), "fn", 'exec'))"""
1143        self.check(b, a)
1144
1145        b = """execfile("fn", glob)"""
1146        a = """exec(compile(open("fn").read(), "fn", 'exec'), glob)"""
1147        self.check(b, a)
1148
1149        b = """execfile("fn", glob, loc)"""
1150        a = """exec(compile(open("fn").read(), "fn", 'exec'), glob, loc)"""
1151        self.check(b, a)
1152
1153        b = """execfile("fn", globals=glob)"""
1154        a = """exec(compile(open("fn").read(), "fn", 'exec'), globals=glob)"""
1155        self.check(b, a)
1156
1157        b = """execfile("fn", locals=loc)"""
1158        a = """exec(compile(open("fn").read(), "fn", 'exec'), locals=loc)"""
1159        self.check(b, a)
1160
1161        b = """execfile("fn", globals=glob, locals=loc)"""
1162        a = """exec(compile(open("fn").read(), "fn", 'exec'), globals=glob, locals=loc)"""
1163        self.check(b, a)
1164
1165    def test_spacing(self):
1166        b = """execfile( "fn" )"""
1167        a = """exec(compile(open( "fn" ).read(), "fn", 'exec'))"""
1168        self.check(b, a)
1169
1170        b = """execfile("fn",  globals = glob)"""
1171        a = """exec(compile(open("fn").read(), "fn", 'exec'),  globals = glob)"""
1172        self.check(b, a)
1173
1174
1175class Test_isinstance(FixerTestCase):
1176    fixer = "isinstance"
1177
1178    def test_remove_multiple_items(self):
1179        b = """isinstance(x, (int, int, int))"""
1180        a = """isinstance(x, int)"""
1181        self.check(b, a)
1182
1183        b = """isinstance(x, (int, float, int, int, float))"""
1184        a = """isinstance(x, (int, float))"""
1185        self.check(b, a)
1186
1187        b = """isinstance(x, (int, float, int, int, float, str))"""
1188        a = """isinstance(x, (int, float, str))"""
1189        self.check(b, a)
1190
1191        b = """isinstance(foo() + bar(), (x(), y(), x(), int, int))"""
1192        a = """isinstance(foo() + bar(), (x(), y(), x(), int))"""
1193        self.check(b, a)
1194
1195    def test_prefix_preservation(self):
1196        b = """if    isinstance(  foo(), (  bar, bar, baz )) : pass"""
1197        a = """if    isinstance(  foo(), (  bar, baz )) : pass"""
1198        self.check(b, a)
1199
1200    def test_unchanged(self):
1201        self.unchanged("isinstance(x, (str, int))")
1202
1203class Test_dict(FixerTestCase):
1204    fixer = "dict"
1205
1206    def test_prefix_preservation(self):
1207        b = "if   d. keys  (  )  : pass"
1208        a = "if   list(d. keys  (  ))  : pass"
1209        self.check(b, a)
1210
1211        b = "if   d. items  (  )  : pass"
1212        a = "if   list(d. items  (  ))  : pass"
1213        self.check(b, a)
1214
1215        b = "if   d. iterkeys  ( )  : pass"
1216        a = "if   iter(d. keys  ( ))  : pass"
1217        self.check(b, a)
1218
1219        b = "[i for i in    d.  iterkeys(  )  ]"
1220        a = "[i for i in    d.  keys(  )  ]"
1221        self.check(b, a)
1222
1223        b = "if   d. viewkeys  ( )  : pass"
1224        a = "if   d. keys  ( )  : pass"
1225        self.check(b, a)
1226
1227        b = "[i for i in    d.  viewkeys(  )  ]"
1228        a = "[i for i in    d.  keys(  )  ]"
1229        self.check(b, a)
1230
1231    def test_trailing_comment(self):
1232        b = "d.keys() # foo"
1233        a = "list(d.keys()) # foo"
1234        self.check(b, a)
1235
1236        b = "d.items()  # foo"
1237        a = "list(d.items())  # foo"
1238        self.check(b, a)
1239
1240        b = "d.iterkeys()  # foo"
1241        a = "iter(d.keys())  # foo"
1242        self.check(b, a)
1243
1244        b = """[i for i in d.iterkeys() # foo
1245               ]"""
1246        a = """[i for i in d.keys() # foo
1247               ]"""
1248        self.check(b, a)
1249
1250        b = """[i for i in d.iterkeys() # foo
1251               ]"""
1252        a = """[i for i in d.keys() # foo
1253               ]"""
1254        self.check(b, a)
1255
1256        b = "d.viewitems()  # foo"
1257        a = "d.items()  # foo"
1258        self.check(b, a)
1259
1260    def test_unchanged(self):
1261        for wrapper in fixer_util.consuming_calls:
1262            s = "s = %s(d.keys())" % wrapper
1263            self.unchanged(s)
1264
1265            s = "s = %s(d.values())" % wrapper
1266            self.unchanged(s)
1267
1268            s = "s = %s(d.items())" % wrapper
1269            self.unchanged(s)
1270
1271    def test_01(self):
1272        b = "d.keys()"
1273        a = "list(d.keys())"
1274        self.check(b, a)
1275
1276        b = "a[0].foo().keys()"
1277        a = "list(a[0].foo().keys())"
1278        self.check(b, a)
1279
1280    def test_02(self):
1281        b = "d.items()"
1282        a = "list(d.items())"
1283        self.check(b, a)
1284
1285    def test_03(self):
1286        b = "d.values()"
1287        a = "list(d.values())"
1288        self.check(b, a)
1289
1290    def test_04(self):
1291        b = "d.iterkeys()"
1292        a = "iter(d.keys())"
1293        self.check(b, a)
1294
1295    def test_05(self):
1296        b = "d.iteritems()"
1297        a = "iter(d.items())"
1298        self.check(b, a)
1299
1300    def test_06(self):
1301        b = "d.itervalues()"
1302        a = "iter(d.values())"
1303        self.check(b, a)
1304
1305    def test_07(self):
1306        s = "list(d.keys())"
1307        self.unchanged(s)
1308
1309    def test_08(self):
1310        s = "sorted(d.keys())"
1311        self.unchanged(s)
1312
1313    def test_09(self):
1314        b = "iter(d.keys())"
1315        a = "iter(list(d.keys()))"
1316        self.check(b, a)
1317
1318    def test_10(self):
1319        b = "foo(d.keys())"
1320        a = "foo(list(d.keys()))"
1321        self.check(b, a)
1322
1323    def test_11(self):
1324        b = "for i in d.keys(): print i"
1325        a = "for i in list(d.keys()): print i"
1326        self.check(b, a)
1327
1328    def test_12(self):
1329        b = "for i in d.iterkeys(): print i"
1330        a = "for i in d.keys(): print i"
1331        self.check(b, a)
1332
1333    def test_13(self):
1334        b = "[i for i in d.keys()]"
1335        a = "[i for i in list(d.keys())]"
1336        self.check(b, a)
1337
1338    def test_14(self):
1339        b = "[i for i in d.iterkeys()]"
1340        a = "[i for i in d.keys()]"
1341        self.check(b, a)
1342
1343    def test_15(self):
1344        b = "(i for i in d.keys())"
1345        a = "(i for i in list(d.keys()))"
1346        self.check(b, a)
1347
1348    def test_16(self):
1349        b = "(i for i in d.iterkeys())"
1350        a = "(i for i in d.keys())"
1351        self.check(b, a)
1352
1353    def test_17(self):
1354        b = "iter(d.iterkeys())"
1355        a = "iter(d.keys())"
1356        self.check(b, a)
1357
1358    def test_18(self):
1359        b = "list(d.iterkeys())"
1360        a = "list(d.keys())"
1361        self.check(b, a)
1362
1363    def test_19(self):
1364        b = "sorted(d.iterkeys())"
1365        a = "sorted(d.keys())"
1366        self.check(b, a)
1367
1368    def test_20(self):
1369        b = "foo(d.iterkeys())"
1370        a = "foo(iter(d.keys()))"
1371        self.check(b, a)
1372
1373    def test_21(self):
1374        b = "print h.iterkeys().next()"
1375        a = "print iter(h.keys()).next()"
1376        self.check(b, a)
1377
1378    def test_22(self):
1379        b = "print h.keys()[0]"
1380        a = "print list(h.keys())[0]"
1381        self.check(b, a)
1382
1383    def test_23(self):
1384        b = "print list(h.iterkeys().next())"
1385        a = "print list(iter(h.keys()).next())"
1386        self.check(b, a)
1387
1388    def test_24(self):
1389        b = "for x in h.keys()[0]: print x"
1390        a = "for x in list(h.keys())[0]: print x"
1391        self.check(b, a)
1392
1393    def test_25(self):
1394        b = "d.viewkeys()"
1395        a = "d.keys()"
1396        self.check(b, a)
1397
1398    def test_26(self):
1399        b = "d.viewitems()"
1400        a = "d.items()"
1401        self.check(b, a)
1402
1403    def test_27(self):
1404        b = "d.viewvalues()"
1405        a = "d.values()"
1406        self.check(b, a)
1407
1408    def test_14(self):
1409        b = "[i for i in d.viewkeys()]"
1410        a = "[i for i in d.keys()]"
1411        self.check(b, a)
1412
1413    def test_15(self):
1414        b = "(i for i in d.viewkeys())"
1415        a = "(i for i in d.keys())"
1416        self.check(b, a)
1417
1418    def test_17(self):
1419        b = "iter(d.viewkeys())"
1420        a = "iter(d.keys())"
1421        self.check(b, a)
1422
1423    def test_18(self):
1424        b = "list(d.viewkeys())"
1425        a = "list(d.keys())"
1426        self.check(b, a)
1427
1428    def test_19(self):
1429        b = "sorted(d.viewkeys())"
1430        a = "sorted(d.keys())"
1431        self.check(b, a)
1432
1433class Test_xrange(FixerTestCase):
1434    fixer = "xrange"
1435
1436    def test_prefix_preservation(self):
1437        b = """x =    xrange(  10  )"""
1438        a = """x =    range(  10  )"""
1439        self.check(b, a)
1440
1441        b = """x = xrange(  1  ,  10   )"""
1442        a = """x = range(  1  ,  10   )"""
1443        self.check(b, a)
1444
1445        b = """x = xrange(  0  ,  10 ,  2 )"""
1446        a = """x = range(  0  ,  10 ,  2 )"""
1447        self.check(b, a)
1448
1449    def test_single_arg(self):
1450        b = """x = xrange(10)"""
1451        a = """x = range(10)"""
1452        self.check(b, a)
1453
1454    def test_two_args(self):
1455        b = """x = xrange(1, 10)"""
1456        a = """x = range(1, 10)"""
1457        self.check(b, a)
1458
1459    def test_three_args(self):
1460        b = """x = xrange(0, 10, 2)"""
1461        a = """x = range(0, 10, 2)"""
1462        self.check(b, a)
1463
1464    def test_wrap_in_list(self):
1465        b = """x = range(10, 3, 9)"""
1466        a = """x = list(range(10, 3, 9))"""
1467        self.check(b, a)
1468
1469        b = """x = foo(range(10, 3, 9))"""
1470        a = """x = foo(list(range(10, 3, 9)))"""
1471        self.check(b, a)
1472
1473        b = """x = range(10, 3, 9) + [4]"""
1474        a = """x = list(range(10, 3, 9)) + [4]"""
1475        self.check(b, a)
1476
1477        b = """x = range(10)[::-1]"""
1478        a = """x = list(range(10))[::-1]"""
1479        self.check(b, a)
1480
1481        b = """x = range(10)  [3]"""
1482        a = """x = list(range(10))  [3]"""
1483        self.check(b, a)
1484
1485    def test_xrange_in_for(self):
1486        b = """for i in xrange(10):\n    j=i"""
1487        a = """for i in range(10):\n    j=i"""
1488        self.check(b, a)
1489
1490        b = """[i for i in xrange(10)]"""
1491        a = """[i for i in range(10)]"""
1492        self.check(b, a)
1493
1494    def test_range_in_for(self):
1495        self.unchanged("for i in range(10): pass")
1496        self.unchanged("[i for i in range(10)]")
1497
1498    def test_in_contains_test(self):
1499        self.unchanged("x in range(10, 3, 9)")
1500
1501    def test_in_consuming_context(self):
1502        for call in fixer_util.consuming_calls:
1503            self.unchanged("a = %s(range(10))" % call)
1504
1505class Test_xrange_with_reduce(FixerTestCase):
1506
1507    def setUp(self):
1508        super(Test_xrange_with_reduce, self).setUp(["xrange", "reduce"])
1509
1510    def test_double_transform(self):
1511        b = """reduce(x, xrange(5))"""
1512        a = """from functools import reduce
1513reduce(x, range(5))"""
1514        self.check(b, a)
1515
1516class Test_raw_input(FixerTestCase):
1517    fixer = "raw_input"
1518
1519    def test_prefix_preservation(self):
1520        b = """x =    raw_input(   )"""
1521        a = """x =    input(   )"""
1522        self.check(b, a)
1523
1524        b = """x = raw_input(   ''   )"""
1525        a = """x = input(   ''   )"""
1526        self.check(b, a)
1527
1528    def test_1(self):
1529        b = """x = raw_input()"""
1530        a = """x = input()"""
1531        self.check(b, a)
1532
1533    def test_2(self):
1534        b = """x = raw_input('')"""
1535        a = """x = input('')"""
1536        self.check(b, a)
1537
1538    def test_3(self):
1539        b = """x = raw_input('prompt')"""
1540        a = """x = input('prompt')"""
1541        self.check(b, a)
1542
1543    def test_4(self):
1544        b = """x = raw_input(foo(a) + 6)"""
1545        a = """x = input(foo(a) + 6)"""
1546        self.check(b, a)
1547
1548    def test_5(self):
1549        b = """x = raw_input(invite).split()"""
1550        a = """x = input(invite).split()"""
1551        self.check(b, a)
1552
1553    def test_6(self):
1554        b = """x = raw_input(invite) . split ()"""
1555        a = """x = input(invite) . split ()"""
1556        self.check(b, a)
1557
1558    def test_8(self):
1559        b = "x = int(raw_input())"
1560        a = "x = int(input())"
1561        self.check(b, a)
1562
1563class Test_funcattrs(FixerTestCase):
1564    fixer = "funcattrs"
1565
1566    attrs = ["closure", "doc", "name", "defaults", "code", "globals", "dict"]
1567
1568    def test(self):
1569        for attr in self.attrs:
1570            b = "a.func_%s" % attr
1571            a = "a.__%s__" % attr
1572            self.check(b, a)
1573
1574            b = "self.foo.func_%s.foo_bar" % attr
1575            a = "self.foo.__%s__.foo_bar" % attr
1576            self.check(b, a)
1577
1578    def test_unchanged(self):
1579        for attr in self.attrs:
1580            s = "foo(func_%s + 5)" % attr
1581            self.unchanged(s)
1582
1583            s = "f(foo.__%s__)" % attr
1584            self.unchanged(s)
1585
1586            s = "f(foo.__%s__.foo)" % attr
1587            self.unchanged(s)
1588
1589class Test_xreadlines(FixerTestCase):
1590    fixer = "xreadlines"
1591
1592    def test_call(self):
1593        b = "for x in f.xreadlines(): pass"
1594        a = "for x in f: pass"
1595        self.check(b, a)
1596
1597        b = "for x in foo().xreadlines(): pass"
1598        a = "for x in foo(): pass"
1599        self.check(b, a)
1600
1601        b = "for x in (5 + foo()).xreadlines(): pass"
1602        a = "for x in (5 + foo()): pass"
1603        self.check(b, a)
1604
1605    def test_attr_ref(self):
1606        b = "foo(f.xreadlines + 5)"
1607        a = "foo(f.__iter__ + 5)"
1608        self.check(b, a)
1609
1610        b = "foo(f().xreadlines + 5)"
1611        a = "foo(f().__iter__ + 5)"
1612        self.check(b, a)
1613
1614        b = "foo((5 + f()).xreadlines + 5)"
1615        a = "foo((5 + f()).__iter__ + 5)"
1616        self.check(b, a)
1617
1618    def test_unchanged(self):
1619        s = "for x in f.xreadlines(5): pass"
1620        self.unchanged(s)
1621
1622        s = "for x in f.xreadlines(k=5): pass"
1623        self.unchanged(s)
1624
1625        s = "for x in f.xreadlines(*k, **v): pass"
1626        self.unchanged(s)
1627
1628        s = "foo(xreadlines)"
1629        self.unchanged(s)
1630
1631
1632class ImportsFixerTests:
1633
1634    def test_import_module(self):
1635        for old, new in self.modules.items():
1636            b = "import %s" % old
1637            a = "import %s" % new
1638            self.check(b, a)
1639
1640            b = "import foo, %s, bar" % old
1641            a = "import foo, %s, bar" % new
1642            self.check(b, a)
1643
1644    def test_import_from(self):
1645        for old, new in self.modules.items():
1646            b = "from %s import foo" % old
1647            a = "from %s import foo" % new
1648            self.check(b, a)
1649
1650            b = "from %s import foo, bar" % old
1651            a = "from %s import foo, bar" % new
1652            self.check(b, a)
1653
1654            b = "from %s import (yes, no)" % old
1655            a = "from %s import (yes, no)" % new
1656            self.check(b, a)
1657
1658    def test_import_module_as(self):
1659        for old, new in self.modules.items():
1660            b = "import %s as foo_bar" % old
1661            a = "import %s as foo_bar" % new
1662            self.check(b, a)
1663
1664            b = "import %s as foo_bar" % old
1665            a = "import %s as foo_bar" % new
1666            self.check(b, a)
1667
1668    def test_import_from_as(self):
1669        for old, new in self.modules.items():
1670            b = "from %s import foo as bar" % old
1671            a = "from %s import foo as bar" % new
1672            self.check(b, a)
1673
1674    def test_star(self):
1675        for old, new in self.modules.items():
1676            b = "from %s import *" % old
1677            a = "from %s import *" % new
1678            self.check(b, a)
1679
1680    def test_import_module_usage(self):
1681        for old, new in self.modules.items():
1682            b = """
1683                import %s
1684                foo(%s.bar)
1685                """ % (old, old)
1686            a = """
1687                import %s
1688                foo(%s.bar)
1689                """ % (new, new)
1690            self.check(b, a)
1691
1692            b = """
1693                from %s import x
1694                %s = 23
1695                """ % (old, old)
1696            a = """
1697                from %s import x
1698                %s = 23
1699                """ % (new, old)
1700            self.check(b, a)
1701
1702            s = """
1703                def f():
1704                    %s.method()
1705                """ % (old,)
1706            self.unchanged(s)
1707
1708            # test nested usage
1709            b = """
1710                import %s
1711                %s.bar(%s.foo)
1712                """ % (old, old, old)
1713            a = """
1714                import %s
1715                %s.bar(%s.foo)
1716                """ % (new, new, new)
1717            self.check(b, a)
1718
1719            b = """
1720                import %s
1721                x.%s
1722                """ % (old, old)
1723            a = """
1724                import %s
1725                x.%s
1726                """ % (new, old)
1727            self.check(b, a)
1728
1729
1730class Test_imports(FixerTestCase, ImportsFixerTests):
1731    fixer = "imports"
1732    from ..fixes.fix_imports import MAPPING as modules
1733
1734    def test_multiple_imports(self):
1735        b = """import urlparse, cStringIO"""
1736        a = """import urllib.parse, io"""
1737        self.check(b, a)
1738
1739    def test_multiple_imports_as(self):
1740        b = """
1741            import copy_reg as bar, HTMLParser as foo, urlparse
1742            s = urlparse.spam(bar.foo())
1743            """
1744        a = """
1745            import copyreg as bar, html.parser as foo, urllib.parse
1746            s = urllib.parse.spam(bar.foo())
1747            """
1748        self.check(b, a)
1749
1750
1751class Test_imports2(FixerTestCase, ImportsFixerTests):
1752    fixer = "imports2"
1753    from ..fixes.fix_imports2 import MAPPING as modules
1754
1755
1756class Test_imports_fixer_order(FixerTestCase, ImportsFixerTests):
1757
1758    def setUp(self):
1759        super(Test_imports_fixer_order, self).setUp(['imports', 'imports2'])
1760        from ..fixes.fix_imports2 import MAPPING as mapping2
1761        self.modules = mapping2.copy()
1762        from ..fixes.fix_imports import MAPPING as mapping1
1763        for key in ('dbhash', 'dumbdbm', 'dbm', 'gdbm'):
1764            self.modules[key] = mapping1[key]
1765
1766    def test_after_local_imports_refactoring(self):
1767        for fix in ("imports", "imports2"):
1768            self.fixer = fix
1769            self.assert_runs_after("import")
1770
1771
1772class Test_urllib(FixerTestCase):
1773    fixer = "urllib"
1774    from ..fixes.fix_urllib import MAPPING as modules
1775
1776    def test_import_module(self):
1777        for old, changes in self.modules.items():
1778            b = "import %s" % old
1779            a = "import %s" % ", ".join(map(itemgetter(0), changes))
1780            self.check(b, a)
1781
1782    def test_import_from(self):
1783        for old, changes in self.modules.items():
1784            all_members = []
1785            for new, members in changes:
1786                for member in members:
1787                    all_members.append(member)
1788                    b = "from %s import %s" % (old, member)
1789                    a = "from %s import %s" % (new, member)
1790                    self.check(b, a)
1791
1792                    s = "from foo import %s" % member
1793                    self.unchanged(s)
1794
1795                b = "from %s import %s" % (old, ", ".join(members))
1796                a = "from %s import %s" % (new, ", ".join(members))
1797                self.check(b, a)
1798
1799                s = "from foo import %s" % ", ".join(members)
1800                self.unchanged(s)
1801
1802            # test the breaking of a module into multiple replacements
1803            b = "from %s import %s" % (old, ", ".join(all_members))
1804            a = "\n".join(["from %s import %s" % (new, ", ".join(members))
1805                            for (new, members) in changes])
1806            self.check(b, a)
1807
1808    def test_import_module_as(self):
1809        for old in self.modules:
1810            s = "import %s as foo" % old
1811            self.warns_unchanged(s, "This module is now multiple modules")
1812
1813    def test_import_from_as(self):
1814        for old, changes in self.modules.items():
1815            for new, members in changes:
1816                for member in members:
1817                    b = "from %s import %s as foo_bar" % (old, member)
1818                    a = "from %s import %s as foo_bar" % (new, member)
1819                    self.check(b, a)
1820                    b = "from %s import %s as blah, %s" % (old, member, member)
1821                    a = "from %s import %s as blah, %s" % (new, member, member)
1822                    self.check(b, a)
1823
1824    def test_star(self):
1825        for old in self.modules:
1826            s = "from %s import *" % old
1827            self.warns_unchanged(s, "Cannot handle star imports")
1828
1829    def test_indented(self):
1830        b = """
1831def foo():
1832    from urllib import urlencode, urlopen
1833"""
1834        a = """
1835def foo():
1836    from urllib.parse import urlencode
1837    from urllib.request import urlopen
1838"""
1839        self.check(b, a)
1840
1841        b = """
1842def foo():
1843    other()
1844    from urllib import urlencode, urlopen
1845"""
1846        a = """
1847def foo():
1848    other()
1849    from urllib.parse import urlencode
1850    from urllib.request import urlopen
1851"""
1852        self.check(b, a)
1853
1854
1855
1856    def test_import_module_usage(self):
1857        for old, changes in self.modules.items():
1858            for new, members in changes:
1859                for member in members:
1860                    new_import = ", ".join([n for (n, mems)
1861                                            in self.modules[old]])
1862                    b = """
1863                        import %s
1864                        foo(%s.%s)
1865                        """ % (old, old, member)
1866                    a = """
1867                        import %s
1868                        foo(%s.%s)
1869                        """ % (new_import, new, member)
1870                    self.check(b, a)
1871                    b = """
1872                        import %s
1873                        %s.%s(%s.%s)
1874                        """ % (old, old, member, old, member)
1875                    a = """
1876                        import %s
1877                        %s.%s(%s.%s)
1878                        """ % (new_import, new, member, new, member)
1879                    self.check(b, a)
1880
1881
1882class Test_input(FixerTestCase):
1883    fixer = "input"
1884
1885    def test_prefix_preservation(self):
1886        b = """x =   input(   )"""
1887        a = """x =   eval(input(   ))"""
1888        self.check(b, a)
1889
1890        b = """x = input(   ''   )"""
1891        a = """x = eval(input(   ''   ))"""
1892        self.check(b, a)
1893
1894    def test_trailing_comment(self):
1895        b = """x = input()  #  foo"""
1896        a = """x = eval(input())  #  foo"""
1897        self.check(b, a)
1898
1899    def test_idempotency(self):
1900        s = """x = eval(input())"""
1901        self.unchanged(s)
1902
1903        s = """x = eval(input(''))"""
1904        self.unchanged(s)
1905
1906        s = """x = eval(input(foo(5) + 9))"""
1907        self.unchanged(s)
1908
1909    def test_1(self):
1910        b = """x = input()"""
1911        a = """x = eval(input())"""
1912        self.check(b, a)
1913
1914    def test_2(self):
1915        b = """x = input('')"""
1916        a = """x = eval(input(''))"""
1917        self.check(b, a)
1918
1919    def test_3(self):
1920        b = """x = input('prompt')"""
1921        a = """x = eval(input('prompt'))"""
1922        self.check(b, a)
1923
1924    def test_4(self):
1925        b = """x = input(foo(5) + 9)"""
1926        a = """x = eval(input(foo(5) + 9))"""
1927        self.check(b, a)
1928
1929class Test_tuple_params(FixerTestCase):
1930    fixer = "tuple_params"
1931
1932    def test_unchanged_1(self):
1933        s = """def foo(): pass"""
1934        self.unchanged(s)
1935
1936    def test_unchanged_2(self):
1937        s = """def foo(a, b, c): pass"""
1938        self.unchanged(s)
1939
1940    def test_unchanged_3(self):
1941        s = """def foo(a=3, b=4, c=5): pass"""
1942        self.unchanged(s)
1943
1944    def test_1(self):
1945        b = """
1946            def foo(((a, b), c)):
1947                x = 5"""
1948
1949        a = """
1950            def foo(xxx_todo_changeme):
1951                ((a, b), c) = xxx_todo_changeme
1952                x = 5"""
1953        self.check(b, a)
1954
1955    def test_2(self):
1956        b = """
1957            def foo(((a, b), c), d):
1958                x = 5"""
1959
1960        a = """
1961            def foo(xxx_todo_changeme, d):
1962                ((a, b), c) = xxx_todo_changeme
1963                x = 5"""
1964        self.check(b, a)
1965
1966    def test_3(self):
1967        b = """
1968            def foo(((a, b), c), d) -> e:
1969                x = 5"""
1970
1971        a = """
1972            def foo(xxx_todo_changeme, d) -> e:
1973                ((a, b), c) = xxx_todo_changeme
1974                x = 5"""
1975        self.check(b, a)
1976
1977    def test_semicolon(self):
1978        b = """
1979            def foo(((a, b), c)): x = 5; y = 7"""
1980
1981        a = """
1982            def foo(xxx_todo_changeme): ((a, b), c) = xxx_todo_changeme; x = 5; y = 7"""
1983        self.check(b, a)
1984
1985    def test_keywords(self):
1986        b = """
1987            def foo(((a, b), c), d, e=5) -> z:
1988                x = 5"""
1989
1990        a = """
1991            def foo(xxx_todo_changeme, d, e=5) -> z:
1992                ((a, b), c) = xxx_todo_changeme
1993                x = 5"""
1994        self.check(b, a)
1995
1996    def test_varargs(self):
1997        b = """
1998            def foo(((a, b), c), d, *vargs, **kwargs) -> z:
1999                x = 5"""
2000
2001        a = """
2002            def foo(xxx_todo_changeme, d, *vargs, **kwargs) -> z:
2003                ((a, b), c) = xxx_todo_changeme
2004                x = 5"""
2005        self.check(b, a)
2006
2007    def test_multi_1(self):
2008        b = """
2009            def foo(((a, b), c), (d, e, f)) -> z:
2010                x = 5"""
2011
2012        a = """
2013            def foo(xxx_todo_changeme, xxx_todo_changeme1) -> z:
2014                ((a, b), c) = xxx_todo_changeme
2015                (d, e, f) = xxx_todo_changeme1
2016                x = 5"""
2017        self.check(b, a)
2018
2019    def test_multi_2(self):
2020        b = """
2021            def foo(x, ((a, b), c), d, (e, f, g), y) -> z:
2022                x = 5"""
2023
2024        a = """
2025            def foo(x, xxx_todo_changeme, d, xxx_todo_changeme1, y) -> z:
2026                ((a, b), c) = xxx_todo_changeme
2027                (e, f, g) = xxx_todo_changeme1
2028                x = 5"""
2029        self.check(b, a)
2030
2031    def test_docstring(self):
2032        b = """
2033            def foo(((a, b), c), (d, e, f)) -> z:
2034                "foo foo foo foo"
2035                x = 5"""
2036
2037        a = """
2038            def foo(xxx_todo_changeme, xxx_todo_changeme1) -> z:
2039                "foo foo foo foo"
2040                ((a, b), c) = xxx_todo_changeme
2041                (d, e, f) = xxx_todo_changeme1
2042                x = 5"""
2043        self.check(b, a)
2044
2045    def test_lambda_no_change(self):
2046        s = """lambda x: x + 5"""
2047        self.unchanged(s)
2048
2049    def test_lambda_parens_single_arg(self):
2050        b = """lambda (x): x + 5"""
2051        a = """lambda x: x + 5"""
2052        self.check(b, a)
2053
2054        b = """lambda(x): x + 5"""
2055        a = """lambda x: x + 5"""
2056        self.check(b, a)
2057
2058        b = """lambda ((((x)))): x + 5"""
2059        a = """lambda x: x + 5"""
2060        self.check(b, a)
2061
2062        b = """lambda((((x)))): x + 5"""
2063        a = """lambda x: x + 5"""
2064        self.check(b, a)
2065
2066    def test_lambda_simple(self):
2067        b = """lambda (x, y): x + f(y)"""
2068        a = """lambda x_y: x_y[0] + f(x_y[1])"""
2069        self.check(b, a)
2070
2071        b = """lambda(x, y): x + f(y)"""
2072        a = """lambda x_y: x_y[0] + f(x_y[1])"""
2073        self.check(b, a)
2074
2075        b = """lambda (((x, y))): x + f(y)"""
2076        a = """lambda x_y: x_y[0] + f(x_y[1])"""
2077        self.check(b, a)
2078
2079        b = """lambda(((x, y))): x + f(y)"""
2080        a = """lambda x_y: x_y[0] + f(x_y[1])"""
2081        self.check(b, a)
2082
2083    def test_lambda_one_tuple(self):
2084        b = """lambda (x,): x + f(x)"""
2085        a = """lambda x1: x1[0] + f(x1[0])"""
2086        self.check(b, a)
2087
2088        b = """lambda (((x,))): x + f(x)"""
2089        a = """lambda x1: x1[0] + f(x1[0])"""
2090        self.check(b, a)
2091
2092    def test_lambda_simple_multi_use(self):
2093        b = """lambda (x, y): x + x + f(x) + x"""
2094        a = """lambda x_y: x_y[0] + x_y[0] + f(x_y[0]) + x_y[0]"""
2095        self.check(b, a)
2096
2097    def test_lambda_simple_reverse(self):
2098        b = """lambda (x, y): y + x"""
2099        a = """lambda x_y: x_y[1] + x_y[0]"""
2100        self.check(b, a)
2101
2102    def test_lambda_nested(self):
2103        b = """lambda (x, (y, z)): x + y + z"""
2104        a = """lambda x_y_z: x_y_z[0] + x_y_z[1][0] + x_y_z[1][1]"""
2105        self.check(b, a)
2106
2107        b = """lambda (((x, (y, z)))): x + y + z"""
2108        a = """lambda x_y_z: x_y_z[0] + x_y_z[1][0] + x_y_z[1][1]"""
2109        self.check(b, a)
2110
2111    def test_lambda_nested_multi_use(self):
2112        b = """lambda (x, (y, z)): x + y + f(y)"""
2113        a = """lambda x_y_z: x_y_z[0] + x_y_z[1][0] + f(x_y_z[1][0])"""
2114        self.check(b, a)
2115
2116class Test_methodattrs(FixerTestCase):
2117    fixer = "methodattrs"
2118
2119    attrs = ["func", "self", "class"]
2120
2121    def test(self):
2122        for attr in self.attrs:
2123            b = "a.im_%s" % attr
2124            if attr == "class":
2125                a = "a.__self__.__class__"
2126            else:
2127                a = "a.__%s__" % attr
2128            self.check(b, a)
2129
2130            b = "self.foo.im_%s.foo_bar" % attr
2131            if attr == "class":
2132                a = "self.foo.__self__.__class__.foo_bar"
2133            else:
2134                a = "self.foo.__%s__.foo_bar" % attr
2135            self.check(b, a)
2136
2137    def test_unchanged(self):
2138        for attr in self.attrs:
2139            s = "foo(im_%s + 5)" % attr
2140            self.unchanged(s)
2141
2142            s = "f(foo.__%s__)" % attr
2143            self.unchanged(s)
2144
2145            s = "f(foo.__%s__.foo)" % attr
2146            self.unchanged(s)
2147
2148class Test_next(FixerTestCase):
2149    fixer = "next"
2150
2151    def test_1(self):
2152        b = """it.next()"""
2153        a = """next(it)"""
2154        self.check(b, a)
2155
2156    def test_2(self):
2157        b = """a.b.c.d.next()"""
2158        a = """next(a.b.c.d)"""
2159        self.check(b, a)
2160
2161    def test_3(self):
2162        b = """(a + b).next()"""
2163        a = """next((a + b))"""
2164        self.check(b, a)
2165
2166    def test_4(self):
2167        b = """a().next()"""
2168        a = """next(a())"""
2169        self.check(b, a)
2170
2171    def test_5(self):
2172        b = """a().next() + b"""
2173        a = """next(a()) + b"""
2174        self.check(b, a)
2175
2176    def test_6(self):
2177        b = """c(      a().next() + b)"""
2178        a = """c(      next(a()) + b)"""
2179        self.check(b, a)
2180
2181    def test_prefix_preservation_1(self):
2182        b = """
2183            for a in b:
2184                foo(a)
2185                a.next()
2186            """
2187        a = """
2188            for a in b:
2189                foo(a)
2190                next(a)
2191            """
2192        self.check(b, a)
2193
2194    def test_prefix_preservation_2(self):
2195        b = """
2196            for a in b:
2197                foo(a) # abc
2198                # def
2199                a.next()
2200            """
2201        a = """
2202            for a in b:
2203                foo(a) # abc
2204                # def
2205                next(a)
2206            """
2207        self.check(b, a)
2208
2209    def test_prefix_preservation_3(self):
2210        b = """
2211            next = 5
2212            for a in b:
2213                foo(a)
2214                a.next()
2215            """
2216        a = """
2217            next = 5
2218            for a in b:
2219                foo(a)
2220                a.__next__()
2221            """
2222        self.check(b, a, ignore_warnings=True)
2223
2224    def test_prefix_preservation_4(self):
2225        b = """
2226            next = 5
2227            for a in b:
2228                foo(a) # abc
2229                # def
2230                a.next()
2231            """
2232        a = """
2233            next = 5
2234            for a in b:
2235                foo(a) # abc
2236                # def
2237                a.__next__()
2238            """
2239        self.check(b, a, ignore_warnings=True)
2240
2241    def test_prefix_preservation_5(self):
2242        b = """
2243            next = 5
2244            for a in b:
2245                foo(foo(a), # abc
2246                    a.next())
2247            """
2248        a = """
2249            next = 5
2250            for a in b:
2251                foo(foo(a), # abc
2252                    a.__next__())
2253            """
2254        self.check(b, a, ignore_warnings=True)
2255
2256    def test_prefix_preservation_6(self):
2257        b = """
2258            for a in b:
2259                foo(foo(a), # abc
2260                    a.next())
2261            """
2262        a = """
2263            for a in b:
2264                foo(foo(a), # abc
2265                    next(a))
2266            """
2267        self.check(b, a)
2268
2269    def test_method_1(self):
2270        b = """
2271            class A:
2272                def next(self):
2273                    pass
2274            """
2275        a = """
2276            class A:
2277                def __next__(self):
2278                    pass
2279            """
2280        self.check(b, a)
2281
2282    def test_method_2(self):
2283        b = """
2284            class A(object):
2285                def next(self):
2286                    pass
2287            """
2288        a = """
2289            class A(object):
2290                def __next__(self):
2291                    pass
2292            """
2293        self.check(b, a)
2294
2295    def test_method_3(self):
2296        b = """
2297            class A:
2298                def next(x):
2299                    pass
2300            """
2301        a = """
2302            class A:
2303                def __next__(x):
2304                    pass
2305            """
2306        self.check(b, a)
2307
2308    def test_method_4(self):
2309        b = """
2310            class A:
2311                def __init__(self, foo):
2312                    self.foo = foo
2313
2314                def next(self):
2315                    pass
2316
2317                def __iter__(self):
2318                    return self
2319            """
2320        a = """
2321            class A:
2322                def __init__(self, foo):
2323                    self.foo = foo
2324
2325                def __next__(self):
2326                    pass
2327
2328                def __iter__(self):
2329                    return self
2330            """
2331        self.check(b, a)
2332
2333    def test_method_unchanged(self):
2334        s = """
2335            class A:
2336                def next(self, a, b):
2337                    pass
2338            """
2339        self.unchanged(s)
2340
2341    def test_shadowing_assign_simple(self):
2342        s = """
2343            next = foo
2344
2345            class A:
2346                def next(self, a, b):
2347                    pass
2348            """
2349        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2350
2351    def test_shadowing_assign_tuple_1(self):
2352        s = """
2353            (next, a) = foo
2354
2355            class A:
2356                def next(self, a, b):
2357                    pass
2358            """
2359        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2360
2361    def test_shadowing_assign_tuple_2(self):
2362        s = """
2363            (a, (b, (next, c)), a) = foo
2364
2365            class A:
2366                def next(self, a, b):
2367                    pass
2368            """
2369        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2370
2371    def test_shadowing_assign_list_1(self):
2372        s = """
2373            [next, a] = foo
2374
2375            class A:
2376                def next(self, a, b):
2377                    pass
2378            """
2379        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2380
2381    def test_shadowing_assign_list_2(self):
2382        s = """
2383            [a, [b, [next, c]], a] = foo
2384
2385            class A:
2386                def next(self, a, b):
2387                    pass
2388            """
2389        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2390
2391    def test_builtin_assign(self):
2392        s = """
2393            def foo():
2394                __builtin__.next = foo
2395
2396            class A:
2397                def next(self, a, b):
2398                    pass
2399            """
2400        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2401
2402    def test_builtin_assign_in_tuple(self):
2403        s = """
2404            def foo():
2405                (a, __builtin__.next) = foo
2406
2407            class A:
2408                def next(self, a, b):
2409                    pass
2410            """
2411        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2412
2413    def test_builtin_assign_in_list(self):
2414        s = """
2415            def foo():
2416                [a, __builtin__.next] = foo
2417
2418            class A:
2419                def next(self, a, b):
2420                    pass
2421            """
2422        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2423
2424    def test_assign_to_next(self):
2425        s = """
2426            def foo():
2427                A.next = foo
2428
2429            class A:
2430                def next(self, a, b):
2431                    pass
2432            """
2433        self.unchanged(s)
2434
2435    def test_assign_to_next_in_tuple(self):
2436        s = """
2437            def foo():
2438                (a, A.next) = foo
2439
2440            class A:
2441                def next(self, a, b):
2442                    pass
2443            """
2444        self.unchanged(s)
2445
2446    def test_assign_to_next_in_list(self):
2447        s = """
2448            def foo():
2449                [a, A.next] = foo
2450
2451            class A:
2452                def next(self, a, b):
2453                    pass
2454            """
2455        self.unchanged(s)
2456
2457    def test_shadowing_import_1(self):
2458        s = """
2459            import foo.bar as next
2460
2461            class A:
2462                def next(self, a, b):
2463                    pass
2464            """
2465        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2466
2467    def test_shadowing_import_2(self):
2468        s = """
2469            import bar, bar.foo as next
2470
2471            class A:
2472                def next(self, a, b):
2473                    pass
2474            """
2475        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2476
2477    def test_shadowing_import_3(self):
2478        s = """
2479            import bar, bar.foo as next, baz
2480
2481            class A:
2482                def next(self, a, b):
2483                    pass
2484            """
2485        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2486
2487    def test_shadowing_import_from_1(self):
2488        s = """
2489            from x import next
2490
2491            class A:
2492                def next(self, a, b):
2493                    pass
2494            """
2495        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2496
2497    def test_shadowing_import_from_2(self):
2498        s = """
2499            from x.a import next
2500
2501            class A:
2502                def next(self, a, b):
2503                    pass
2504            """
2505        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2506
2507    def test_shadowing_import_from_3(self):
2508        s = """
2509            from x import a, next, b
2510
2511            class A:
2512                def next(self, a, b):
2513                    pass
2514            """
2515        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2516
2517    def test_shadowing_import_from_4(self):
2518        s = """
2519            from x.a import a, next, b
2520
2521            class A:
2522                def next(self, a, b):
2523                    pass
2524            """
2525        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2526
2527    def test_shadowing_funcdef_1(self):
2528        s = """
2529            def next(a):
2530                pass
2531
2532            class A:
2533                def next(self, a, b):
2534                    pass
2535            """
2536        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2537
2538    def test_shadowing_funcdef_2(self):
2539        b = """
2540            def next(a):
2541                pass
2542
2543            class A:
2544                def next(self):
2545                    pass
2546
2547            it.next()
2548            """
2549        a = """
2550            def next(a):
2551                pass
2552
2553            class A:
2554                def __next__(self):
2555                    pass
2556
2557            it.__next__()
2558            """
2559        self.warns(b, a, "Calls to builtin next() possibly shadowed")
2560
2561    def test_shadowing_global_1(self):
2562        s = """
2563            def f():
2564                global next
2565                next = 5
2566            """
2567        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2568
2569    def test_shadowing_global_2(self):
2570        s = """
2571            def f():
2572                global a, next, b
2573                next = 5
2574            """
2575        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2576
2577    def test_shadowing_for_simple(self):
2578        s = """
2579            for next in it():
2580                pass
2581
2582            b = 5
2583            c = 6
2584            """
2585        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2586
2587    def test_shadowing_for_tuple_1(self):
2588        s = """
2589            for next, b in it():
2590                pass
2591
2592            b = 5
2593            c = 6
2594            """
2595        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2596
2597    def test_shadowing_for_tuple_2(self):
2598        s = """
2599            for a, (next, c), b in it():
2600                pass
2601
2602            b = 5
2603            c = 6
2604            """
2605        self.warns_unchanged(s, "Calls to builtin next() possibly shadowed")
2606
2607    def test_noncall_access_1(self):
2608        b = """gnext = g.next"""
2609        a = """gnext = g.__next__"""
2610        self.check(b, a)
2611
2612    def test_noncall_access_2(self):
2613        b = """f(g.next + 5)"""
2614        a = """f(g.__next__ + 5)"""
2615        self.check(b, a)
2616
2617    def test_noncall_access_3(self):
2618        b = """f(g().next + 5)"""
2619        a = """f(g().__next__ + 5)"""
2620        self.check(b, a)
2621
2622class Test_nonzero(FixerTestCase):
2623    fixer = "nonzero"
2624
2625    def test_1(self):
2626        b = """
2627            class A:
2628                def __nonzero__(self):
2629                    pass
2630            """
2631        a = """
2632            class A:
2633                def __bool__(self):
2634                    pass
2635            """
2636        self.check(b, a)
2637
2638    def test_2(self):
2639        b = """
2640            class A(object):
2641                def __nonzero__(self):
2642                    pass
2643            """
2644        a = """
2645            class A(object):
2646                def __bool__(self):
2647                    pass
2648            """
2649        self.check(b, a)
2650
2651    def test_unchanged_1(self):
2652        s = """
2653            class A(object):
2654                def __bool__(self):
2655                    pass
2656            """
2657        self.unchanged(s)
2658
2659    def test_unchanged_2(self):
2660        s = """
2661            class A(object):
2662                def __nonzero__(self, a):
2663                    pass
2664            """
2665        self.unchanged(s)
2666
2667    def test_unchanged_func(self):
2668        s = """
2669            def __nonzero__(self):
2670                pass
2671            """
2672        self.unchanged(s)
2673
2674class Test_numliterals(FixerTestCase):
2675    fixer = "numliterals"
2676
2677    def test_octal_1(self):
2678        b = """0755"""
2679        a = """0o755"""
2680        self.check(b, a)
2681
2682    def test_long_int_1(self):
2683        b = """a = 12L"""
2684        a = """a = 12"""
2685        self.check(b, a)
2686
2687    def test_long_int_2(self):
2688        b = """a = 12l"""
2689        a = """a = 12"""
2690        self.check(b, a)
2691
2692    def test_long_hex(self):
2693        b = """b = 0x12l"""
2694        a = """b = 0x12"""
2695        self.check(b, a)
2696
2697    def test_comments_and_spacing(self):
2698        b = """b =   0x12L"""
2699        a = """b =   0x12"""
2700        self.check(b, a)
2701
2702        b = """b = 0755 # spam"""
2703        a = """b = 0o755 # spam"""
2704        self.check(b, a)
2705
2706    def test_unchanged_int(self):
2707        s = """5"""
2708        self.unchanged(s)
2709
2710    def test_unchanged_float(self):
2711        s = """5.0"""
2712        self.unchanged(s)
2713
2714    def test_unchanged_octal(self):
2715        s = """0o755"""
2716        self.unchanged(s)
2717
2718    def test_unchanged_hex(self):
2719        s = """0xABC"""
2720        self.unchanged(s)
2721
2722    def test_unchanged_exp(self):
2723        s = """5.0e10"""
2724        self.unchanged(s)
2725
2726    def test_unchanged_complex_int(self):
2727        s = """5 + 4j"""
2728        self.unchanged(s)
2729
2730    def test_unchanged_complex_float(self):
2731        s = """5.4 + 4.9j"""
2732        self.unchanged(s)
2733
2734    def test_unchanged_complex_bare(self):
2735        s = """4j"""
2736        self.unchanged(s)
2737        s = """4.4j"""
2738        self.unchanged(s)
2739
2740class Test_renames(FixerTestCase):
2741    fixer = "renames"
2742
2743    modules = {"sys":  ("maxint", "maxsize"),
2744              }
2745
2746    def test_import_from(self):
2747        for mod, (old, new) in self.modules.items():
2748            b = "from %s import %s" % (mod, old)
2749            a = "from %s import %s" % (mod, new)
2750            self.check(b, a)
2751
2752            s = "from foo import %s" % old
2753            self.unchanged(s)
2754
2755    def test_import_from_as(self):
2756        for mod, (old, new) in self.modules.items():
2757            b = "from %s import %s as foo_bar" % (mod, old)
2758            a = "from %s import %s as foo_bar" % (mod, new)
2759            self.check(b, a)
2760
2761    def test_import_module_usage(self):
2762        for mod, (old, new) in self.modules.items():
2763            b = """
2764                import %s
2765                foo(%s, %s.%s)
2766                """ % (mod, mod, mod, old)
2767            a = """
2768                import %s
2769                foo(%s, %s.%s)
2770                """ % (mod, mod, mod, new)
2771            self.check(b, a)
2772
2773    def XXX_test_from_import_usage(self):
2774        # not implemented yet
2775        for mod, (old, new) in self.modules.items():
2776            b = """
2777                from %s import %s
2778                foo(%s, %s)
2779                """ % (mod, old, mod, old)
2780            a = """
2781                from %s import %s
2782                foo(%s, %s)
2783                """ % (mod, new, mod, new)
2784            self.check(b, a)
2785
2786class Test_unicode(FixerTestCase):
2787    fixer = "unicode"
2788
2789    def test_whitespace(self):
2790        b = """unicode( x)"""
2791        a = """str( x)"""
2792        self.check(b, a)
2793
2794        b = """ unicode(x )"""
2795        a = """ str(x )"""
2796        self.check(b, a)
2797
2798        b = """ u'h'"""
2799        a = """ 'h'"""
2800        self.check(b, a)
2801
2802    def test_unicode_call(self):
2803        b = """unicode(x, y, z)"""
2804        a = """str(x, y, z)"""
2805        self.check(b, a)
2806
2807    def test_unichr(self):
2808        b = """unichr(u'h')"""
2809        a = """chr('h')"""
2810        self.check(b, a)
2811
2812    def test_unicode_literal_1(self):
2813        b = '''u"x"'''
2814        a = '''"x"'''
2815        self.check(b, a)
2816
2817    def test_unicode_literal_2(self):
2818        b = """ur'x'"""
2819        a = """r'x'"""
2820        self.check(b, a)
2821
2822    def test_unicode_literal_3(self):
2823        b = """UR'''x''' """
2824        a = """R'''x''' """
2825        self.check(b, a)
2826
2827class Test_callable(FixerTestCase):
2828    fixer = "callable"
2829
2830    def test_prefix_preservation(self):
2831        b = """callable(    x)"""
2832        a = """import collections\nisinstance(    x, collections.Callable)"""
2833        self.check(b, a)
2834
2835        b = """if     callable(x): pass"""
2836        a = """import collections
2837if     isinstance(x, collections.Callable): pass"""
2838        self.check(b, a)
2839
2840    def test_callable_call(self):
2841        b = """callable(x)"""
2842        a = """import collections\nisinstance(x, collections.Callable)"""
2843        self.check(b, a)
2844
2845    def test_global_import(self):
2846        b = """
2847def spam(foo):
2848    callable(foo)"""[1:]
2849        a = """
2850import collections
2851def spam(foo):
2852    isinstance(foo, collections.Callable)"""[1:]
2853        self.check(b, a)
2854
2855        b = """
2856import collections
2857def spam(foo):
2858    callable(foo)"""[1:]
2859        # same output if it was already imported
2860        self.check(b, a)
2861
2862        b = """
2863from collections import *
2864def spam(foo):
2865    callable(foo)"""[1:]
2866        a = """
2867from collections import *
2868import collections
2869def spam(foo):
2870    isinstance(foo, collections.Callable)"""[1:]
2871        self.check(b, a)
2872
2873        b = """
2874do_stuff()
2875do_some_other_stuff()
2876assert callable(do_stuff)"""[1:]
2877        a = """
2878import collections
2879do_stuff()
2880do_some_other_stuff()
2881assert isinstance(do_stuff, collections.Callable)"""[1:]
2882        self.check(b, a)
2883
2884        b = """
2885if isinstance(do_stuff, Callable):
2886    assert callable(do_stuff)
2887    do_stuff(do_stuff)
2888    if not callable(do_stuff):
2889        exit(1)
2890    else:
2891        assert callable(do_stuff)
2892else:
2893    assert not callable(do_stuff)"""[1:]
2894        a = """
2895import collections
2896if isinstance(do_stuff, Callable):
2897    assert isinstance(do_stuff, collections.Callable)
2898    do_stuff(do_stuff)
2899    if not isinstance(do_stuff, collections.Callable):
2900        exit(1)
2901    else:
2902        assert isinstance(do_stuff, collections.Callable)
2903else:
2904    assert not isinstance(do_stuff, collections.Callable)"""[1:]
2905        self.check(b, a)
2906
2907    def test_callable_should_not_change(self):
2908        a = """callable(*x)"""
2909        self.unchanged(a)
2910
2911        a = """callable(x, y)"""
2912        self.unchanged(a)
2913
2914        a = """callable(x, kw=y)"""
2915        self.unchanged(a)
2916
2917        a = """callable()"""
2918        self.unchanged(a)
2919
2920class Test_filter(FixerTestCase):
2921    fixer = "filter"
2922
2923    def test_prefix_preservation(self):
2924        b = """x =   filter(    foo,     'abc'   )"""
2925        a = """x =   list(filter(    foo,     'abc'   ))"""
2926        self.check(b, a)
2927
2928        b = """x =   filter(  None , 'abc'  )"""
2929        a = """x =   [_f for _f in 'abc' if _f]"""
2930        self.check(b, a)
2931
2932    def test_filter_basic(self):
2933        b = """x = filter(None, 'abc')"""
2934        a = """x = [_f for _f in 'abc' if _f]"""
2935        self.check(b, a)
2936
2937        b = """x = len(filter(f, 'abc'))"""
2938        a = """x = len(list(filter(f, 'abc')))"""
2939        self.check(b, a)
2940
2941        b = """x = filter(lambda x: x%2 == 0, range(10))"""
2942        a = """x = [x for x in range(10) if x%2 == 0]"""
2943        self.check(b, a)
2944
2945        # Note the parens around x
2946        b = """x = filter(lambda (x): x%2 == 0, range(10))"""
2947        a = """x = [x for x in range(10) if x%2 == 0]"""
2948        self.check(b, a)
2949
2950        # XXX This (rare) case is not supported
2951##         b = """x = filter(f, 'abc')[0]"""
2952##         a = """x = list(filter(f, 'abc'))[0]"""
2953##         self.check(b, a)
2954
2955    def test_filter_nochange(self):
2956        a = """b.join(filter(f, 'abc'))"""
2957        self.unchanged(a)
2958        a = """(a + foo(5)).join(filter(f, 'abc'))"""
2959        self.unchanged(a)
2960        a = """iter(filter(f, 'abc'))"""
2961        self.unchanged(a)
2962        a = """list(filter(f, 'abc'))"""
2963        self.unchanged(a)
2964        a = """list(filter(f, 'abc'))[0]"""
2965        self.unchanged(a)
2966        a = """set(filter(f, 'abc'))"""
2967        self.unchanged(a)
2968        a = """set(filter(f, 'abc')).pop()"""
2969        self.unchanged(a)
2970        a = """tuple(filter(f, 'abc'))"""
2971        self.unchanged(a)
2972        a = """any(filter(f, 'abc'))"""
2973        self.unchanged(a)
2974        a = """all(filter(f, 'abc'))"""
2975        self.unchanged(a)
2976        a = """sum(filter(f, 'abc'))"""
2977        self.unchanged(a)
2978        a = """sorted(filter(f, 'abc'))"""
2979        self.unchanged(a)
2980        a = """sorted(filter(f, 'abc'), key=blah)"""
2981        self.unchanged(a)
2982        a = """sorted(filter(f, 'abc'), key=blah)[0]"""
2983        self.unchanged(a)
2984        a = """enumerate(filter(f, 'abc'))"""
2985        self.unchanged(a)
2986        a = """enumerate(filter(f, 'abc'), start=1)"""
2987        self.unchanged(a)
2988        a = """for i in filter(f, 'abc'): pass"""
2989        self.unchanged(a)
2990        a = """[x for x in filter(f, 'abc')]"""
2991        self.unchanged(a)
2992        a = """(x for x in filter(f, 'abc'))"""
2993        self.unchanged(a)
2994
2995    def test_future_builtins(self):
2996        a = "from future_builtins import spam, filter; filter(f, 'ham')"
2997        self.unchanged(a)
2998
2999        b = """from future_builtins import spam; x = filter(f, 'abc')"""
3000        a = """from future_builtins import spam; x = list(filter(f, 'abc'))"""
3001        self.check(b, a)
3002
3003        a = "from future_builtins import *; filter(f, 'ham')"
3004        self.unchanged(a)
3005
3006class Test_map(FixerTestCase):
3007    fixer = "map"
3008
3009    def check(self, b, a):
3010        self.unchanged("from future_builtins import map; " + b, a)
3011        super(Test_map, self).check(b, a)
3012
3013    def test_prefix_preservation(self):
3014        b = """x =    map(   f,    'abc'   )"""
3015        a = """x =    list(map(   f,    'abc'   ))"""
3016        self.check(b, a)
3017
3018    def test_trailing_comment(self):
3019        b = """x = map(f, 'abc')   #   foo"""
3020        a = """x = list(map(f, 'abc'))   #   foo"""
3021        self.check(b, a)
3022
3023    def test_None_with_multiple_arguments(self):
3024        s = """x = map(None, a, b, c)"""
3025        self.warns_unchanged(s, "cannot convert map(None, ...) with "
3026                             "multiple arguments")
3027
3028    def test_map_basic(self):
3029        b = """x = map(f, 'abc')"""
3030        a = """x = list(map(f, 'abc'))"""
3031        self.check(b, a)
3032
3033        b = """x = len(map(f, 'abc', 'def'))"""
3034        a = """x = len(list(map(f, 'abc', 'def')))"""
3035        self.check(b, a)
3036
3037        b = """x = map(None, 'abc')"""
3038        a = """x = list('abc')"""
3039        self.check(b, a)
3040
3041        b = """x = map(lambda x: x+1, range(4))"""
3042        a = """x = [x+1 for x in range(4)]"""
3043        self.check(b, a)
3044
3045        # Note the parens around x
3046        b = """x = map(lambda (x): x+1, range(4))"""
3047        a = """x = [x+1 for x in range(4)]"""
3048        self.check(b, a)
3049
3050        b = """
3051            foo()
3052            # foo
3053            map(f, x)
3054            """
3055        a = """
3056            foo()
3057            # foo
3058            list(map(f, x))
3059            """
3060        self.warns(b, a, "You should use a for loop here")
3061
3062        # XXX This (rare) case is not supported
3063##         b = """x = map(f, 'abc')[0]"""
3064##         a = """x = list(map(f, 'abc'))[0]"""
3065##         self.check(b, a)
3066
3067    def test_map_nochange(self):
3068        a = """b.join(map(f, 'abc'))"""
3069        self.unchanged(a)
3070        a = """(a + foo(5)).join(map(f, 'abc'))"""
3071        self.unchanged(a)
3072        a = """iter(map(f, 'abc'))"""
3073        self.unchanged(a)
3074        a = """list(map(f, 'abc'))"""
3075        self.unchanged(a)
3076        a = """list(map(f, 'abc'))[0]"""
3077        self.unchanged(a)
3078        a = """set(map(f, 'abc'))"""
3079        self.unchanged(a)
3080        a = """set(map(f, 'abc')).pop()"""
3081        self.unchanged(a)
3082        a = """tuple(map(f, 'abc'))"""
3083        self.unchanged(a)
3084        a = """any(map(f, 'abc'))"""
3085        self.unchanged(a)
3086        a = """all(map(f, 'abc'))"""
3087        self.unchanged(a)
3088        a = """sum(map(f, 'abc'))"""
3089        self.unchanged(a)
3090        a = """sorted(map(f, 'abc'))"""
3091        self.unchanged(a)
3092        a = """sorted(map(f, 'abc'), key=blah)"""
3093        self.unchanged(a)
3094        a = """sorted(map(f, 'abc'), key=blah)[0]"""
3095        self.unchanged(a)
3096        a = """enumerate(map(f, 'abc'))"""
3097        self.unchanged(a)
3098        a = """enumerate(map(f, 'abc'), start=1)"""
3099        self.unchanged(a)
3100        a = """for i in map(f, 'abc'): pass"""
3101        self.unchanged(a)
3102        a = """[x for x in map(f, 'abc')]"""
3103        self.unchanged(a)
3104        a = """(x for x in map(f, 'abc'))"""
3105        self.unchanged(a)
3106
3107    def test_future_builtins(self):
3108        a = "from future_builtins import spam, map, eggs; map(f, 'ham')"
3109        self.unchanged(a)
3110
3111        b = """from future_builtins import spam, eggs; x = map(f, 'abc')"""
3112        a = """from future_builtins import spam, eggs; x = list(map(f, 'abc'))"""
3113        self.check(b, a)
3114
3115        a = "from future_builtins import *; map(f, 'ham')"
3116        self.unchanged(a)
3117
3118class Test_zip(FixerTestCase):
3119    fixer = "zip"
3120
3121    def check(self, b, a):
3122        self.unchanged("from future_builtins import zip; " + b, a)
3123        super(Test_zip, self).check(b, a)
3124
3125    def test_zip_basic(self):
3126        b = """x = zip(a, b, c)"""
3127        a = """x = list(zip(a, b, c))"""
3128        self.check(b, a)
3129
3130        b = """x = len(zip(a, b))"""
3131        a = """x = len(list(zip(a, b)))"""
3132        self.check(b, a)
3133
3134    def test_zip_nochange(self):
3135        a = """b.join(zip(a, b))"""
3136        self.unchanged(a)
3137        a = """(a + foo(5)).join(zip(a, b))"""
3138        self.unchanged(a)
3139        a = """iter(zip(a, b))"""
3140        self.unchanged(a)
3141        a = """list(zip(a, b))"""
3142        self.unchanged(a)
3143        a = """list(zip(a, b))[0]"""
3144        self.unchanged(a)
3145        a = """set(zip(a, b))"""
3146        self.unchanged(a)
3147        a = """set(zip(a, b)).pop()"""
3148        self.unchanged(a)
3149        a = """tuple(zip(a, b))"""
3150        self.unchanged(a)
3151        a = """any(zip(a, b))"""
3152        self.unchanged(a)
3153        a = """all(zip(a, b))"""
3154        self.unchanged(a)
3155        a = """sum(zip(a, b))"""
3156        self.unchanged(a)
3157        a = """sorted(zip(a, b))"""
3158        self.unchanged(a)
3159        a = """sorted(zip(a, b), key=blah)"""
3160        self.unchanged(a)
3161        a = """sorted(zip(a, b), key=blah)[0]"""
3162        self.unchanged(a)
3163        a = """enumerate(zip(a, b))"""
3164        self.unchanged(a)
3165        a = """enumerate(zip(a, b), start=1)"""
3166        self.unchanged(a)
3167        a = """for i in zip(a, b): pass"""
3168        self.unchanged(a)
3169        a = """[x for x in zip(a, b)]"""
3170        self.unchanged(a)
3171        a = """(x for x in zip(a, b))"""
3172        self.unchanged(a)
3173
3174    def test_future_builtins(self):
3175        a = "from future_builtins import spam, zip, eggs; zip(a, b)"
3176        self.unchanged(a)
3177
3178        b = """from future_builtins import spam, eggs; x = zip(a, b)"""
3179        a = """from future_builtins import spam, eggs; x = list(zip(a, b))"""
3180        self.check(b, a)
3181
3182        a = "from future_builtins import *; zip(a, b)"
3183        self.unchanged(a)
3184
3185class Test_standarderror(FixerTestCase):
3186    fixer = "standarderror"
3187
3188    def test(self):
3189        b = """x =    StandardError()"""
3190        a = """x =    Exception()"""
3191        self.check(b, a)
3192
3193        b = """x = StandardError(a, b, c)"""
3194        a = """x = Exception(a, b, c)"""
3195        self.check(b, a)
3196
3197        b = """f(2 + StandardError(a, b, c))"""
3198        a = """f(2 + Exception(a, b, c))"""
3199        self.check(b, a)
3200
3201class Test_types(FixerTestCase):
3202    fixer = "types"
3203
3204    def test_basic_types_convert(self):
3205        b = """types.StringType"""
3206        a = """bytes"""
3207        self.check(b, a)
3208
3209        b = """types.DictType"""
3210        a = """dict"""
3211        self.check(b, a)
3212
3213        b = """types . IntType"""
3214        a = """int"""
3215        self.check(b, a)
3216
3217        b = """types.ListType"""
3218        a = """list"""
3219        self.check(b, a)
3220
3221        b = """types.LongType"""
3222        a = """int"""
3223        self.check(b, a)
3224
3225        b = """types.NoneType"""
3226        a = """type(None)"""
3227        self.check(b, a)
3228
3229class Test_idioms(FixerTestCase):
3230    fixer = "idioms"
3231
3232    def test_while(self):
3233        b = """while 1: foo()"""
3234        a = """while True: foo()"""
3235        self.check(b, a)
3236
3237        b = """while   1: foo()"""
3238        a = """while   True: foo()"""
3239        self.check(b, a)
3240
3241        b = """
3242            while 1:
3243                foo()
3244            """
3245        a = """
3246            while True:
3247                foo()
3248            """
3249        self.check(b, a)
3250
3251    def test_while_unchanged(self):
3252        s = """while 11: foo()"""
3253        self.unchanged(s)
3254
3255        s = """while 0: foo()"""
3256        self.unchanged(s)
3257
3258        s = """while foo(): foo()"""
3259        self.unchanged(s)
3260
3261        s = """while []: foo()"""
3262        self.unchanged(s)
3263
3264    def test_eq_simple(self):
3265        b = """type(x) == T"""
3266        a = """isinstance(x, T)"""
3267        self.check(b, a)
3268
3269        b = """if   type(x) == T: pass"""
3270        a = """if   isinstance(x, T): pass"""
3271        self.check(b, a)
3272
3273    def test_eq_reverse(self):
3274        b = """T == type(x)"""
3275        a = """isinstance(x, T)"""
3276        self.check(b, a)
3277
3278        b = """if   T == type(x): pass"""
3279        a = """if   isinstance(x, T): pass"""
3280        self.check(b, a)
3281
3282    def test_eq_expression(self):
3283        b = """type(x+y) == d.get('T')"""
3284        a = """isinstance(x+y, d.get('T'))"""
3285        self.check(b, a)
3286
3287        b = """type(   x  +  y) == d.get('T')"""
3288        a = """isinstance(x  +  y, d.get('T'))"""
3289        self.check(b, a)
3290
3291    def test_is_simple(self):
3292        b = """type(x) is T"""
3293        a = """isinstance(x, T)"""
3294        self.check(b, a)
3295
3296        b = """if   type(x) is T: pass"""
3297        a = """if   isinstance(x, T): pass"""
3298        self.check(b, a)
3299
3300    def test_is_reverse(self):
3301        b = """T is type(x)"""
3302        a = """isinstance(x, T)"""
3303        self.check(b, a)
3304
3305        b = """if   T is type(x): pass"""
3306        a = """if   isinstance(x, T): pass"""
3307        self.check(b, a)
3308
3309    def test_is_expression(self):
3310        b = """type(x+y) is d.get('T')"""
3311        a = """isinstance(x+y, d.get('T'))"""
3312        self.check(b, a)
3313
3314        b = """type(   x  +  y) is d.get('T')"""
3315        a = """isinstance(x  +  y, d.get('T'))"""
3316        self.check(b, a)
3317
3318    def test_is_not_simple(self):
3319        b = """type(x) is not T"""
3320        a = """not isinstance(x, T)"""
3321        self.check(b, a)
3322
3323        b = """if   type(x) is not T: pass"""
3324        a = """if   not isinstance(x, T): pass"""
3325        self.check(b, a)
3326
3327    def test_is_not_reverse(self):
3328        b = """T is not type(x)"""
3329        a = """not isinstance(x, T)"""
3330        self.check(b, a)
3331
3332        b = """if   T is not type(x): pass"""
3333        a = """if   not isinstance(x, T): pass"""
3334        self.check(b, a)
3335
3336    def test_is_not_expression(self):
3337        b = """type(x+y) is not d.get('T')"""
3338        a = """not isinstance(x+y, d.get('T'))"""
3339        self.check(b, a)
3340
3341        b = """type(   x  +  y) is not d.get('T')"""
3342        a = """not isinstance(x  +  y, d.get('T'))"""
3343        self.check(b, a)
3344
3345    def test_ne_simple(self):
3346        b = """type(x) != T"""
3347        a = """not isinstance(x, T)"""
3348        self.check(b, a)
3349
3350        b = """if   type(x) != T: pass"""
3351        a = """if   not isinstance(x, T): pass"""
3352        self.check(b, a)
3353
3354    def test_ne_reverse(self):
3355        b = """T != type(x)"""
3356        a = """not isinstance(x, T)"""
3357        self.check(b, a)
3358
3359        b = """if   T != type(x): pass"""
3360        a = """if   not isinstance(x, T): pass"""
3361        self.check(b, a)
3362
3363    def test_ne_expression(self):
3364        b = """type(x+y) != d.get('T')"""
3365        a = """not isinstance(x+y, d.get('T'))"""
3366        self.check(b, a)
3367
3368        b = """type(   x  +  y) != d.get('T')"""
3369        a = """not isinstance(x  +  y, d.get('T'))"""
3370        self.check(b, a)
3371
3372    def test_type_unchanged(self):
3373        a = """type(x).__name__"""
3374        self.unchanged(a)
3375
3376    def test_sort_list_call(self):
3377        b = """
3378            v = list(t)
3379            v.sort()
3380            foo(v)
3381            """
3382        a = """
3383            v = sorted(t)
3384            foo(v)
3385            """
3386        self.check(b, a)
3387
3388        b = """
3389            v = list(foo(b) + d)
3390            v.sort()
3391            foo(v)
3392            """
3393        a = """
3394            v = sorted(foo(b) + d)
3395            foo(v)
3396            """
3397        self.check(b, a)
3398
3399        b = """
3400            while x:
3401                v = list(t)
3402                v.sort()
3403                foo(v)
3404            """
3405        a = """
3406            while x:
3407                v = sorted(t)
3408                foo(v)
3409            """
3410        self.check(b, a)
3411
3412        b = """
3413            v = list(t)
3414            # foo
3415            v.sort()
3416            foo(v)
3417            """
3418        a = """
3419            v = sorted(t)
3420            # foo
3421            foo(v)
3422            """
3423        self.check(b, a)
3424
3425        b = r"""
3426            v = list(   t)
3427            v.sort()
3428            foo(v)
3429            """
3430        a = r"""
3431            v = sorted(   t)
3432            foo(v)
3433            """
3434        self.check(b, a)
3435
3436        b = r"""
3437            try:
3438                m = list(s)
3439                m.sort()
3440            except: pass
3441            """
3442
3443        a = r"""
3444            try:
3445                m = sorted(s)
3446            except: pass
3447            """
3448        self.check(b, a)
3449
3450        b = r"""
3451            try:
3452                m = list(s)
3453                # foo
3454                m.sort()
3455            except: pass
3456            """
3457
3458        a = r"""
3459            try:
3460                m = sorted(s)
3461                # foo
3462            except: pass
3463            """
3464        self.check(b, a)
3465
3466        b = r"""
3467            m = list(s)
3468            # more comments
3469            m.sort()"""
3470
3471        a = r"""
3472            m = sorted(s)
3473            # more comments"""
3474        self.check(b, a)
3475
3476    def test_sort_simple_expr(self):
3477        b = """
3478            v = t
3479            v.sort()
3480            foo(v)
3481            """
3482        a = """
3483            v = sorted(t)
3484            foo(v)
3485            """
3486        self.check(b, a)
3487
3488        b = """
3489            v = foo(b)
3490            v.sort()
3491            foo(v)
3492            """
3493        a = """
3494            v = sorted(foo(b))
3495            foo(v)
3496            """
3497        self.check(b, a)
3498
3499        b = """
3500            v = b.keys()
3501            v.sort()
3502            foo(v)
3503            """
3504        a = """
3505            v = sorted(b.keys())
3506            foo(v)
3507            """
3508        self.check(b, a)
3509
3510        b = """
3511            v = foo(b) + d
3512            v.sort()
3513            foo(v)
3514            """
3515        a = """
3516            v = sorted(foo(b) + d)
3517            foo(v)
3518            """
3519        self.check(b, a)
3520
3521        b = """
3522            while x:
3523                v = t
3524                v.sort()
3525                foo(v)
3526            """
3527        a = """
3528            while x:
3529                v = sorted(t)
3530                foo(v)
3531            """
3532        self.check(b, a)
3533
3534        b = """
3535            v = t
3536            # foo
3537            v.sort()
3538            foo(v)
3539            """
3540        a = """
3541            v = sorted(t)
3542            # foo
3543            foo(v)
3544            """
3545        self.check(b, a)
3546
3547        b = r"""
3548            v =   t
3549            v.sort()
3550            foo(v)
3551            """
3552        a = r"""
3553            v =   sorted(t)
3554            foo(v)
3555            """
3556        self.check(b, a)
3557
3558    def test_sort_unchanged(self):
3559        s = """
3560            v = list(t)
3561            w.sort()
3562            foo(w)
3563            """
3564        self.unchanged(s)
3565
3566        s = """
3567            v = list(t)
3568            v.sort(u)
3569            foo(v)
3570            """
3571        self.unchanged(s)
3572
3573class Test_basestring(FixerTestCase):
3574    fixer = "basestring"
3575
3576    def test_basestring(self):
3577        b = """isinstance(x, basestring)"""
3578        a = """isinstance(x, str)"""
3579        self.check(b, a)
3580
3581class Test_buffer(FixerTestCase):
3582    fixer = "buffer"
3583
3584    def test_buffer(self):
3585        b = """x = buffer(y)"""
3586        a = """x = memoryview(y)"""
3587        self.check(b, a)
3588
3589    def test_slicing(self):
3590        b = """buffer(y)[4:5]"""
3591        a = """memoryview(y)[4:5]"""
3592        self.check(b, a)
3593
3594class Test_future(FixerTestCase):
3595    fixer = "future"
3596
3597    def test_future(self):
3598        b = """from __future__ import braces"""
3599        a = """"""
3600        self.check(b, a)
3601
3602        b = """# comment\nfrom __future__ import braces"""
3603        a = """# comment\n"""
3604        self.check(b, a)
3605
3606        b = """from __future__ import braces\n# comment"""
3607        a = """\n# comment"""
3608        self.check(b, a)
3609
3610    def test_run_order(self):
3611        self.assert_runs_after('print')
3612
3613class Test_itertools(FixerTestCase):
3614    fixer = "itertools"
3615
3616    def checkall(self, before, after):
3617        # Because we need to check with and without the itertools prefix
3618        # and on each of the three functions, these loops make it all
3619        # much easier
3620        for i in ('itertools.', ''):
3621            for f in ('map', 'filter', 'zip'):
3622                b = before %(i+'i'+f)
3623                a = after %(f)
3624                self.check(b, a)
3625
3626    def test_0(self):
3627        # A simple example -- test_1 covers exactly the same thing,
3628        # but it's not quite as clear.
3629        b = "itertools.izip(a, b)"
3630        a = "zip(a, b)"
3631        self.check(b, a)
3632
3633    def test_1(self):
3634        b = """%s(f, a)"""
3635        a = """%s(f, a)"""
3636        self.checkall(b, a)
3637
3638    def test_qualified(self):
3639        b = """itertools.ifilterfalse(a, b)"""
3640        a = """itertools.filterfalse(a, b)"""
3641        self.check(b, a)
3642
3643        b = """itertools.izip_longest(a, b)"""
3644        a = """itertools.zip_longest(a, b)"""
3645        self.check(b, a)
3646
3647    def test_2(self):
3648        b = """ifilterfalse(a, b)"""
3649        a = """filterfalse(a, b)"""
3650        self.check(b, a)
3651
3652        b = """izip_longest(a, b)"""
3653        a = """zip_longest(a, b)"""
3654        self.check(b, a)
3655
3656    def test_space_1(self):
3657        b = """    %s(f, a)"""
3658        a = """    %s(f, a)"""
3659        self.checkall(b, a)
3660
3661    def test_space_2(self):
3662        b = """    itertools.ifilterfalse(a, b)"""
3663        a = """    itertools.filterfalse(a, b)"""
3664        self.check(b, a)
3665
3666        b = """    itertools.izip_longest(a, b)"""
3667        a = """    itertools.zip_longest(a, b)"""
3668        self.check(b, a)
3669
3670    def test_run_order(self):
3671        self.assert_runs_after('map', 'zip', 'filter')
3672
3673
3674class Test_itertools_imports(FixerTestCase):
3675    fixer = 'itertools_imports'
3676
3677    def test_reduced(self):
3678        b = "from itertools import imap, izip, foo"
3679        a = "from itertools import foo"
3680        self.check(b, a)
3681
3682        b = "from itertools import bar, imap, izip, foo"
3683        a = "from itertools import bar, foo"
3684        self.check(b, a)
3685
3686        b = "from itertools import chain, imap, izip"
3687        a = "from itertools import chain"
3688        self.check(b, a)
3689
3690    def test_comments(self):
3691        b = "#foo\nfrom itertools import imap, izip"
3692        a = "#foo\n"
3693        self.check(b, a)
3694
3695    def test_none(self):
3696        b = "from itertools import imap, izip"
3697        a = ""
3698        self.check(b, a)
3699
3700        b = "from itertools import izip"
3701        a = ""
3702        self.check(b, a)
3703
3704    def test_import_as(self):
3705        b = "from itertools import izip, bar as bang, imap"
3706        a = "from itertools import bar as bang"
3707        self.check(b, a)
3708
3709        b = "from itertools import izip as _zip, imap, bar"
3710        a = "from itertools import bar"
3711        self.check(b, a)
3712
3713        b = "from itertools import imap as _map"
3714        a = ""
3715        self.check(b, a)
3716
3717        b = "from itertools import imap as _map, izip as _zip"
3718        a = ""
3719        self.check(b, a)
3720
3721        s = "from itertools import bar as bang"
3722        self.unchanged(s)
3723
3724    def test_ifilter_and_zip_longest(self):
3725        for name in "filterfalse", "zip_longest":
3726            b = "from itertools import i%s" % (name,)
3727            a = "from itertools import %s" % (name,)
3728            self.check(b, a)
3729
3730            b = "from itertools import imap, i%s, foo" % (name,)
3731            a = "from itertools import %s, foo" % (name,)
3732            self.check(b, a)
3733
3734            b = "from itertools import bar, i%s, foo" % (name,)
3735            a = "from itertools import bar, %s, foo" % (name,)
3736            self.check(b, a)
3737
3738    def test_import_star(self):
3739        s = "from itertools import *"
3740        self.unchanged(s)
3741
3742
3743    def test_unchanged(self):
3744        s = "from itertools import foo"
3745        self.unchanged(s)
3746
3747
3748class Test_import(FixerTestCase):
3749    fixer = "import"
3750
3751    def setUp(self):
3752        super(Test_import, self).setUp()
3753        # Need to replace fix_import's exists method
3754        # so we can check that it's doing the right thing
3755        self.files_checked = []
3756        self.present_files = set()
3757        self.always_exists = True
3758        def fake_exists(name):
3759            self.files_checked.append(name)
3760            return self.always_exists or (name in self.present_files)
3761
3762        from lib2to3.fixes import fix_import
3763        fix_import.exists = fake_exists
3764
3765    def tearDown(self):
3766        from lib2to3.fixes import fix_import
3767        fix_import.exists = os.path.exists
3768
3769    def check_both(self, b, a):
3770        self.always_exists = True
3771        super(Test_import, self).check(b, a)
3772        self.always_exists = False
3773        super(Test_import, self).unchanged(b)
3774
3775    def test_files_checked(self):
3776        def p(path):
3777            # Takes a unix path and returns a path with correct separators
3778            return os.path.pathsep.join(path.split("/"))
3779
3780        self.always_exists = False
3781        self.present_files = set(['__init__.py'])
3782        expected_extensions = ('.py', os.path.sep, '.pyc', '.so', '.sl', '.pyd')
3783        names_to_test = (p("/spam/eggs.py"), "ni.py", p("../../shrubbery.py"))
3784
3785        for name in names_to_test:
3786            self.files_checked = []
3787            self.filename = name
3788            self.unchanged("import jam")
3789
3790            if os.path.dirname(name):
3791                name = os.path.dirname(name) + '/jam'
3792            else:
3793                name = 'jam'
3794            expected_checks = set(name + ext for ext in expected_extensions)
3795            expected_checks.add("__init__.py")
3796
3797            self.assertEqual(set(self.files_checked), expected_checks)
3798
3799    def test_not_in_package(self):
3800        s = "import bar"
3801        self.always_exists = False
3802        self.present_files = set(["bar.py"])
3803        self.unchanged(s)
3804
3805    def test_with_absolute_import_enabled(self):
3806        s = "from __future__ import absolute_import\nimport bar"
3807        self.always_exists = False
3808        self.present_files = set(["__init__.py", "bar.py"])
3809        self.unchanged(s)
3810
3811    def test_in_package(self):
3812        b = "import bar"
3813        a = "from . import bar"
3814        self.always_exists = False
3815        self.present_files = set(["__init__.py", "bar.py"])
3816        self.check(b, a)
3817
3818    def test_import_from_package(self):
3819        b = "import bar"
3820        a = "from . import bar"
3821        self.always_exists = False
3822        self.present_files = set(["__init__.py", "bar" + os.path.sep])
3823        self.check(b, a)
3824
3825    def test_already_relative_import(self):
3826        s = "from . import bar"
3827        self.unchanged(s)
3828
3829    def test_comments_and_indent(self):
3830        b = "import bar # Foo"
3831        a = "from . import bar # Foo"
3832        self.check(b, a)
3833
3834    def test_from(self):
3835        b = "from foo import bar, baz"
3836        a = "from .foo import bar, baz"
3837        self.check_both(b, a)
3838
3839        b = "from foo import bar"
3840        a = "from .foo import bar"
3841        self.check_both(b, a)
3842
3843        b = "from foo import (bar, baz)"
3844        a = "from .foo import (bar, baz)"
3845        self.check_both(b, a)
3846
3847    def test_dotted_from(self):
3848        b = "from green.eggs import ham"
3849        a = "from .green.eggs import ham"
3850        self.check_both(b, a)
3851
3852    def test_from_as(self):
3853        b = "from green.eggs import ham as spam"
3854        a = "from .green.eggs import ham as spam"
3855        self.check_both(b, a)
3856
3857    def test_import(self):
3858        b = "import foo"
3859        a = "from . import foo"
3860        self.check_both(b, a)
3861
3862        b = "import foo, bar"
3863        a = "from . import foo, bar"
3864        self.check_both(b, a)
3865
3866        b = "import foo, bar, x"
3867        a = "from . import foo, bar, x"
3868        self.check_both(b, a)
3869
3870        b = "import x, y, z"
3871        a = "from . import x, y, z"
3872        self.check_both(b, a)
3873
3874    def test_import_as(self):
3875        b = "import foo as x"
3876        a = "from . import foo as x"
3877        self.check_both(b, a)
3878
3879        b = "import a as b, b as c, c as d"
3880        a = "from . import a as b, b as c, c as d"
3881        self.check_both(b, a)
3882
3883    def test_local_and_absolute(self):
3884        self.always_exists = False
3885        self.present_files = set(["foo.py", "__init__.py"])
3886
3887        s = "import foo, bar"
3888        self.warns_unchanged(s, "absolute and local imports together")
3889
3890    def test_dotted_import(self):
3891        b = "import foo.bar"
3892        a = "from . import foo.bar"
3893        self.check_both(b, a)
3894
3895    def test_dotted_import_as(self):
3896        b = "import foo.bar as bang"
3897        a = "from . import foo.bar as bang"
3898        self.check_both(b, a)
3899
3900    def test_prefix(self):
3901        b = """
3902        # prefix
3903        import foo.bar
3904        """
3905        a = """
3906        # prefix
3907        from . import foo.bar
3908        """
3909        self.check_both(b, a)
3910
3911
3912class Test_set_literal(FixerTestCase):
3913
3914    fixer = "set_literal"
3915
3916    def test_basic(self):
3917        b = """set([1, 2, 3])"""
3918        a = """{1, 2, 3}"""
3919        self.check(b, a)
3920
3921        b = """set((1, 2, 3))"""
3922        a = """{1, 2, 3}"""
3923        self.check(b, a)
3924
3925        b = """set((1,))"""
3926        a = """{1}"""
3927        self.check(b, a)
3928
3929        b = """set([1])"""
3930        self.check(b, a)
3931
3932        b = """set((a, b))"""
3933        a = """{a, b}"""
3934        self.check(b, a)
3935
3936        b = """set([a, b])"""
3937        self.check(b, a)
3938
3939        b = """set((a*234, f(args=23)))"""
3940        a = """{a*234, f(args=23)}"""
3941        self.check(b, a)
3942
3943        b = """set([a*23, f(23)])"""
3944        a = """{a*23, f(23)}"""
3945        self.check(b, a)
3946
3947        b = """set([a-234**23])"""
3948        a = """{a-234**23}"""
3949        self.check(b, a)
3950
3951    def test_listcomps(self):
3952        b = """set([x for x in y])"""
3953        a = """{x for x in y}"""
3954        self.check(b, a)
3955
3956        b = """set([x for x in y if x == m])"""
3957        a = """{x for x in y if x == m}"""
3958        self.check(b, a)
3959
3960        b = """set([x for x in y for a in b])"""
3961        a = """{x for x in y for a in b}"""
3962        self.check(b, a)
3963
3964        b = """set([f(x) - 23 for x in y])"""
3965        a = """{f(x) - 23 for x in y}"""
3966        self.check(b, a)
3967
3968    def test_whitespace(self):
3969        b = """set( [1, 2])"""
3970        a = """{1, 2}"""
3971        self.check(b, a)
3972
3973        b = """set([1 ,  2])"""
3974        a = """{1 ,  2}"""
3975        self.check(b, a)
3976
3977        b = """set([ 1 ])"""
3978        a = """{ 1 }"""
3979        self.check(b, a)
3980
3981        b = """set( [1] )"""
3982        a = """{1}"""
3983        self.check(b, a)
3984
3985        b = """set([  1,  2  ])"""
3986        a = """{  1,  2  }"""
3987        self.check(b, a)
3988
3989        b = """set([x  for x in y ])"""
3990        a = """{x  for x in y }"""
3991        self.check(b, a)
3992
3993        b = """set(
3994                   [1, 2]
3995               )
3996            """
3997        a = """{1, 2}\n"""
3998        self.check(b, a)
3999
4000    def test_comments(self):
4001        b = """set((1, 2)) # Hi"""
4002        a = """{1, 2} # Hi"""
4003        self.check(b, a)
4004
4005        # This isn't optimal behavior, but the fixer is optional.
4006        b = """
4007            # Foo
4008            set( # Bar
4009               (1, 2)
4010            )
4011            """
4012        a = """
4013            # Foo
4014            {1, 2}
4015            """
4016        self.check(b, a)
4017
4018    def test_unchanged(self):
4019        s = """set()"""
4020        self.unchanged(s)
4021
4022        s = """set(a)"""
4023        self.unchanged(s)
4024
4025        s = """set(a, b, c)"""
4026        self.unchanged(s)
4027
4028        # Don't transform generators because they might have to be lazy.
4029        s = """set(x for x in y)"""
4030        self.unchanged(s)
4031
4032        s = """set(x for x in y if z)"""
4033        self.unchanged(s)
4034
4035        s = """set(a*823-23**2 + f(23))"""
4036        self.unchanged(s)
4037
4038
4039class Test_sys_exc(FixerTestCase):
4040    fixer = "sys_exc"
4041
4042    def test_0(self):
4043        b = "sys.exc_type"
4044        a = "sys.exc_info()[0]"
4045        self.check(b, a)
4046
4047    def test_1(self):
4048        b = "sys.exc_value"
4049        a = "sys.exc_info()[1]"
4050        self.check(b, a)
4051
4052    def test_2(self):
4053        b = "sys.exc_traceback"
4054        a = "sys.exc_info()[2]"
4055        self.check(b, a)
4056
4057    def test_3(self):
4058        b = "sys.exc_type # Foo"
4059        a = "sys.exc_info()[0] # Foo"
4060        self.check(b, a)
4061
4062    def test_4(self):
4063        b = "sys.  exc_type"
4064        a = "sys.  exc_info()[0]"
4065        self.check(b, a)
4066
4067    def test_5(self):
4068        b = "sys  .exc_type"
4069        a = "sys  .exc_info()[0]"
4070        self.check(b, a)
4071
4072
4073class Test_paren(FixerTestCase):
4074    fixer = "paren"
4075
4076    def test_0(self):
4077        b = """[i for i in 1, 2 ]"""
4078        a = """[i for i in (1, 2) ]"""
4079        self.check(b, a)
4080
4081    def test_1(self):
4082        b = """[i for i in 1, 2, ]"""
4083        a = """[i for i in (1, 2,) ]"""
4084        self.check(b, a)
4085
4086    def test_2(self):
4087        b = """[i for i  in     1, 2 ]"""
4088        a = """[i for i  in     (1, 2) ]"""
4089        self.check(b, a)
4090
4091    def test_3(self):
4092        b = """[i for i in 1, 2 if i]"""
4093        a = """[i for i in (1, 2) if i]"""
4094        self.check(b, a)
4095
4096    def test_4(self):
4097        b = """[i for i in 1,    2    ]"""
4098        a = """[i for i in (1,    2)    ]"""
4099        self.check(b, a)
4100
4101    def test_5(self):
4102        b = """(i for i in 1, 2)"""
4103        a = """(i for i in (1, 2))"""
4104        self.check(b, a)
4105
4106    def test_6(self):
4107        b = """(i for i in 1   ,2   if i)"""
4108        a = """(i for i in (1   ,2)   if i)"""
4109        self.check(b, a)
4110
4111    def test_unchanged_0(self):
4112        s = """[i for i in (1, 2)]"""
4113        self.unchanged(s)
4114
4115    def test_unchanged_1(self):
4116        s = """[i for i in foo()]"""
4117        self.unchanged(s)
4118
4119    def test_unchanged_2(self):
4120        s = """[i for i in (1, 2) if nothing]"""
4121        self.unchanged(s)
4122
4123    def test_unchanged_3(self):
4124        s = """(i for i in (1, 2))"""
4125        self.unchanged(s)
4126
4127    def test_unchanged_4(self):
4128        s = """[i for i in m]"""
4129        self.unchanged(s)
4130
4131class Test_metaclass(FixerTestCase):
4132
4133    fixer = 'metaclass'
4134
4135    def test_unchanged(self):
4136        self.unchanged("class X(): pass")
4137        self.unchanged("class X(object): pass")
4138        self.unchanged("class X(object1, object2): pass")
4139        self.unchanged("class X(object1, object2, object3): pass")
4140        self.unchanged("class X(metaclass=Meta): pass")
4141        self.unchanged("class X(b, arg=23, metclass=Meta): pass")
4142        self.unchanged("class X(b, arg=23, metaclass=Meta, other=42): pass")
4143
4144        s = """
4145        class X:
4146            def __metaclass__(self): pass
4147        """
4148        self.unchanged(s)
4149
4150        s = """
4151        class X:
4152            a[23] = 74
4153        """
4154        self.unchanged(s)
4155
4156    def test_comments(self):
4157        b = """
4158        class X:
4159            # hi
4160            __metaclass__ = AppleMeta
4161        """
4162        a = """
4163        class X(metaclass=AppleMeta):
4164            # hi
4165            pass
4166        """
4167        self.check(b, a)
4168
4169        b = """
4170        class X:
4171            __metaclass__ = Meta
4172            # Bedtime!
4173        """
4174        a = """
4175        class X(metaclass=Meta):
4176            pass
4177            # Bedtime!
4178        """
4179        self.check(b, a)
4180
4181    def test_meta(self):
4182        # no-parent class, odd body
4183        b = """
4184        class X():
4185            __metaclass__ = Q
4186            pass
4187        """
4188        a = """
4189        class X(metaclass=Q):
4190            pass
4191        """
4192        self.check(b, a)
4193
4194        # one parent class, no body
4195        b = """class X(object): __metaclass__ = Q"""
4196        a = """class X(object, metaclass=Q): pass"""
4197        self.check(b, a)
4198
4199
4200        # one parent, simple body
4201        b = """
4202        class X(object):
4203            __metaclass__ = Meta
4204            bar = 7
4205        """
4206        a = """
4207        class X(object, metaclass=Meta):
4208            bar = 7
4209        """
4210        self.check(b, a)
4211
4212        b = """
4213        class X:
4214            __metaclass__ = Meta; x = 4; g = 23
4215        """
4216        a = """
4217        class X(metaclass=Meta):
4218            x = 4; g = 23
4219        """
4220        self.check(b, a)
4221
4222        # one parent, simple body, __metaclass__ last
4223        b = """
4224        class X(object):
4225            bar = 7
4226            __metaclass__ = Meta
4227        """
4228        a = """
4229        class X(object, metaclass=Meta):
4230            bar = 7
4231        """
4232        self.check(b, a)
4233
4234        # redefining __metaclass__
4235        b = """
4236        class X():
4237            __metaclass__ = A
4238            __metaclass__ = B
4239            bar = 7
4240        """
4241        a = """
4242        class X(metaclass=B):
4243            bar = 7
4244        """
4245        self.check(b, a)
4246
4247        # multiple inheritance, simple body
4248        b = """
4249        class X(clsA, clsB):
4250            __metaclass__ = Meta
4251            bar = 7
4252        """
4253        a = """
4254        class X(clsA, clsB, metaclass=Meta):
4255            bar = 7
4256        """
4257        self.check(b, a)
4258
4259        # keywords in the class statement
4260        b = """class m(a, arg=23): __metaclass__ = Meta"""
4261        a = """class m(a, arg=23, metaclass=Meta): pass"""
4262        self.check(b, a)
4263
4264        b = """
4265        class X(expression(2 + 4)):
4266            __metaclass__ = Meta
4267        """
4268        a = """
4269        class X(expression(2 + 4), metaclass=Meta):
4270            pass
4271        """
4272        self.check(b, a)
4273
4274        b = """
4275        class X(expression(2 + 4), x**4):
4276            __metaclass__ = Meta
4277        """
4278        a = """
4279        class X(expression(2 + 4), x**4, metaclass=Meta):
4280            pass
4281        """
4282        self.check(b, a)
4283
4284        b = """
4285        class X:
4286            __metaclass__ = Meta
4287            save.py = 23
4288        """
4289        a = """
4290        class X(metaclass=Meta):
4291            save.py = 23
4292        """
4293        self.check(b, a)
4294
4295
4296class Test_getcwdu(FixerTestCase):
4297
4298    fixer = 'getcwdu'
4299
4300    def test_basic(self):
4301        b = """os.getcwdu"""
4302        a = """os.getcwd"""
4303        self.check(b, a)
4304
4305        b = """os.getcwdu()"""
4306        a = """os.getcwd()"""
4307        self.check(b, a)
4308
4309        b = """meth = os.getcwdu"""
4310        a = """meth = os.getcwd"""
4311        self.check(b, a)
4312
4313        b = """os.getcwdu(args)"""
4314        a = """os.getcwd(args)"""
4315        self.check(b, a)
4316
4317    def test_comment(self):
4318        b = """os.getcwdu() # Foo"""
4319        a = """os.getcwd() # Foo"""
4320        self.check(b, a)
4321
4322    def test_unchanged(self):
4323        s = """os.getcwd()"""
4324        self.unchanged(s)
4325
4326        s = """getcwdu()"""
4327        self.unchanged(s)
4328
4329        s = """os.getcwdb()"""
4330        self.unchanged(s)
4331
4332    def test_indentation(self):
4333        b = """
4334            if 1:
4335                os.getcwdu()
4336            """
4337        a = """
4338            if 1:
4339                os.getcwd()
4340            """
4341        self.check(b, a)
4342
4343    def test_multilation(self):
4344        b = """os .getcwdu()"""
4345        a = """os .getcwd()"""
4346        self.check(b, a)
4347
4348        b = """os.  getcwdu"""
4349        a = """os.  getcwd"""
4350        self.check(b, a)
4351
4352        b = """os.getcwdu (  )"""
4353        a = """os.getcwd (  )"""
4354        self.check(b, a)
4355
4356
4357class Test_operator(FixerTestCase):
4358
4359    fixer = "operator"
4360
4361    def test_operator_isCallable(self):
4362        b = "operator.isCallable(x)"
4363        a = "hasattr(x, '__call__')"
4364        self.check(b, a)
4365
4366    def test_operator_sequenceIncludes(self):
4367        b = "operator.sequenceIncludes(x, y)"
4368        a = "operator.contains(x, y)"
4369        self.check(b, a)
4370
4371        b = "operator .sequenceIncludes(x, y)"
4372        a = "operator .contains(x, y)"
4373        self.check(b, a)
4374
4375        b = "operator.  sequenceIncludes(x, y)"
4376        a = "operator.  contains(x, y)"
4377        self.check(b, a)
4378
4379    def test_operator_isSequenceType(self):
4380        b = "operator.isSequenceType(x)"
4381        a = "import collections\nisinstance(x, collections.Sequence)"
4382        self.check(b, a)
4383
4384    def test_operator_isMappingType(self):
4385        b = "operator.isMappingType(x)"
4386        a = "import collections\nisinstance(x, collections.Mapping)"
4387        self.check(b, a)
4388
4389    def test_operator_isNumberType(self):
4390        b = "operator.isNumberType(x)"
4391        a = "import numbers\nisinstance(x, numbers.Number)"
4392        self.check(b, a)
4393
4394    def test_operator_repeat(self):
4395        b = "operator.repeat(x, n)"
4396        a = "operator.mul(x, n)"
4397        self.check(b, a)
4398
4399        b = "operator .repeat(x, n)"
4400        a = "operator .mul(x, n)"
4401        self.check(b, a)
4402
4403        b = "operator.  repeat(x, n)"
4404        a = "operator.  mul(x, n)"
4405        self.check(b, a)
4406
4407    def test_operator_irepeat(self):
4408        b = "operator.irepeat(x, n)"
4409        a = "operator.imul(x, n)"
4410        self.check(b, a)
4411
4412        b = "operator .irepeat(x, n)"
4413        a = "operator .imul(x, n)"
4414        self.check(b, a)
4415
4416        b = "operator.  irepeat(x, n)"
4417        a = "operator.  imul(x, n)"
4418        self.check(b, a)
4419
4420    def test_bare_isCallable(self):
4421        s = "isCallable(x)"
4422        t = "You should use 'hasattr(x, '__call__')' here."
4423        self.warns_unchanged(s, t)
4424
4425    def test_bare_sequenceIncludes(self):
4426        s = "sequenceIncludes(x, y)"
4427        t = "You should use 'operator.contains(x, y)' here."
4428        self.warns_unchanged(s, t)
4429
4430    def test_bare_operator_isSequenceType(self):
4431        s = "isSequenceType(z)"
4432        t = "You should use 'isinstance(z, collections.Sequence)' here."
4433        self.warns_unchanged(s, t)
4434
4435    def test_bare_operator_isMappingType(self):
4436        s = "isMappingType(x)"
4437        t = "You should use 'isinstance(x, collections.Mapping)' here."
4438        self.warns_unchanged(s, t)
4439
4440    def test_bare_operator_isNumberType(self):
4441        s = "isNumberType(y)"
4442        t = "You should use 'isinstance(y, numbers.Number)' here."
4443        self.warns_unchanged(s, t)
4444
4445    def test_bare_operator_repeat(self):
4446        s = "repeat(x, n)"
4447        t = "You should use 'operator.mul(x, n)' here."
4448        self.warns_unchanged(s, t)
4449
4450    def test_bare_operator_irepeat(self):
4451        s = "irepeat(y, 187)"
4452        t = "You should use 'operator.imul(y, 187)' here."
4453        self.warns_unchanged(s, t)
4454
4455
4456class Test_exitfunc(FixerTestCase):
4457
4458    fixer = "exitfunc"
4459
4460    def test_simple(self):
4461        b = """
4462            import sys
4463            sys.exitfunc = my_atexit
4464            """
4465        a = """
4466            import sys
4467            import atexit
4468            atexit.register(my_atexit)
4469            """
4470        self.check(b, a)
4471
4472    def test_names_import(self):
4473        b = """
4474            import sys, crumbs
4475            sys.exitfunc = my_func
4476            """
4477        a = """
4478            import sys, crumbs, atexit
4479            atexit.register(my_func)
4480            """
4481        self.check(b, a)
4482
4483    def test_complex_expression(self):
4484        b = """
4485            import sys
4486            sys.exitfunc = do(d)/a()+complex(f=23, g=23)*expression
4487            """
4488        a = """
4489            import sys
4490            import atexit
4491            atexit.register(do(d)/a()+complex(f=23, g=23)*expression)
4492            """
4493        self.check(b, a)
4494
4495    def test_comments(self):
4496        b = """
4497            import sys # Foo
4498            sys.exitfunc = f # Blah
4499            """
4500        a = """
4501            import sys
4502            import atexit # Foo
4503            atexit.register(f) # Blah
4504            """
4505        self.check(b, a)
4506
4507        b = """
4508            import apples, sys, crumbs, larry # Pleasant comments
4509            sys.exitfunc = func
4510            """
4511        a = """
4512            import apples, sys, crumbs, larry, atexit # Pleasant comments
4513            atexit.register(func)
4514            """
4515        self.check(b, a)
4516
4517    def test_in_a_function(self):
4518        b = """
4519            import sys
4520            def f():
4521                sys.exitfunc = func
4522            """
4523        a = """
4524            import sys
4525            import atexit
4526            def f():
4527                atexit.register(func)
4528             """
4529        self.check(b, a)
4530
4531    def test_no_sys_import(self):
4532        b = """sys.exitfunc = f"""
4533        a = """atexit.register(f)"""
4534        msg = ("Can't find sys import; Please add an atexit import at the "
4535            "top of your file.")
4536        self.warns(b, a, msg)
4537
4538
4539    def test_unchanged(self):
4540        s = """f(sys.exitfunc)"""
4541        self.unchanged(s)
4542