1 """ Test suite for the fixer modules """ 2 3 # Python imports 4 import os 5 import unittest 6 from itertools import chain 7 from operator import itemgetter 8 9 # Local imports 10 from lib2to3 import pygram, pytree, refactor, fixer_util 11 from lib2to3.tests import support 12 13 14 class 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 71 class 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 98 class 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 156 class 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 285 class 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 334 class 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 369 class 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 475 class 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 526 class 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 564 class 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 839 class 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 966 class 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 1091 class 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 1137 class 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 1175 class 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 1203 class 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 1433 class 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 1505 class 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 1513 reduce(x, range(5))""" 1514 self.check(b, a) 1515 1516 class 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 1563 class 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 1589 class 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 1632 class 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 1730 class 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 1751 class Test_imports2(FixerTestCase, ImportsFixerTests): 1752 fixer = "imports2" 1753 from ..fixes.fix_imports2 import MAPPING as modules 1754 1755 1756 class 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 1772 class 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 = """ 1831 def foo(): 1832 from urllib import urlencode, urlopen 1833 """ 1834 a = """ 1835 def foo(): 1836 from urllib.parse import urlencode 1837 from urllib.request import urlopen 1838 """ 1839 self.check(b, a) 1840 1841 b = """ 1842 def foo(): 1843 other() 1844 from urllib import urlencode, urlopen 1845 """ 1846 a = """ 1847 def 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 1882 class 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 1929 class 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 2116 class 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 2148 class 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 2622 class 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 2674 class 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 2740 class 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 2786 class 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 2827 class 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 2837 if 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 = """ 2847 def spam(foo): 2848 callable(foo)"""[1:] 2849 a = """ 2850 import collections 2851 def spam(foo): 2852 isinstance(foo, collections.Callable)"""[1:] 2853 self.check(b, a) 2854 2855 b = """ 2856 import collections 2857 def spam(foo): 2858 callable(foo)"""[1:] 2859 # same output if it was already imported 2860 self.check(b, a) 2861 2862 b = """ 2863 from collections import * 2864 def spam(foo): 2865 callable(foo)"""[1:] 2866 a = """ 2867 from collections import * 2868 import collections 2869 def spam(foo): 2870 isinstance(foo, collections.Callable)"""[1:] 2871 self.check(b, a) 2872 2873 b = """ 2874 do_stuff() 2875 do_some_other_stuff() 2876 assert callable(do_stuff)"""[1:] 2877 a = """ 2878 import collections 2879 do_stuff() 2880 do_some_other_stuff() 2881 assert isinstance(do_stuff, collections.Callable)"""[1:] 2882 self.check(b, a) 2883 2884 b = """ 2885 if 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) 2892 else: 2893 assert not callable(do_stuff)"""[1:] 2894 a = """ 2895 import collections 2896 if 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) 2903 else: 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 2920 class 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 = """for i in filter(f, 'abc'): pass""" 2985 self.unchanged(a) 2986 a = """[x for x in filter(f, 'abc')]""" 2987 self.unchanged(a) 2988 a = """(x for x in filter(f, 'abc'))""" 2989 self.unchanged(a) 2990 2991 def test_future_builtins(self): 2992 a = "from future_builtins import spam, filter; filter(f, 'ham')" 2993 self.unchanged(a) 2994 2995 b = """from future_builtins import spam; x = filter(f, 'abc')""" 2996 a = """from future_builtins import spam; x = list(filter(f, 'abc'))""" 2997 self.check(b, a) 2998 2999 a = "from future_builtins import *; filter(f, 'ham')" 3000 self.unchanged(a) 3001 3002 class Test_map(FixerTestCase): 3003 fixer = "map" 3004 3005 def check(self, b, a): 3006 self.unchanged("from future_builtins import map; " + b, a) 3007 super(Test_map, self).check(b, a) 3008 3009 def test_prefix_preservation(self): 3010 b = """x = map( f, 'abc' )""" 3011 a = """x = list(map( f, 'abc' ))""" 3012 self.check(b, a) 3013 3014 def test_trailing_comment(self): 3015 b = """x = map(f, 'abc') # foo""" 3016 a = """x = list(map(f, 'abc')) # foo""" 3017 self.check(b, a) 3018 3019 def test_None_with_multiple_arguments(self): 3020 s = """x = map(None, a, b, c)""" 3021 self.warns_unchanged(s, "cannot convert map(None, ...) with " 3022 "multiple arguments") 3023 3024 def test_map_basic(self): 3025 b = """x = map(f, 'abc')""" 3026 a = """x = list(map(f, 'abc'))""" 3027 self.check(b, a) 3028 3029 b = """x = len(map(f, 'abc', 'def'))""" 3030 a = """x = len(list(map(f, 'abc', 'def')))""" 3031 self.check(b, a) 3032 3033 b = """x = map(None, 'abc')""" 3034 a = """x = list('abc')""" 3035 self.check(b, a) 3036 3037 b = """x = map(lambda x: x+1, range(4))""" 3038 a = """x = [x+1 for x in range(4)]""" 3039 self.check(b, a) 3040 3041 # Note the parens around x 3042 b = """x = map(lambda (x): x+1, range(4))""" 3043 a = """x = [x+1 for x in range(4)]""" 3044 self.check(b, a) 3045 3046 b = """ 3047 foo() 3048 # foo 3049 map(f, x) 3050 """ 3051 a = """ 3052 foo() 3053 # foo 3054 list(map(f, x)) 3055 """ 3056 self.warns(b, a, "You should use a for loop here") 3057 3058 # XXX This (rare) case is not supported 3059 ## b = """x = map(f, 'abc')[0]""" 3060 ## a = """x = list(map(f, 'abc'))[0]""" 3061 ## self.check(b, a) 3062 3063 def test_map_nochange(self): 3064 a = """b.join(map(f, 'abc'))""" 3065 self.unchanged(a) 3066 a = """(a + foo(5)).join(map(f, 'abc'))""" 3067 self.unchanged(a) 3068 a = """iter(map(f, 'abc'))""" 3069 self.unchanged(a) 3070 a = """list(map(f, 'abc'))""" 3071 self.unchanged(a) 3072 a = """list(map(f, 'abc'))[0]""" 3073 self.unchanged(a) 3074 a = """set(map(f, 'abc'))""" 3075 self.unchanged(a) 3076 a = """set(map(f, 'abc')).pop()""" 3077 self.unchanged(a) 3078 a = """tuple(map(f, 'abc'))""" 3079 self.unchanged(a) 3080 a = """any(map(f, 'abc'))""" 3081 self.unchanged(a) 3082 a = """all(map(f, 'abc'))""" 3083 self.unchanged(a) 3084 a = """sum(map(f, 'abc'))""" 3085 self.unchanged(a) 3086 a = """sorted(map(f, 'abc'))""" 3087 self.unchanged(a) 3088 a = """sorted(map(f, 'abc'), key=blah)""" 3089 self.unchanged(a) 3090 a = """sorted(map(f, 'abc'), key=blah)[0]""" 3091 self.unchanged(a) 3092 a = """for i in map(f, 'abc'): pass""" 3093 self.unchanged(a) 3094 a = """[x for x in map(f, 'abc')]""" 3095 self.unchanged(a) 3096 a = """(x for x in map(f, 'abc'))""" 3097 self.unchanged(a) 3098 3099 def test_future_builtins(self): 3100 a = "from future_builtins import spam, map, eggs; map(f, 'ham')" 3101 self.unchanged(a) 3102 3103 b = """from future_builtins import spam, eggs; x = map(f, 'abc')""" 3104 a = """from future_builtins import spam, eggs; x = list(map(f, 'abc'))""" 3105 self.check(b, a) 3106 3107 a = "from future_builtins import *; map(f, 'ham')" 3108 self.unchanged(a) 3109 3110 class Test_zip(FixerTestCase): 3111 fixer = "zip" 3112 3113 def check(self, b, a): 3114 self.unchanged("from future_builtins import zip; " + b, a) 3115 super(Test_zip, self).check(b, a) 3116 3117 def test_zip_basic(self): 3118 b = """x = zip(a, b, c)""" 3119 a = """x = list(zip(a, b, c))""" 3120 self.check(b, a) 3121 3122 b = """x = len(zip(a, b))""" 3123 a = """x = len(list(zip(a, b)))""" 3124 self.check(b, a) 3125 3126 def test_zip_nochange(self): 3127 a = """b.join(zip(a, b))""" 3128 self.unchanged(a) 3129 a = """(a + foo(5)).join(zip(a, b))""" 3130 self.unchanged(a) 3131 a = """iter(zip(a, b))""" 3132 self.unchanged(a) 3133 a = """list(zip(a, b))""" 3134 self.unchanged(a) 3135 a = """list(zip(a, b))[0]""" 3136 self.unchanged(a) 3137 a = """set(zip(a, b))""" 3138 self.unchanged(a) 3139 a = """set(zip(a, b)).pop()""" 3140 self.unchanged(a) 3141 a = """tuple(zip(a, b))""" 3142 self.unchanged(a) 3143 a = """any(zip(a, b))""" 3144 self.unchanged(a) 3145 a = """all(zip(a, b))""" 3146 self.unchanged(a) 3147 a = """sum(zip(a, b))""" 3148 self.unchanged(a) 3149 a = """sorted(zip(a, b))""" 3150 self.unchanged(a) 3151 a = """sorted(zip(a, b), key=blah)""" 3152 self.unchanged(a) 3153 a = """sorted(zip(a, b), key=blah)[0]""" 3154 self.unchanged(a) 3155 a = """for i in zip(a, b): pass""" 3156 self.unchanged(a) 3157 a = """[x for x in zip(a, b)]""" 3158 self.unchanged(a) 3159 a = """(x for x in zip(a, b))""" 3160 self.unchanged(a) 3161 3162 def test_future_builtins(self): 3163 a = "from future_builtins import spam, zip, eggs; zip(a, b)" 3164 self.unchanged(a) 3165 3166 b = """from future_builtins import spam, eggs; x = zip(a, b)""" 3167 a = """from future_builtins import spam, eggs; x = list(zip(a, b))""" 3168 self.check(b, a) 3169 3170 a = "from future_builtins import *; zip(a, b)" 3171 self.unchanged(a) 3172 3173 class Test_standarderror(FixerTestCase): 3174 fixer = "standarderror" 3175 3176 def test(self): 3177 b = """x = StandardError()""" 3178 a = """x = Exception()""" 3179 self.check(b, a) 3180 3181 b = """x = StandardError(a, b, c)""" 3182 a = """x = Exception(a, b, c)""" 3183 self.check(b, a) 3184 3185 b = """f(2 + StandardError(a, b, c))""" 3186 a = """f(2 + Exception(a, b, c))""" 3187 self.check(b, a) 3188 3189 class Test_types(FixerTestCase): 3190 fixer = "types" 3191 3192 def test_basic_types_convert(self): 3193 b = """types.StringType""" 3194 a = """bytes""" 3195 self.check(b, a) 3196 3197 b = """types.DictType""" 3198 a = """dict""" 3199 self.check(b, a) 3200 3201 b = """types . IntType""" 3202 a = """int""" 3203 self.check(b, a) 3204 3205 b = """types.ListType""" 3206 a = """list""" 3207 self.check(b, a) 3208 3209 b = """types.LongType""" 3210 a = """int""" 3211 self.check(b, a) 3212 3213 b = """types.NoneType""" 3214 a = """type(None)""" 3215 self.check(b, a) 3216 3217 class Test_idioms(FixerTestCase): 3218 fixer = "idioms" 3219 3220 def test_while(self): 3221 b = """while 1: foo()""" 3222 a = """while True: foo()""" 3223 self.check(b, a) 3224 3225 b = """while 1: foo()""" 3226 a = """while True: foo()""" 3227 self.check(b, a) 3228 3229 b = """ 3230 while 1: 3231 foo() 3232 """ 3233 a = """ 3234 while True: 3235 foo() 3236 """ 3237 self.check(b, a) 3238 3239 def test_while_unchanged(self): 3240 s = """while 11: foo()""" 3241 self.unchanged(s) 3242 3243 s = """while 0: foo()""" 3244 self.unchanged(s) 3245 3246 s = """while foo(): foo()""" 3247 self.unchanged(s) 3248 3249 s = """while []: foo()""" 3250 self.unchanged(s) 3251 3252 def test_eq_simple(self): 3253 b = """type(x) == T""" 3254 a = """isinstance(x, T)""" 3255 self.check(b, a) 3256 3257 b = """if type(x) == T: pass""" 3258 a = """if isinstance(x, T): pass""" 3259 self.check(b, a) 3260 3261 def test_eq_reverse(self): 3262 b = """T == type(x)""" 3263 a = """isinstance(x, T)""" 3264 self.check(b, a) 3265 3266 b = """if T == type(x): pass""" 3267 a = """if isinstance(x, T): pass""" 3268 self.check(b, a) 3269 3270 def test_eq_expression(self): 3271 b = """type(x+y) == d.get('T')""" 3272 a = """isinstance(x+y, d.get('T'))""" 3273 self.check(b, a) 3274 3275 b = """type( x + y) == d.get('T')""" 3276 a = """isinstance(x + y, d.get('T'))""" 3277 self.check(b, a) 3278 3279 def test_is_simple(self): 3280 b = """type(x) is T""" 3281 a = """isinstance(x, T)""" 3282 self.check(b, a) 3283 3284 b = """if type(x) is T: pass""" 3285 a = """if isinstance(x, T): pass""" 3286 self.check(b, a) 3287 3288 def test_is_reverse(self): 3289 b = """T is type(x)""" 3290 a = """isinstance(x, T)""" 3291 self.check(b, a) 3292 3293 b = """if T is type(x): pass""" 3294 a = """if isinstance(x, T): pass""" 3295 self.check(b, a) 3296 3297 def test_is_expression(self): 3298 b = """type(x+y) is d.get('T')""" 3299 a = """isinstance(x+y, d.get('T'))""" 3300 self.check(b, a) 3301 3302 b = """type( x + y) is d.get('T')""" 3303 a = """isinstance(x + y, d.get('T'))""" 3304 self.check(b, a) 3305 3306 def test_is_not_simple(self): 3307 b = """type(x) is not T""" 3308 a = """not isinstance(x, T)""" 3309 self.check(b, a) 3310 3311 b = """if type(x) is not T: pass""" 3312 a = """if not isinstance(x, T): pass""" 3313 self.check(b, a) 3314 3315 def test_is_not_reverse(self): 3316 b = """T is not type(x)""" 3317 a = """not isinstance(x, T)""" 3318 self.check(b, a) 3319 3320 b = """if T is not type(x): pass""" 3321 a = """if not isinstance(x, T): pass""" 3322 self.check(b, a) 3323 3324 def test_is_not_expression(self): 3325 b = """type(x+y) is not d.get('T')""" 3326 a = """not isinstance(x+y, d.get('T'))""" 3327 self.check(b, a) 3328 3329 b = """type( x + y) is not d.get('T')""" 3330 a = """not isinstance(x + y, d.get('T'))""" 3331 self.check(b, a) 3332 3333 def test_ne_simple(self): 3334 b = """type(x) != T""" 3335 a = """not isinstance(x, T)""" 3336 self.check(b, a) 3337 3338 b = """if type(x) != T: pass""" 3339 a = """if not isinstance(x, T): pass""" 3340 self.check(b, a) 3341 3342 def test_ne_reverse(self): 3343 b = """T != type(x)""" 3344 a = """not isinstance(x, T)""" 3345 self.check(b, a) 3346 3347 b = """if T != type(x): pass""" 3348 a = """if not isinstance(x, T): pass""" 3349 self.check(b, a) 3350 3351 def test_ne_expression(self): 3352 b = """type(x+y) != d.get('T')""" 3353 a = """not isinstance(x+y, d.get('T'))""" 3354 self.check(b, a) 3355 3356 b = """type( x + y) != d.get('T')""" 3357 a = """not isinstance(x + y, d.get('T'))""" 3358 self.check(b, a) 3359 3360 def test_type_unchanged(self): 3361 a = """type(x).__name__""" 3362 self.unchanged(a) 3363 3364 def test_sort_list_call(self): 3365 b = """ 3366 v = list(t) 3367 v.sort() 3368 foo(v) 3369 """ 3370 a = """ 3371 v = sorted(t) 3372 foo(v) 3373 """ 3374 self.check(b, a) 3375 3376 b = """ 3377 v = list(foo(b) + d) 3378 v.sort() 3379 foo(v) 3380 """ 3381 a = """ 3382 v = sorted(foo(b) + d) 3383 foo(v) 3384 """ 3385 self.check(b, a) 3386 3387 b = """ 3388 while x: 3389 v = list(t) 3390 v.sort() 3391 foo(v) 3392 """ 3393 a = """ 3394 while x: 3395 v = sorted(t) 3396 foo(v) 3397 """ 3398 self.check(b, a) 3399 3400 b = """ 3401 v = list(t) 3402 # foo 3403 v.sort() 3404 foo(v) 3405 """ 3406 a = """ 3407 v = sorted(t) 3408 # foo 3409 foo(v) 3410 """ 3411 self.check(b, a) 3412 3413 b = r""" 3414 v = list( t) 3415 v.sort() 3416 foo(v) 3417 """ 3418 a = r""" 3419 v = sorted( t) 3420 foo(v) 3421 """ 3422 self.check(b, a) 3423 3424 b = r""" 3425 try: 3426 m = list(s) 3427 m.sort() 3428 except: pass 3429 """ 3430 3431 a = r""" 3432 try: 3433 m = sorted(s) 3434 except: pass 3435 """ 3436 self.check(b, a) 3437 3438 b = r""" 3439 try: 3440 m = list(s) 3441 # foo 3442 m.sort() 3443 except: pass 3444 """ 3445 3446 a = r""" 3447 try: 3448 m = sorted(s) 3449 # foo 3450 except: pass 3451 """ 3452 self.check(b, a) 3453 3454 b = r""" 3455 m = list(s) 3456 # more comments 3457 m.sort()""" 3458 3459 a = r""" 3460 m = sorted(s) 3461 # more comments""" 3462 self.check(b, a) 3463 3464 def test_sort_simple_expr(self): 3465 b = """ 3466 v = t 3467 v.sort() 3468 foo(v) 3469 """ 3470 a = """ 3471 v = sorted(t) 3472 foo(v) 3473 """ 3474 self.check(b, a) 3475 3476 b = """ 3477 v = foo(b) 3478 v.sort() 3479 foo(v) 3480 """ 3481 a = """ 3482 v = sorted(foo(b)) 3483 foo(v) 3484 """ 3485 self.check(b, a) 3486 3487 b = """ 3488 v = b.keys() 3489 v.sort() 3490 foo(v) 3491 """ 3492 a = """ 3493 v = sorted(b.keys()) 3494 foo(v) 3495 """ 3496 self.check(b, a) 3497 3498 b = """ 3499 v = foo(b) + d 3500 v.sort() 3501 foo(v) 3502 """ 3503 a = """ 3504 v = sorted(foo(b) + d) 3505 foo(v) 3506 """ 3507 self.check(b, a) 3508 3509 b = """ 3510 while x: 3511 v = t 3512 v.sort() 3513 foo(v) 3514 """ 3515 a = """ 3516 while x: 3517 v = sorted(t) 3518 foo(v) 3519 """ 3520 self.check(b, a) 3521 3522 b = """ 3523 v = t 3524 # foo 3525 v.sort() 3526 foo(v) 3527 """ 3528 a = """ 3529 v = sorted(t) 3530 # foo 3531 foo(v) 3532 """ 3533 self.check(b, a) 3534 3535 b = r""" 3536 v = t 3537 v.sort() 3538 foo(v) 3539 """ 3540 a = r""" 3541 v = sorted(t) 3542 foo(v) 3543 """ 3544 self.check(b, a) 3545 3546 def test_sort_unchanged(self): 3547 s = """ 3548 v = list(t) 3549 w.sort() 3550 foo(w) 3551 """ 3552 self.unchanged(s) 3553 3554 s = """ 3555 v = list(t) 3556 v.sort(u) 3557 foo(v) 3558 """ 3559 self.unchanged(s) 3560 3561 class Test_basestring(FixerTestCase): 3562 fixer = "basestring" 3563 3564 def test_basestring(self): 3565 b = """isinstance(x, basestring)""" 3566 a = """isinstance(x, str)""" 3567 self.check(b, a) 3568 3569 class Test_buffer(FixerTestCase): 3570 fixer = "buffer" 3571 3572 def test_buffer(self): 3573 b = """x = buffer(y)""" 3574 a = """x = memoryview(y)""" 3575 self.check(b, a) 3576 3577 def test_slicing(self): 3578 b = """buffer(y)[4:5]""" 3579 a = """memoryview(y)[4:5]""" 3580 self.check(b, a) 3581 3582 class Test_future(FixerTestCase): 3583 fixer = "future" 3584 3585 def test_future(self): 3586 b = """from __future__ import braces""" 3587 a = """""" 3588 self.check(b, a) 3589 3590 b = """# comment\nfrom __future__ import braces""" 3591 a = """# comment\n""" 3592 self.check(b, a) 3593 3594 b = """from __future__ import braces\n# comment""" 3595 a = """\n# comment""" 3596 self.check(b, a) 3597 3598 def test_run_order(self): 3599 self.assert_runs_after('print') 3600 3601 class Test_itertools(FixerTestCase): 3602 fixer = "itertools" 3603 3604 def checkall(self, before, after): 3605 # Because we need to check with and without the itertools prefix 3606 # and on each of the three functions, these loops make it all 3607 # much easier 3608 for i in ('itertools.', ''): 3609 for f in ('map', 'filter', 'zip'): 3610 b = before %(i+'i'+f) 3611 a = after %(f) 3612 self.check(b, a) 3613 3614 def test_0(self): 3615 # A simple example -- test_1 covers exactly the same thing, 3616 # but it's not quite as clear. 3617 b = "itertools.izip(a, b)" 3618 a = "zip(a, b)" 3619 self.check(b, a) 3620 3621 def test_1(self): 3622 b = """%s(f, a)""" 3623 a = """%s(f, a)""" 3624 self.checkall(b, a) 3625 3626 def test_qualified(self): 3627 b = """itertools.ifilterfalse(a, b)""" 3628 a = """itertools.filterfalse(a, b)""" 3629 self.check(b, a) 3630 3631 b = """itertools.izip_longest(a, b)""" 3632 a = """itertools.zip_longest(a, b)""" 3633 self.check(b, a) 3634 3635 def test_2(self): 3636 b = """ifilterfalse(a, b)""" 3637 a = """filterfalse(a, b)""" 3638 self.check(b, a) 3639 3640 b = """izip_longest(a, b)""" 3641 a = """zip_longest(a, b)""" 3642 self.check(b, a) 3643 3644 def test_space_1(self): 3645 b = """ %s(f, a)""" 3646 a = """ %s(f, a)""" 3647 self.checkall(b, a) 3648 3649 def test_space_2(self): 3650 b = """ itertools.ifilterfalse(a, b)""" 3651 a = """ itertools.filterfalse(a, b)""" 3652 self.check(b, a) 3653 3654 b = """ itertools.izip_longest(a, b)""" 3655 a = """ itertools.zip_longest(a, b)""" 3656 self.check(b, a) 3657 3658 def test_run_order(self): 3659 self.assert_runs_after('map', 'zip', 'filter') 3660 3661 3662 class Test_itertools_imports(FixerTestCase): 3663 fixer = 'itertools_imports' 3664 3665 def test_reduced(self): 3666 b = "from itertools import imap, izip, foo" 3667 a = "from itertools import foo" 3668 self.check(b, a) 3669 3670 b = "from itertools import bar, imap, izip, foo" 3671 a = "from itertools import bar, foo" 3672 self.check(b, a) 3673 3674 b = "from itertools import chain, imap, izip" 3675 a = "from itertools import chain" 3676 self.check(b, a) 3677 3678 def test_comments(self): 3679 b = "#foo\nfrom itertools import imap, izip" 3680 a = "#foo\n" 3681 self.check(b, a) 3682 3683 def test_none(self): 3684 b = "from itertools import imap, izip" 3685 a = "" 3686 self.check(b, a) 3687 3688 b = "from itertools import izip" 3689 a = "" 3690 self.check(b, a) 3691 3692 def test_import_as(self): 3693 b = "from itertools import izip, bar as bang, imap" 3694 a = "from itertools import bar as bang" 3695 self.check(b, a) 3696 3697 b = "from itertools import izip as _zip, imap, bar" 3698 a = "from itertools import bar" 3699 self.check(b, a) 3700 3701 b = "from itertools import imap as _map" 3702 a = "" 3703 self.check(b, a) 3704 3705 b = "from itertools import imap as _map, izip as _zip" 3706 a = "" 3707 self.check(b, a) 3708 3709 s = "from itertools import bar as bang" 3710 self.unchanged(s) 3711 3712 def test_ifilter_and_zip_longest(self): 3713 for name in "filterfalse", "zip_longest": 3714 b = "from itertools import i%s" % (name,) 3715 a = "from itertools import %s" % (name,) 3716 self.check(b, a) 3717 3718 b = "from itertools import imap, i%s, foo" % (name,) 3719 a = "from itertools import %s, foo" % (name,) 3720 self.check(b, a) 3721 3722 b = "from itertools import bar, i%s, foo" % (name,) 3723 a = "from itertools import bar, %s, foo" % (name,) 3724 self.check(b, a) 3725 3726 def test_import_star(self): 3727 s = "from itertools import *" 3728 self.unchanged(s) 3729 3730 3731 def test_unchanged(self): 3732 s = "from itertools import foo" 3733 self.unchanged(s) 3734 3735 3736 class Test_import(FixerTestCase): 3737 fixer = "import" 3738 3739 def setUp(self): 3740 super(Test_import, self).setUp() 3741 # Need to replace fix_import's exists method 3742 # so we can check that it's doing the right thing 3743 self.files_checked = [] 3744 self.present_files = set() 3745 self.always_exists = True 3746 def fake_exists(name): 3747 self.files_checked.append(name) 3748 return self.always_exists or (name in self.present_files) 3749 3750 from lib2to3.fixes import fix_import 3751 fix_import.exists = fake_exists 3752 3753 def tearDown(self): 3754 from lib2to3.fixes import fix_import 3755 fix_import.exists = os.path.exists 3756 3757 def check_both(self, b, a): 3758 self.always_exists = True 3759 super(Test_import, self).check(b, a) 3760 self.always_exists = False 3761 super(Test_import, self).unchanged(b) 3762 3763 def test_files_checked(self): 3764 def p(path): 3765 # Takes a unix path and returns a path with correct separators 3766 return os.path.pathsep.join(path.split("/")) 3767 3768 self.always_exists = False 3769 self.present_files = set(['__init__.py']) 3770 expected_extensions = ('.py', os.path.sep, '.pyc', '.so', '.sl', '.pyd') 3771 names_to_test = (p("/spam/eggs.py"), "ni.py", p("../../shrubbery.py")) 3772 3773 for name in names_to_test: 3774 self.files_checked = [] 3775 self.filename = name 3776 self.unchanged("import jam") 3777 3778 if os.path.dirname(name): 3779 name = os.path.dirname(name) + '/jam' 3780 else: 3781 name = 'jam' 3782 expected_checks = set(name + ext for ext in expected_extensions) 3783 expected_checks.add("__init__.py") 3784 3785 self.assertEqual(set(self.files_checked), expected_checks) 3786 3787 def test_not_in_package(self): 3788 s = "import bar" 3789 self.always_exists = False 3790 self.present_files = set(["bar.py"]) 3791 self.unchanged(s) 3792 3793 def test_with_absolute_import_enabled(self): 3794 s = "from __future__ import absolute_import\nimport bar" 3795 self.always_exists = False 3796 self.present_files = set(["__init__.py", "bar.py"]) 3797 self.unchanged(s) 3798 3799 def test_in_package(self): 3800 b = "import bar" 3801 a = "from . import bar" 3802 self.always_exists = False 3803 self.present_files = set(["__init__.py", "bar.py"]) 3804 self.check(b, a) 3805 3806 def test_import_from_package(self): 3807 b = "import bar" 3808 a = "from . import bar" 3809 self.always_exists = False 3810 self.present_files = set(["__init__.py", "bar" + os.path.sep]) 3811 self.check(b, a) 3812 3813 def test_already_relative_import(self): 3814 s = "from . import bar" 3815 self.unchanged(s) 3816 3817 def test_comments_and_indent(self): 3818 b = "import bar # Foo" 3819 a = "from . import bar # Foo" 3820 self.check(b, a) 3821 3822 def test_from(self): 3823 b = "from foo import bar, baz" 3824 a = "from .foo import bar, baz" 3825 self.check_both(b, a) 3826 3827 b = "from foo import bar" 3828 a = "from .foo import bar" 3829 self.check_both(b, a) 3830 3831 b = "from foo import (bar, baz)" 3832 a = "from .foo import (bar, baz)" 3833 self.check_both(b, a) 3834 3835 def test_dotted_from(self): 3836 b = "from green.eggs import ham" 3837 a = "from .green.eggs import ham" 3838 self.check_both(b, a) 3839 3840 def test_from_as(self): 3841 b = "from green.eggs import ham as spam" 3842 a = "from .green.eggs import ham as spam" 3843 self.check_both(b, a) 3844 3845 def test_import(self): 3846 b = "import foo" 3847 a = "from . import foo" 3848 self.check_both(b, a) 3849 3850 b = "import foo, bar" 3851 a = "from . import foo, bar" 3852 self.check_both(b, a) 3853 3854 b = "import foo, bar, x" 3855 a = "from . import foo, bar, x" 3856 self.check_both(b, a) 3857 3858 b = "import x, y, z" 3859 a = "from . import x, y, z" 3860 self.check_both(b, a) 3861 3862 def test_import_as(self): 3863 b = "import foo as x" 3864 a = "from . import foo as x" 3865 self.check_both(b, a) 3866 3867 b = "import a as b, b as c, c as d" 3868 a = "from . import a as b, b as c, c as d" 3869 self.check_both(b, a) 3870 3871 def test_local_and_absolute(self): 3872 self.always_exists = False 3873 self.present_files = set(["foo.py", "__init__.py"]) 3874 3875 s = "import foo, bar" 3876 self.warns_unchanged(s, "absolute and local imports together") 3877 3878 def test_dotted_import(self): 3879 b = "import foo.bar" 3880 a = "from . import foo.bar" 3881 self.check_both(b, a) 3882 3883 def test_dotted_import_as(self): 3884 b = "import foo.bar as bang" 3885 a = "from . import foo.bar as bang" 3886 self.check_both(b, a) 3887 3888 def test_prefix(self): 3889 b = """ 3890 # prefix 3891 import foo.bar 3892 """ 3893 a = """ 3894 # prefix 3895 from . import foo.bar 3896 """ 3897 self.check_both(b, a) 3898 3899 3900 class Test_set_literal(FixerTestCase): 3901 3902 fixer = "set_literal" 3903 3904 def test_basic(self): 3905 b = """set([1, 2, 3])""" 3906 a = """{1, 2, 3}""" 3907 self.check(b, a) 3908 3909 b = """set((1, 2, 3))""" 3910 a = """{1, 2, 3}""" 3911 self.check(b, a) 3912 3913 b = """set((1,))""" 3914 a = """{1}""" 3915 self.check(b, a) 3916 3917 b = """set([1])""" 3918 self.check(b, a) 3919 3920 b = """set((a, b))""" 3921 a = """{a, b}""" 3922 self.check(b, a) 3923 3924 b = """set([a, b])""" 3925 self.check(b, a) 3926 3927 b = """set((a*234, f(args=23)))""" 3928 a = """{a*234, f(args=23)}""" 3929 self.check(b, a) 3930 3931 b = """set([a*23, f(23)])""" 3932 a = """{a*23, f(23)}""" 3933 self.check(b, a) 3934 3935 b = """set([a-234**23])""" 3936 a = """{a-234**23}""" 3937 self.check(b, a) 3938 3939 def test_listcomps(self): 3940 b = """set([x for x in y])""" 3941 a = """{x for x in y}""" 3942 self.check(b, a) 3943 3944 b = """set([x for x in y if x == m])""" 3945 a = """{x for x in y if x == m}""" 3946 self.check(b, a) 3947 3948 b = """set([x for x in y for a in b])""" 3949 a = """{x for x in y for a in b}""" 3950 self.check(b, a) 3951 3952 b = """set([f(x) - 23 for x in y])""" 3953 a = """{f(x) - 23 for x in y}""" 3954 self.check(b, a) 3955 3956 def test_whitespace(self): 3957 b = """set( [1, 2])""" 3958 a = """{1, 2}""" 3959 self.check(b, a) 3960 3961 b = """set([1 , 2])""" 3962 a = """{1 , 2}""" 3963 self.check(b, a) 3964 3965 b = """set([ 1 ])""" 3966 a = """{ 1 }""" 3967 self.check(b, a) 3968 3969 b = """set( [1] )""" 3970 a = """{1}""" 3971 self.check(b, a) 3972 3973 b = """set([ 1, 2 ])""" 3974 a = """{ 1, 2 }""" 3975 self.check(b, a) 3976 3977 b = """set([x for x in y ])""" 3978 a = """{x for x in y }""" 3979 self.check(b, a) 3980 3981 b = """set( 3982 [1, 2] 3983 ) 3984 """ 3985 a = """{1, 2}\n""" 3986 self.check(b, a) 3987 3988 def test_comments(self): 3989 b = """set((1, 2)) # Hi""" 3990 a = """{1, 2} # Hi""" 3991 self.check(b, a) 3992 3993 # This isn't optimal behavior, but the fixer is optional. 3994 b = """ 3995 # Foo 3996 set( # Bar 3997 (1, 2) 3998 ) 3999 """ 4000 a = """ 4001 # Foo 4002 {1, 2} 4003 """ 4004 self.check(b, a) 4005 4006 def test_unchanged(self): 4007 s = """set()""" 4008 self.unchanged(s) 4009 4010 s = """set(a)""" 4011 self.unchanged(s) 4012 4013 s = """set(a, b, c)""" 4014 self.unchanged(s) 4015 4016 # Don't transform generators because they might have to be lazy. 4017 s = """set(x for x in y)""" 4018 self.unchanged(s) 4019 4020 s = """set(x for x in y if z)""" 4021 self.unchanged(s) 4022 4023 s = """set(a*823-23**2 + f(23))""" 4024 self.unchanged(s) 4025 4026 4027 class Test_sys_exc(FixerTestCase): 4028 fixer = "sys_exc" 4029 4030 def test_0(self): 4031 b = "sys.exc_type" 4032 a = "sys.exc_info()[0]" 4033 self.check(b, a) 4034 4035 def test_1(self): 4036 b = "sys.exc_value" 4037 a = "sys.exc_info()[1]" 4038 self.check(b, a) 4039 4040 def test_2(self): 4041 b = "sys.exc_traceback" 4042 a = "sys.exc_info()[2]" 4043 self.check(b, a) 4044 4045 def test_3(self): 4046 b = "sys.exc_type # Foo" 4047 a = "sys.exc_info()[0] # Foo" 4048 self.check(b, a) 4049 4050 def test_4(self): 4051 b = "sys. exc_type" 4052 a = "sys. exc_info()[0]" 4053 self.check(b, a) 4054 4055 def test_5(self): 4056 b = "sys .exc_type" 4057 a = "sys .exc_info()[0]" 4058 self.check(b, a) 4059 4060 4061 class Test_paren(FixerTestCase): 4062 fixer = "paren" 4063 4064 def test_0(self): 4065 b = """[i for i in 1, 2 ]""" 4066 a = """[i for i in (1, 2) ]""" 4067 self.check(b, a) 4068 4069 def test_1(self): 4070 b = """[i for i in 1, 2, ]""" 4071 a = """[i for i in (1, 2,) ]""" 4072 self.check(b, a) 4073 4074 def test_2(self): 4075 b = """[i for i in 1, 2 ]""" 4076 a = """[i for i in (1, 2) ]""" 4077 self.check(b, a) 4078 4079 def test_3(self): 4080 b = """[i for i in 1, 2 if i]""" 4081 a = """[i for i in (1, 2) if i]""" 4082 self.check(b, a) 4083 4084 def test_4(self): 4085 b = """[i for i in 1, 2 ]""" 4086 a = """[i for i in (1, 2) ]""" 4087 self.check(b, a) 4088 4089 def test_5(self): 4090 b = """(i for i in 1, 2)""" 4091 a = """(i for i in (1, 2))""" 4092 self.check(b, a) 4093 4094 def test_6(self): 4095 b = """(i for i in 1 ,2 if i)""" 4096 a = """(i for i in (1 ,2) if i)""" 4097 self.check(b, a) 4098 4099 def test_unchanged_0(self): 4100 s = """[i for i in (1, 2)]""" 4101 self.unchanged(s) 4102 4103 def test_unchanged_1(self): 4104 s = """[i for i in foo()]""" 4105 self.unchanged(s) 4106 4107 def test_unchanged_2(self): 4108 s = """[i for i in (1, 2) if nothing]""" 4109 self.unchanged(s) 4110 4111 def test_unchanged_3(self): 4112 s = """(i for i in (1, 2))""" 4113 self.unchanged(s) 4114 4115 def test_unchanged_4(self): 4116 s = """[i for i in m]""" 4117 self.unchanged(s) 4118 4119 class Test_metaclass(FixerTestCase): 4120 4121 fixer = 'metaclass' 4122 4123 def test_unchanged(self): 4124 self.unchanged("class X(): pass") 4125 self.unchanged("class X(object): pass") 4126 self.unchanged("class X(object1, object2): pass") 4127 self.unchanged("class X(object1, object2, object3): pass") 4128 self.unchanged("class X(metaclass=Meta): pass") 4129 self.unchanged("class X(b, arg=23, metclass=Meta): pass") 4130 self.unchanged("class X(b, arg=23, metaclass=Meta, other=42): pass") 4131 4132 s = """ 4133 class X: 4134 def __metaclass__(self): pass 4135 """ 4136 self.unchanged(s) 4137 4138 s = """ 4139 class X: 4140 a[23] = 74 4141 """ 4142 self.unchanged(s) 4143 4144 def test_comments(self): 4145 b = """ 4146 class X: 4147 # hi 4148 __metaclass__ = AppleMeta 4149 """ 4150 a = """ 4151 class X(metaclass=AppleMeta): 4152 # hi 4153 pass 4154 """ 4155 self.check(b, a) 4156 4157 b = """ 4158 class X: 4159 __metaclass__ = Meta 4160 # Bedtime! 4161 """ 4162 a = """ 4163 class X(metaclass=Meta): 4164 pass 4165 # Bedtime! 4166 """ 4167 self.check(b, a) 4168 4169 def test_meta(self): 4170 # no-parent class, odd body 4171 b = """ 4172 class X(): 4173 __metaclass__ = Q 4174 pass 4175 """ 4176 a = """ 4177 class X(metaclass=Q): 4178 pass 4179 """ 4180 self.check(b, a) 4181 4182 # one parent class, no body 4183 b = """class X(object): __metaclass__ = Q""" 4184 a = """class X(object, metaclass=Q): pass""" 4185 self.check(b, a) 4186 4187 4188 # one parent, simple body 4189 b = """ 4190 class X(object): 4191 __metaclass__ = Meta 4192 bar = 7 4193 """ 4194 a = """ 4195 class X(object, metaclass=Meta): 4196 bar = 7 4197 """ 4198 self.check(b, a) 4199 4200 b = """ 4201 class X: 4202 __metaclass__ = Meta; x = 4; g = 23 4203 """ 4204 a = """ 4205 class X(metaclass=Meta): 4206 x = 4; g = 23 4207 """ 4208 self.check(b, a) 4209 4210 # one parent, simple body, __metaclass__ last 4211 b = """ 4212 class X(object): 4213 bar = 7 4214 __metaclass__ = Meta 4215 """ 4216 a = """ 4217 class X(object, metaclass=Meta): 4218 bar = 7 4219 """ 4220 self.check(b, a) 4221 4222 # redefining __metaclass__ 4223 b = """ 4224 class X(): 4225 __metaclass__ = A 4226 __metaclass__ = B 4227 bar = 7 4228 """ 4229 a = """ 4230 class X(metaclass=B): 4231 bar = 7 4232 """ 4233 self.check(b, a) 4234 4235 # multiple inheritance, simple body 4236 b = """ 4237 class X(clsA, clsB): 4238 __metaclass__ = Meta 4239 bar = 7 4240 """ 4241 a = """ 4242 class X(clsA, clsB, metaclass=Meta): 4243 bar = 7 4244 """ 4245 self.check(b, a) 4246 4247 # keywords in the class statement 4248 b = """class m(a, arg=23): __metaclass__ = Meta""" 4249 a = """class m(a, arg=23, metaclass=Meta): pass""" 4250 self.check(b, a) 4251 4252 b = """ 4253 class X(expression(2 + 4)): 4254 __metaclass__ = Meta 4255 """ 4256 a = """ 4257 class X(expression(2 + 4), metaclass=Meta): 4258 pass 4259 """ 4260 self.check(b, a) 4261 4262 b = """ 4263 class X(expression(2 + 4), x**4): 4264 __metaclass__ = Meta 4265 """ 4266 a = """ 4267 class X(expression(2 + 4), x**4, metaclass=Meta): 4268 pass 4269 """ 4270 self.check(b, a) 4271 4272 b = """ 4273 class X: 4274 __metaclass__ = Meta 4275 save.py = 23 4276 """ 4277 a = """ 4278 class X(metaclass=Meta): 4279 save.py = 23 4280 """ 4281 self.check(b, a) 4282 4283 4284 class Test_getcwdu(FixerTestCase): 4285 4286 fixer = 'getcwdu' 4287 4288 def test_basic(self): 4289 b = """os.getcwdu""" 4290 a = """os.getcwd""" 4291 self.check(b, a) 4292 4293 b = """os.getcwdu()""" 4294 a = """os.getcwd()""" 4295 self.check(b, a) 4296 4297 b = """meth = os.getcwdu""" 4298 a = """meth = os.getcwd""" 4299 self.check(b, a) 4300 4301 b = """os.getcwdu(args)""" 4302 a = """os.getcwd(args)""" 4303 self.check(b, a) 4304 4305 def test_comment(self): 4306 b = """os.getcwdu() # Foo""" 4307 a = """os.getcwd() # Foo""" 4308 self.check(b, a) 4309 4310 def test_unchanged(self): 4311 s = """os.getcwd()""" 4312 self.unchanged(s) 4313 4314 s = """getcwdu()""" 4315 self.unchanged(s) 4316 4317 s = """os.getcwdb()""" 4318 self.unchanged(s) 4319 4320 def test_indentation(self): 4321 b = """ 4322 if 1: 4323 os.getcwdu() 4324 """ 4325 a = """ 4326 if 1: 4327 os.getcwd() 4328 """ 4329 self.check(b, a) 4330 4331 def test_multilation(self): 4332 b = """os .getcwdu()""" 4333 a = """os .getcwd()""" 4334 self.check(b, a) 4335 4336 b = """os. getcwdu""" 4337 a = """os. getcwd""" 4338 self.check(b, a) 4339 4340 b = """os.getcwdu ( )""" 4341 a = """os.getcwd ( )""" 4342 self.check(b, a) 4343 4344 4345 class Test_operator(FixerTestCase): 4346 4347 fixer = "operator" 4348 4349 def test_operator_isCallable(self): 4350 b = "operator.isCallable(x)" 4351 a = "hasattr(x, '__call__')" 4352 self.check(b, a) 4353 4354 def test_operator_sequenceIncludes(self): 4355 b = "operator.sequenceIncludes(x, y)" 4356 a = "operator.contains(x, y)" 4357 self.check(b, a) 4358 4359 b = "operator .sequenceIncludes(x, y)" 4360 a = "operator .contains(x, y)" 4361 self.check(b, a) 4362 4363 b = "operator. sequenceIncludes(x, y)" 4364 a = "operator. contains(x, y)" 4365 self.check(b, a) 4366 4367 def test_operator_isSequenceType(self): 4368 b = "operator.isSequenceType(x)" 4369 a = "import collections\nisinstance(x, collections.Sequence)" 4370 self.check(b, a) 4371 4372 def test_operator_isMappingType(self): 4373 b = "operator.isMappingType(x)" 4374 a = "import collections\nisinstance(x, collections.Mapping)" 4375 self.check(b, a) 4376 4377 def test_operator_isNumberType(self): 4378 b = "operator.isNumberType(x)" 4379 a = "import numbers\nisinstance(x, numbers.Number)" 4380 self.check(b, a) 4381 4382 def test_operator_repeat(self): 4383 b = "operator.repeat(x, n)" 4384 a = "operator.mul(x, n)" 4385 self.check(b, a) 4386 4387 b = "operator .repeat(x, n)" 4388 a = "operator .mul(x, n)" 4389 self.check(b, a) 4390 4391 b = "operator. repeat(x, n)" 4392 a = "operator. mul(x, n)" 4393 self.check(b, a) 4394 4395 def test_operator_irepeat(self): 4396 b = "operator.irepeat(x, n)" 4397 a = "operator.imul(x, n)" 4398 self.check(b, a) 4399 4400 b = "operator .irepeat(x, n)" 4401 a = "operator .imul(x, n)" 4402 self.check(b, a) 4403 4404 b = "operator. irepeat(x, n)" 4405 a = "operator. imul(x, n)" 4406 self.check(b, a) 4407 4408 def test_bare_isCallable(self): 4409 s = "isCallable(x)" 4410 t = "You should use 'hasattr(x, '__call__')' here." 4411 self.warns_unchanged(s, t) 4412 4413 def test_bare_sequenceIncludes(self): 4414 s = "sequenceIncludes(x, y)" 4415 t = "You should use 'operator.contains(x, y)' here." 4416 self.warns_unchanged(s, t) 4417 4418 def test_bare_operator_isSequenceType(self): 4419 s = "isSequenceType(z)" 4420 t = "You should use 'isinstance(z, collections.Sequence)' here." 4421 self.warns_unchanged(s, t) 4422 4423 def test_bare_operator_isMappingType(self): 4424 s = "isMappingType(x)" 4425 t = "You should use 'isinstance(x, collections.Mapping)' here." 4426 self.warns_unchanged(s, t) 4427 4428 def test_bare_operator_isNumberType(self): 4429 s = "isNumberType(y)" 4430 t = "You should use 'isinstance(y, numbers.Number)' here." 4431 self.warns_unchanged(s, t) 4432 4433 def test_bare_operator_repeat(self): 4434 s = "repeat(x, n)" 4435 t = "You should use 'operator.mul(x, n)' here." 4436 self.warns_unchanged(s, t) 4437 4438 def test_bare_operator_irepeat(self): 4439 s = "irepeat(y, 187)" 4440 t = "You should use 'operator.imul(y, 187)' here." 4441 self.warns_unchanged(s, t) 4442 4443 4444 class Test_exitfunc(FixerTestCase): 4445 4446 fixer = "exitfunc" 4447 4448 def test_simple(self): 4449 b = """ 4450 import sys 4451 sys.exitfunc = my_atexit 4452 """ 4453 a = """ 4454 import sys 4455 import atexit 4456 atexit.register(my_atexit) 4457 """ 4458 self.check(b, a) 4459 4460 def test_names_import(self): 4461 b = """ 4462 import sys, crumbs 4463 sys.exitfunc = my_func 4464 """ 4465 a = """ 4466 import sys, crumbs, atexit 4467 atexit.register(my_func) 4468 """ 4469 self.check(b, a) 4470 4471 def test_complex_expression(self): 4472 b = """ 4473 import sys 4474 sys.exitfunc = do(d)/a()+complex(f=23, g=23)*expression 4475 """ 4476 a = """ 4477 import sys 4478 import atexit 4479 atexit.register(do(d)/a()+complex(f=23, g=23)*expression) 4480 """ 4481 self.check(b, a) 4482 4483 def test_comments(self): 4484 b = """ 4485 import sys # Foo 4486 sys.exitfunc = f # Blah 4487 """ 4488 a = """ 4489 import sys 4490 import atexit # Foo 4491 atexit.register(f) # Blah 4492 """ 4493 self.check(b, a) 4494 4495 b = """ 4496 import apples, sys, crumbs, larry # Pleasant comments 4497 sys.exitfunc = func 4498 """ 4499 a = """ 4500 import apples, sys, crumbs, larry, atexit # Pleasant comments 4501 atexit.register(func) 4502 """ 4503 self.check(b, a) 4504 4505 def test_in_a_function(self): 4506 b = """ 4507 import sys 4508 def f(): 4509 sys.exitfunc = func 4510 """ 4511 a = """ 4512 import sys 4513 import atexit 4514 def f(): 4515 atexit.register(func) 4516 """ 4517 self.check(b, a) 4518 4519 def test_no_sys_import(self): 4520 b = """sys.exitfunc = f""" 4521 a = """atexit.register(f)""" 4522 msg = ("Can't find sys import; Please add an atexit import at the " 4523 "top of your file.") 4524 self.warns(b, a, msg) 4525 4526 4527 def test_unchanged(self): 4528 s = """f(sys.exitfunc)""" 4529 self.unchanged(s) 4530
