codeparser.py 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380
  1. # ex:ts=4:sw=4:sts=4:et
  2. # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
  3. #
  4. # BitBake Test for codeparser.py
  5. #
  6. # Copyright (C) 2010 Chris Larson
  7. # Copyright (C) 2012 Richard Purdie
  8. #
  9. # This program is free software; you can redistribute it and/or modify
  10. # it under the terms of the GNU General Public License version 2 as
  11. # published by the Free Software Foundation.
  12. #
  13. # This program is distributed in the hope that it will be useful,
  14. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16. # GNU General Public License for more details.
  17. #
  18. # You should have received a copy of the GNU General Public License along
  19. # with this program; if not, write to the Free Software Foundation, Inc.,
  20. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21. #
  22. import unittest
  23. import logging
  24. import bb
  25. logger = logging.getLogger('BitBake.TestCodeParser')
  26. # bb.data references bb.parse but can't directly import due to circular dependencies.
  27. # Hack around it for now :(
  28. import bb.parse
  29. import bb.data
  30. class ReferenceTest(unittest.TestCase):
  31. def setUp(self):
  32. self.d = bb.data.init()
  33. def setEmptyVars(self, varlist):
  34. for k in varlist:
  35. self.d.setVar(k, "")
  36. def setValues(self, values):
  37. for k, v in values.items():
  38. self.d.setVar(k, v)
  39. def assertReferences(self, refs):
  40. self.assertEqual(self.references, refs)
  41. def assertExecs(self, execs):
  42. self.assertEqual(self.execs, execs)
  43. class VariableReferenceTest(ReferenceTest):
  44. def parseExpression(self, exp):
  45. parsedvar = self.d.expandWithRefs(exp, None)
  46. self.references = parsedvar.references
  47. def test_simple_reference(self):
  48. self.setEmptyVars(["FOO"])
  49. self.parseExpression("${FOO}")
  50. self.assertReferences(set(["FOO"]))
  51. def test_nested_reference(self):
  52. self.setEmptyVars(["BAR"])
  53. self.d.setVar("FOO", "BAR")
  54. self.parseExpression("${${FOO}}")
  55. self.assertReferences(set(["FOO", "BAR"]))
  56. def test_python_reference(self):
  57. self.setEmptyVars(["BAR"])
  58. self.parseExpression("${@bb.data.getVar('BAR', d, True) + 'foo'}")
  59. self.assertReferences(set(["BAR"]))
  60. class ShellReferenceTest(ReferenceTest):
  61. def parseExpression(self, exp):
  62. parsedvar = self.d.expandWithRefs(exp, None)
  63. parser = bb.codeparser.ShellParser("ParserTest", logger)
  64. parser.parse_shell(parsedvar.value)
  65. self.references = parsedvar.references
  66. self.execs = parser.execs
  67. def test_quotes_inside_assign(self):
  68. self.parseExpression('foo=foo"bar"baz')
  69. self.assertReferences(set([]))
  70. def test_quotes_inside_arg(self):
  71. self.parseExpression('sed s#"bar baz"#"alpha beta"#g')
  72. self.assertExecs(set(["sed"]))
  73. def test_arg_continuation(self):
  74. self.parseExpression("sed -i -e s,foo,bar,g \\\n *.pc")
  75. self.assertExecs(set(["sed"]))
  76. def test_dollar_in_quoted(self):
  77. self.parseExpression('sed -i -e "foo$" *.pc')
  78. self.assertExecs(set(["sed"]))
  79. def test_quotes_inside_arg_continuation(self):
  80. self.setEmptyVars(["bindir", "D", "libdir"])
  81. self.parseExpression("""
  82. sed -i -e s#"moc_location=.*$"#"moc_location=${bindir}/moc4"# \\
  83. -e s#"uic_location=.*$"#"uic_location=${bindir}/uic4"# \\
  84. ${D}${libdir}/pkgconfig/*.pc
  85. """)
  86. self.assertReferences(set(["bindir", "D", "libdir"]))
  87. def test_assign_subshell_expansion(self):
  88. self.parseExpression("foo=$(echo bar)")
  89. self.assertExecs(set(["echo"]))
  90. def test_shell_unexpanded(self):
  91. self.setEmptyVars(["QT_BASE_NAME"])
  92. self.parseExpression('echo "${QT_BASE_NAME}"')
  93. self.assertExecs(set(["echo"]))
  94. self.assertReferences(set(["QT_BASE_NAME"]))
  95. def test_incomplete_varexp_single_quotes(self):
  96. self.parseExpression("sed -i -e 's:IP{:I${:g' $pc")
  97. self.assertExecs(set(["sed"]))
  98. def test_until(self):
  99. self.parseExpression("until false; do echo true; done")
  100. self.assertExecs(set(["false", "echo"]))
  101. self.assertReferences(set())
  102. def test_case(self):
  103. self.parseExpression("""
  104. case $foo in
  105. *)
  106. bar
  107. ;;
  108. esac
  109. """)
  110. self.assertExecs(set(["bar"]))
  111. self.assertReferences(set())
  112. def test_assign_exec(self):
  113. self.parseExpression("a=b c='foo bar' alpha 1 2 3")
  114. self.assertExecs(set(["alpha"]))
  115. def test_redirect_to_file(self):
  116. self.setEmptyVars(["foo"])
  117. self.parseExpression("echo foo >${foo}/bar")
  118. self.assertExecs(set(["echo"]))
  119. self.assertReferences(set(["foo"]))
  120. def test_heredoc(self):
  121. self.setEmptyVars(["theta"])
  122. self.parseExpression("""
  123. cat <<END
  124. alpha
  125. beta
  126. ${theta}
  127. END
  128. """)
  129. self.assertReferences(set(["theta"]))
  130. def test_redirect_from_heredoc(self):
  131. v = ["B", "SHADOW_MAILDIR", "SHADOW_MAILFILE", "SHADOW_UTMPDIR", "SHADOW_LOGDIR", "bindir"]
  132. self.setEmptyVars(v)
  133. self.parseExpression("""
  134. cat <<END >${B}/cachedpaths
  135. shadow_cv_maildir=${SHADOW_MAILDIR}
  136. shadow_cv_mailfile=${SHADOW_MAILFILE}
  137. shadow_cv_utmpdir=${SHADOW_UTMPDIR}
  138. shadow_cv_logdir=${SHADOW_LOGDIR}
  139. shadow_cv_passwd_dir=${bindir}
  140. END
  141. """)
  142. self.assertReferences(set(v))
  143. self.assertExecs(set(["cat"]))
  144. # def test_incomplete_command_expansion(self):
  145. # self.assertRaises(reftracker.ShellSyntaxError, reftracker.execs,
  146. # bbvalue.shparse("cp foo`", self.d), self.d)
  147. # def test_rogue_dollarsign(self):
  148. # self.setValues({"D" : "/tmp"})
  149. # self.parseExpression("install -d ${D}$")
  150. # self.assertReferences(set(["D"]))
  151. # self.assertExecs(set(["install"]))
  152. class PythonReferenceTest(ReferenceTest):
  153. def setUp(self):
  154. self.d = bb.data.init()
  155. if hasattr(bb.utils, "_context"):
  156. self.context = bb.utils._context
  157. else:
  158. import builtins
  159. self.context = builtins.__dict__
  160. def parseExpression(self, exp):
  161. parsedvar = self.d.expandWithRefs(exp, None)
  162. parser = bb.codeparser.PythonParser("ParserTest", logger)
  163. parser.parse_python(parsedvar.value)
  164. self.references = parsedvar.references | parser.references
  165. self.execs = parser.execs
  166. @staticmethod
  167. def indent(value):
  168. """Python Snippets have to be indented, python values don't have to
  169. be. These unit tests are testing snippets."""
  170. return " " + value
  171. def test_getvar_reference(self):
  172. self.parseExpression("bb.data.getVar('foo', d, True)")
  173. self.assertReferences(set(["foo"]))
  174. self.assertExecs(set())
  175. def test_getvar_computed_reference(self):
  176. self.parseExpression("bb.data.getVar('f' + 'o' + 'o', d, True)")
  177. self.assertReferences(set())
  178. self.assertExecs(set())
  179. def test_getvar_exec_reference(self):
  180. self.parseExpression("eval('bb.data.getVar(\"foo\", d, True)')")
  181. self.assertReferences(set())
  182. self.assertExecs(set(["eval"]))
  183. def test_var_reference(self):
  184. self.context["foo"] = lambda x: x
  185. self.setEmptyVars(["FOO"])
  186. self.parseExpression("foo('${FOO}')")
  187. self.assertReferences(set(["FOO"]))
  188. self.assertExecs(set(["foo"]))
  189. del self.context["foo"]
  190. def test_var_exec(self):
  191. for etype in ("func", "task"):
  192. self.d.setVar("do_something", "echo 'hi mom! ${FOO}'")
  193. self.d.setVarFlag("do_something", etype, True)
  194. self.parseExpression("bb.build.exec_func('do_something', d)")
  195. self.assertReferences(set([]))
  196. self.assertExecs(set(["do_something"]))
  197. def test_function_reference(self):
  198. self.context["testfunc"] = lambda msg: bb.msg.note(1, None, msg)
  199. self.d.setVar("FOO", "Hello, World!")
  200. self.parseExpression("testfunc('${FOO}')")
  201. self.assertReferences(set(["FOO"]))
  202. self.assertExecs(set(["testfunc"]))
  203. del self.context["testfunc"]
  204. def test_qualified_function_reference(self):
  205. self.parseExpression("time.time()")
  206. self.assertExecs(set(["time.time"]))
  207. def test_qualified_function_reference_2(self):
  208. self.parseExpression("os.path.dirname('/foo/bar')")
  209. self.assertExecs(set(["os.path.dirname"]))
  210. def test_qualified_function_reference_nested(self):
  211. self.parseExpression("time.strftime('%Y%m%d',time.gmtime())")
  212. self.assertExecs(set(["time.strftime", "time.gmtime"]))
  213. def test_function_reference_chained(self):
  214. self.context["testget"] = lambda: "\tstrip me "
  215. self.parseExpression("testget().strip()")
  216. self.assertExecs(set(["testget"]))
  217. del self.context["testget"]
  218. class DependencyReferenceTest(ReferenceTest):
  219. pydata = """
  220. bb.data.getVar('somevar', d, True)
  221. def test(d):
  222. foo = 'bar %s' % 'foo'
  223. def test2(d):
  224. d.getVar(foo, True)
  225. d.getVar('bar', False)
  226. test2(d)
  227. def a():
  228. \"\"\"some
  229. stuff
  230. \"\"\"
  231. return "heh"
  232. test(d)
  233. bb.data.expand(bb.data.getVar("something", False, d), d)
  234. bb.data.expand("${inexpand} somethingelse", d)
  235. bb.data.getVar(a(), d, False)
  236. """
  237. def test_python(self):
  238. self.d.setVar("FOO", self.pydata)
  239. self.setEmptyVars(["inexpand", "a", "test2", "test"])
  240. self.d.setVarFlags("FOO", {
  241. "func": True,
  242. "python": True,
  243. "lineno": 1,
  244. "filename": "example.bb",
  245. })
  246. deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
  247. self.assertEqual(deps, set(["somevar", "bar", "something", "inexpand", "test", "test2", "a"]))
  248. shelldata = """
  249. foo () {
  250. bar
  251. }
  252. {
  253. echo baz
  254. $(heh)
  255. eval `moo`
  256. }
  257. a=b
  258. c=d
  259. (
  260. true && false
  261. test -f foo
  262. testval=something
  263. $testval
  264. ) || aiee
  265. ! inverted
  266. echo ${somevar}
  267. case foo in
  268. bar)
  269. echo bar
  270. ;;
  271. baz)
  272. echo baz
  273. ;;
  274. foo*)
  275. echo foo
  276. ;;
  277. esac
  278. """
  279. def test_shell(self):
  280. execs = ["bar", "echo", "heh", "moo", "true", "aiee"]
  281. self.d.setVar("somevar", "heh")
  282. self.d.setVar("inverted", "echo inverted...")
  283. self.d.setVarFlag("inverted", "func", True)
  284. self.d.setVar("FOO", self.shelldata)
  285. self.d.setVarFlags("FOO", {"func": True})
  286. self.setEmptyVars(execs)
  287. deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
  288. self.assertEqual(deps, set(["somevar", "inverted"] + execs))
  289. def test_vardeps(self):
  290. self.d.setVar("oe_libinstall", "echo test")
  291. self.d.setVar("FOO", "foo=oe_libinstall; eval $foo")
  292. self.d.setVarFlag("FOO", "vardeps", "oe_libinstall")
  293. deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
  294. self.assertEqual(deps, set(["oe_libinstall"]))
  295. def test_vardeps_expand(self):
  296. self.d.setVar("oe_libinstall", "echo test")
  297. self.d.setVar("FOO", "foo=oe_libinstall; eval $foo")
  298. self.d.setVarFlag("FOO", "vardeps", "${@'oe_libinstall'}")
  299. deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
  300. self.assertEqual(deps, set(["oe_libinstall"]))
  301. #Currently no wildcard support
  302. #def test_vardeps_wildcards(self):
  303. # self.d.setVar("oe_libinstall", "echo test")
  304. # self.d.setVar("FOO", "foo=oe_libinstall; eval $foo")
  305. # self.d.setVarFlag("FOO", "vardeps", "oe_*")
  306. # self.assertEquals(deps, set(["oe_libinstall"]))