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