/Lib/lib2to3/tests/test_util.py

http://unladen-swallow.googlecode.com/ · Python · 559 lines · 461 code · 84 blank · 14 comment · 8 complexity · 34b1ab2a57dada2c15c0b151b66ad03f MD5 · raw file

  1. #!/usr/bin/env python2.5
  2. """ Test suite for the code in fixes.util """
  3. # Author: Collin Winter
  4. # Testing imports
  5. from . import support
  6. # Python imports
  7. import os.path
  8. # Local imports
  9. from .. import pytree
  10. from .. import fixer_util
  11. from ..fixer_util import Attr, Name
  12. def parse(code, strip_levels=0):
  13. # The topmost node is file_input, which we don't care about.
  14. # The next-topmost node is a *_stmt node, which we also don't care about
  15. tree = support.parse_string(code)
  16. for i in range(strip_levels):
  17. tree = tree.children[0]
  18. tree.parent = None
  19. return tree
  20. class MacroTestCase(support.TestCase):
  21. def assertStr(self, node, string):
  22. if isinstance(node, (tuple, list)):
  23. node = pytree.Node(fixer_util.syms.simple_stmt, node)
  24. self.assertEqual(str(node), string)
  25. class Test_is_tuple(support.TestCase):
  26. def is_tuple(self, string):
  27. return fixer_util.is_tuple(parse(string, strip_levels=2))
  28. def test_valid(self):
  29. self.failUnless(self.is_tuple("(a, b)"))
  30. self.failUnless(self.is_tuple("(a, (b, c))"))
  31. self.failUnless(self.is_tuple("((a, (b, c)),)"))
  32. self.failUnless(self.is_tuple("(a,)"))
  33. self.failUnless(self.is_tuple("()"))
  34. def test_invalid(self):
  35. self.failIf(self.is_tuple("(a)"))
  36. self.failIf(self.is_tuple("('foo') % (b, c)"))
  37. class Test_is_list(support.TestCase):
  38. def is_list(self, string):
  39. return fixer_util.is_list(parse(string, strip_levels=2))
  40. def test_valid(self):
  41. self.failUnless(self.is_list("[]"))
  42. self.failUnless(self.is_list("[a]"))
  43. self.failUnless(self.is_list("[a, b]"))
  44. self.failUnless(self.is_list("[a, [b, c]]"))
  45. self.failUnless(self.is_list("[[a, [b, c]],]"))
  46. def test_invalid(self):
  47. self.failIf(self.is_list("[]+[]"))
  48. class Test_Attr(MacroTestCase):
  49. def test(self):
  50. call = parse("foo()", strip_levels=2)
  51. self.assertStr(Attr(Name("a"), Name("b")), "a.b")
  52. self.assertStr(Attr(call, Name("b")), "foo().b")
  53. def test_returns(self):
  54. attr = Attr(Name("a"), Name("b"))
  55. self.assertEqual(type(attr), list)
  56. class Test_Name(MacroTestCase):
  57. def test(self):
  58. self.assertStr(Name("a"), "a")
  59. self.assertStr(Name("foo.foo().bar"), "foo.foo().bar")
  60. self.assertStr(Name("a", prefix="b"), "ba")
  61. class Test_does_tree_import(support.TestCase):
  62. def _find_bind_rec(self, name, node):
  63. # Search a tree for a binding -- used to find the starting
  64. # point for these tests.
  65. c = fixer_util.find_binding(name, node)
  66. if c: return c
  67. for child in node.children:
  68. c = self._find_bind_rec(name, child)
  69. if c: return c
  70. def does_tree_import(self, package, name, string):
  71. node = parse(string)
  72. # Find the binding of start -- that's what we'll go from
  73. node = self._find_bind_rec('start', node)
  74. return fixer_util.does_tree_import(package, name, node)
  75. def try_with(self, string):
  76. failing_tests = (("a", "a", "from a import b"),
  77. ("a.d", "a", "from a.d import b"),
  78. ("d.a", "a", "from d.a import b"),
  79. (None, "a", "import b"),
  80. (None, "a", "import b, c, d"))
  81. for package, name, import_ in failing_tests:
  82. n = self.does_tree_import(package, name, import_ + "\n" + string)
  83. self.failIf(n)
  84. n = self.does_tree_import(package, name, string + "\n" + import_)
  85. self.failIf(n)
  86. passing_tests = (("a", "a", "from a import a"),
  87. ("x", "a", "from x import a"),
  88. ("x", "a", "from x import b, c, a, d"),
  89. ("x.b", "a", "from x.b import a"),
  90. ("x.b", "a", "from x.b import b, c, a, d"),
  91. (None, "a", "import a"),
  92. (None, "a", "import b, c, a, d"))
  93. for package, name, import_ in passing_tests:
  94. n = self.does_tree_import(package, name, import_ + "\n" + string)
  95. self.failUnless(n)
  96. n = self.does_tree_import(package, name, string + "\n" + import_)
  97. self.failUnless(n)
  98. def test_in_function(self):
  99. self.try_with("def foo():\n\tbar.baz()\n\tstart=3")
  100. class Test_find_binding(support.TestCase):
  101. def find_binding(self, name, string, package=None):
  102. return fixer_util.find_binding(name, parse(string), package)
  103. def test_simple_assignment(self):
  104. self.failUnless(self.find_binding("a", "a = b"))
  105. self.failUnless(self.find_binding("a", "a = [b, c, d]"))
  106. self.failUnless(self.find_binding("a", "a = foo()"))
  107. self.failUnless(self.find_binding("a", "a = foo().foo.foo[6][foo]"))
  108. self.failIf(self.find_binding("a", "foo = a"))
  109. self.failIf(self.find_binding("a", "foo = (a, b, c)"))
  110. def test_tuple_assignment(self):
  111. self.failUnless(self.find_binding("a", "(a,) = b"))
  112. self.failUnless(self.find_binding("a", "(a, b, c) = [b, c, d]"))
  113. self.failUnless(self.find_binding("a", "(c, (d, a), b) = foo()"))
  114. self.failUnless(self.find_binding("a", "(a, b) = foo().foo[6][foo]"))
  115. self.failIf(self.find_binding("a", "(foo, b) = (b, a)"))
  116. self.failIf(self.find_binding("a", "(foo, (b, c)) = (a, b, c)"))
  117. def test_list_assignment(self):
  118. self.failUnless(self.find_binding("a", "[a] = b"))
  119. self.failUnless(self.find_binding("a", "[a, b, c] = [b, c, d]"))
  120. self.failUnless(self.find_binding("a", "[c, [d, a], b] = foo()"))
  121. self.failUnless(self.find_binding("a", "[a, b] = foo().foo[a][foo]"))
  122. self.failIf(self.find_binding("a", "[foo, b] = (b, a)"))
  123. self.failIf(self.find_binding("a", "[foo, [b, c]] = (a, b, c)"))
  124. def test_invalid_assignments(self):
  125. self.failIf(self.find_binding("a", "foo.a = 5"))
  126. self.failIf(self.find_binding("a", "foo[a] = 5"))
  127. self.failIf(self.find_binding("a", "foo(a) = 5"))
  128. self.failIf(self.find_binding("a", "foo(a, b) = 5"))
  129. def test_simple_import(self):
  130. self.failUnless(self.find_binding("a", "import a"))
  131. self.failUnless(self.find_binding("a", "import b, c, a, d"))
  132. self.failIf(self.find_binding("a", "import b"))
  133. self.failIf(self.find_binding("a", "import b, c, d"))
  134. def test_from_import(self):
  135. self.failUnless(self.find_binding("a", "from x import a"))
  136. self.failUnless(self.find_binding("a", "from a import a"))
  137. self.failUnless(self.find_binding("a", "from x import b, c, a, d"))
  138. self.failUnless(self.find_binding("a", "from x.b import a"))
  139. self.failUnless(self.find_binding("a", "from x.b import b, c, a, d"))
  140. self.failIf(self.find_binding("a", "from a import b"))
  141. self.failIf(self.find_binding("a", "from a.d import b"))
  142. self.failIf(self.find_binding("a", "from d.a import b"))
  143. def test_import_as(self):
  144. self.failUnless(self.find_binding("a", "import b as a"))
  145. self.failUnless(self.find_binding("a", "import b as a, c, a as f, d"))
  146. self.failIf(self.find_binding("a", "import a as f"))
  147. self.failIf(self.find_binding("a", "import b, c as f, d as e"))
  148. def test_from_import_as(self):
  149. self.failUnless(self.find_binding("a", "from x import b as a"))
  150. self.failUnless(self.find_binding("a", "from x import g as a, d as b"))
  151. self.failUnless(self.find_binding("a", "from x.b import t as a"))
  152. self.failUnless(self.find_binding("a", "from x.b import g as a, d"))
  153. self.failIf(self.find_binding("a", "from a import b as t"))
  154. self.failIf(self.find_binding("a", "from a.d import b as t"))
  155. self.failIf(self.find_binding("a", "from d.a import b as t"))
  156. def test_simple_import_with_package(self):
  157. self.failUnless(self.find_binding("b", "import b"))
  158. self.failUnless(self.find_binding("b", "import b, c, d"))
  159. self.failIf(self.find_binding("b", "import b", "b"))
  160. self.failIf(self.find_binding("b", "import b, c, d", "c"))
  161. def test_from_import_with_package(self):
  162. self.failUnless(self.find_binding("a", "from x import a", "x"))
  163. self.failUnless(self.find_binding("a", "from a import a", "a"))
  164. self.failUnless(self.find_binding("a", "from x import *", "x"))
  165. self.failUnless(self.find_binding("a", "from x import b, c, a, d", "x"))
  166. self.failUnless(self.find_binding("a", "from x.b import a", "x.b"))
  167. self.failUnless(self.find_binding("a", "from x.b import *", "x.b"))
  168. self.failUnless(self.find_binding("a", "from x.b import b, c, a, d", "x.b"))
  169. self.failIf(self.find_binding("a", "from a import b", "a"))
  170. self.failIf(self.find_binding("a", "from a.d import b", "a.d"))
  171. self.failIf(self.find_binding("a", "from d.a import b", "a.d"))
  172. self.failIf(self.find_binding("a", "from x.y import *", "a.b"))
  173. def test_import_as_with_package(self):
  174. self.failIf(self.find_binding("a", "import b.c as a", "b.c"))
  175. self.failIf(self.find_binding("a", "import a as f", "f"))
  176. self.failIf(self.find_binding("a", "import a as f", "a"))
  177. def test_from_import_as_with_package(self):
  178. # Because it would take a lot of special-case code in the fixers
  179. # to deal with from foo import bar as baz, we'll simply always
  180. # fail if there is an "from ... import ... as ..."
  181. self.failIf(self.find_binding("a", "from x import b as a", "x"))
  182. self.failIf(self.find_binding("a", "from x import g as a, d as b", "x"))
  183. self.failIf(self.find_binding("a", "from x.b import t as a", "x.b"))
  184. self.failIf(self.find_binding("a", "from x.b import g as a, d", "x.b"))
  185. self.failIf(self.find_binding("a", "from a import b as t", "a"))
  186. self.failIf(self.find_binding("a", "from a import b as t", "b"))
  187. self.failIf(self.find_binding("a", "from a import b as t", "t"))
  188. def test_function_def(self):
  189. self.failUnless(self.find_binding("a", "def a(): pass"))
  190. self.failUnless(self.find_binding("a", "def a(b, c, d): pass"))
  191. self.failUnless(self.find_binding("a", "def a(): b = 7"))
  192. self.failIf(self.find_binding("a", "def d(b, (c, a), e): pass"))
  193. self.failIf(self.find_binding("a", "def d(a=7): pass"))
  194. self.failIf(self.find_binding("a", "def d(a): pass"))
  195. self.failIf(self.find_binding("a", "def d(): a = 7"))
  196. s = """
  197. def d():
  198. def a():
  199. pass"""
  200. self.failIf(self.find_binding("a", s))
  201. def test_class_def(self):
  202. self.failUnless(self.find_binding("a", "class a: pass"))
  203. self.failUnless(self.find_binding("a", "class a(): pass"))
  204. self.failUnless(self.find_binding("a", "class a(b): pass"))
  205. self.failUnless(self.find_binding("a", "class a(b, c=8): pass"))
  206. self.failIf(self.find_binding("a", "class d: pass"))
  207. self.failIf(self.find_binding("a", "class d(a): pass"))
  208. self.failIf(self.find_binding("a", "class d(b, a=7): pass"))
  209. self.failIf(self.find_binding("a", "class d(b, *a): pass"))
  210. self.failIf(self.find_binding("a", "class d(b, **a): pass"))
  211. self.failIf(self.find_binding("a", "class d: a = 7"))
  212. s = """
  213. class d():
  214. class a():
  215. pass"""
  216. self.failIf(self.find_binding("a", s))
  217. def test_for(self):
  218. self.failUnless(self.find_binding("a", "for a in r: pass"))
  219. self.failUnless(self.find_binding("a", "for a, b in r: pass"))
  220. self.failUnless(self.find_binding("a", "for (a, b) in r: pass"))
  221. self.failUnless(self.find_binding("a", "for c, (a,) in r: pass"))
  222. self.failUnless(self.find_binding("a", "for c, (a, b) in r: pass"))
  223. self.failUnless(self.find_binding("a", "for c in r: a = c"))
  224. self.failIf(self.find_binding("a", "for c in a: pass"))
  225. def test_for_nested(self):
  226. s = """
  227. for b in r:
  228. for a in b:
  229. pass"""
  230. self.failUnless(self.find_binding("a", s))
  231. s = """
  232. for b in r:
  233. for a, c in b:
  234. pass"""
  235. self.failUnless(self.find_binding("a", s))
  236. s = """
  237. for b in r:
  238. for (a, c) in b:
  239. pass"""
  240. self.failUnless(self.find_binding("a", s))
  241. s = """
  242. for b in r:
  243. for (a,) in b:
  244. pass"""
  245. self.failUnless(self.find_binding("a", s))
  246. s = """
  247. for b in r:
  248. for c, (a, d) in b:
  249. pass"""
  250. self.failUnless(self.find_binding("a", s))
  251. s = """
  252. for b in r:
  253. for c in b:
  254. a = 7"""
  255. self.failUnless(self.find_binding("a", s))
  256. s = """
  257. for b in r:
  258. for c in b:
  259. d = a"""
  260. self.failIf(self.find_binding("a", s))
  261. s = """
  262. for b in r:
  263. for c in a:
  264. d = 7"""
  265. self.failIf(self.find_binding("a", s))
  266. def test_if(self):
  267. self.failUnless(self.find_binding("a", "if b in r: a = c"))
  268. self.failIf(self.find_binding("a", "if a in r: d = e"))
  269. def test_if_nested(self):
  270. s = """
  271. if b in r:
  272. if c in d:
  273. a = c"""
  274. self.failUnless(self.find_binding("a", s))
  275. s = """
  276. if b in r:
  277. if c in d:
  278. c = a"""
  279. self.failIf(self.find_binding("a", s))
  280. def test_while(self):
  281. self.failUnless(self.find_binding("a", "while b in r: a = c"))
  282. self.failIf(self.find_binding("a", "while a in r: d = e"))
  283. def test_while_nested(self):
  284. s = """
  285. while b in r:
  286. while c in d:
  287. a = c"""
  288. self.failUnless(self.find_binding("a", s))
  289. s = """
  290. while b in r:
  291. while c in d:
  292. c = a"""
  293. self.failIf(self.find_binding("a", s))
  294. def test_try_except(self):
  295. s = """
  296. try:
  297. a = 6
  298. except:
  299. b = 8"""
  300. self.failUnless(self.find_binding("a", s))
  301. s = """
  302. try:
  303. b = 8
  304. except:
  305. a = 6"""
  306. self.failUnless(self.find_binding("a", s))
  307. s = """
  308. try:
  309. b = 8
  310. except KeyError:
  311. pass
  312. except:
  313. a = 6"""
  314. self.failUnless(self.find_binding("a", s))
  315. s = """
  316. try:
  317. b = 8
  318. except:
  319. b = 6"""
  320. self.failIf(self.find_binding("a", s))
  321. def test_try_except_nested(self):
  322. s = """
  323. try:
  324. try:
  325. a = 6
  326. except:
  327. pass
  328. except:
  329. b = 8"""
  330. self.failUnless(self.find_binding("a", s))
  331. s = """
  332. try:
  333. b = 8
  334. except:
  335. try:
  336. a = 6
  337. except:
  338. pass"""
  339. self.failUnless(self.find_binding("a", s))
  340. s = """
  341. try:
  342. b = 8
  343. except:
  344. try:
  345. pass
  346. except:
  347. a = 6"""
  348. self.failUnless(self.find_binding("a", s))
  349. s = """
  350. try:
  351. try:
  352. b = 8
  353. except KeyError:
  354. pass
  355. except:
  356. a = 6
  357. except:
  358. pass"""
  359. self.failUnless(self.find_binding("a", s))
  360. s = """
  361. try:
  362. pass
  363. except:
  364. try:
  365. b = 8
  366. except KeyError:
  367. pass
  368. except:
  369. a = 6"""
  370. self.failUnless(self.find_binding("a", s))
  371. s = """
  372. try:
  373. b = 8
  374. except:
  375. b = 6"""
  376. self.failIf(self.find_binding("a", s))
  377. s = """
  378. try:
  379. try:
  380. b = 8
  381. except:
  382. c = d
  383. except:
  384. try:
  385. b = 6
  386. except:
  387. t = 8
  388. except:
  389. o = y"""
  390. self.failIf(self.find_binding("a", s))
  391. def test_try_except_finally(self):
  392. s = """
  393. try:
  394. c = 6
  395. except:
  396. b = 8
  397. finally:
  398. a = 9"""
  399. self.failUnless(self.find_binding("a", s))
  400. s = """
  401. try:
  402. b = 8
  403. finally:
  404. a = 6"""
  405. self.failUnless(self.find_binding("a", s))
  406. s = """
  407. try:
  408. b = 8
  409. finally:
  410. b = 6"""
  411. self.failIf(self.find_binding("a", s))
  412. s = """
  413. try:
  414. b = 8
  415. except:
  416. b = 9
  417. finally:
  418. b = 6"""
  419. self.failIf(self.find_binding("a", s))
  420. def test_try_except_finally_nested(self):
  421. s = """
  422. try:
  423. c = 6
  424. except:
  425. b = 8
  426. finally:
  427. try:
  428. a = 9
  429. except:
  430. b = 9
  431. finally:
  432. c = 9"""
  433. self.failUnless(self.find_binding("a", s))
  434. s = """
  435. try:
  436. b = 8
  437. finally:
  438. try:
  439. pass
  440. finally:
  441. a = 6"""
  442. self.failUnless(self.find_binding("a", s))
  443. s = """
  444. try:
  445. b = 8
  446. finally:
  447. try:
  448. b = 6
  449. finally:
  450. b = 7"""
  451. self.failIf(self.find_binding("a", s))
  452. class Test_touch_import(support.TestCase):
  453. def test_after_docstring(self):
  454. node = parse('"""foo"""\nbar()')
  455. fixer_util.touch_import(None, "foo", node)
  456. self.assertEqual(str(node), '"""foo"""\nimport foo\nbar()\n\n')
  457. def test_after_imports(self):
  458. node = parse('"""foo"""\nimport bar\nbar()')
  459. fixer_util.touch_import(None, "foo", node)
  460. self.assertEqual(str(node), '"""foo"""\nimport bar\nimport foo\nbar()\n\n')
  461. def test_beginning(self):
  462. node = parse('bar()')
  463. fixer_util.touch_import(None, "foo", node)
  464. self.assertEqual(str(node), 'import foo\nbar()\n\n')
  465. def test_from_import(self):
  466. node = parse('bar()')
  467. fixer_util.touch_import("cgi", "escape", node)
  468. self.assertEqual(str(node), 'from cgi import escape\nbar()\n\n')
  469. def test_name_import(self):
  470. node = parse('bar()')
  471. fixer_util.touch_import(None, "cgi", node)
  472. self.assertEqual(str(node), 'import cgi\nbar()\n\n')
  473. if __name__ == "__main__":
  474. import __main__
  475. support.run_all_tests(__main__)