diff options
Diffstat (limited to 'bitbake/lib/bb/tests/data.py')
-rw-r--r-- | bitbake/lib/bb/tests/data.py | 351 |
1 files changed, 351 insertions, 0 deletions
diff --git a/bitbake/lib/bb/tests/data.py b/bitbake/lib/bb/tests/data.py new file mode 100644 index 0000000000..23a5e5fd9c --- /dev/null +++ b/bitbake/lib/bb/tests/data.py | |||
@@ -0,0 +1,351 @@ | |||
1 | # ex:ts=4:sw=4:sts=4:et | ||
2 | # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- | ||
3 | # | ||
4 | # BitBake Tests for the Data Store (data.py/data_smart.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 | |||
23 | import unittest | ||
24 | import bb | ||
25 | import bb.data | ||
26 | import bb.parse | ||
27 | |||
28 | class DataExpansions(unittest.TestCase): | ||
29 | def setUp(self): | ||
30 | self.d = bb.data.init() | ||
31 | self.d["foo"] = "value_of_foo" | ||
32 | self.d["bar"] = "value_of_bar" | ||
33 | self.d["value_of_foo"] = "value_of_'value_of_foo'" | ||
34 | |||
35 | def test_one_var(self): | ||
36 | val = self.d.expand("${foo}") | ||
37 | self.assertEqual(str(val), "value_of_foo") | ||
38 | |||
39 | def test_indirect_one_var(self): | ||
40 | val = self.d.expand("${${foo}}") | ||
41 | self.assertEqual(str(val), "value_of_'value_of_foo'") | ||
42 | |||
43 | def test_indirect_and_another(self): | ||
44 | val = self.d.expand("${${foo}} ${bar}") | ||
45 | self.assertEqual(str(val), "value_of_'value_of_foo' value_of_bar") | ||
46 | |||
47 | def test_python_snippet(self): | ||
48 | val = self.d.expand("${@5*12}") | ||
49 | self.assertEqual(str(val), "60") | ||
50 | |||
51 | def test_expand_in_python_snippet(self): | ||
52 | val = self.d.expand("${@'boo ' + '${foo}'}") | ||
53 | self.assertEqual(str(val), "boo value_of_foo") | ||
54 | |||
55 | def test_python_snippet_getvar(self): | ||
56 | val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}") | ||
57 | self.assertEqual(str(val), "value_of_foo value_of_bar") | ||
58 | |||
59 | def test_python_snippet_syntax_error(self): | ||
60 | self.d.setVar("FOO", "${@foo = 5}") | ||
61 | self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True) | ||
62 | |||
63 | def test_python_snippet_runtime_error(self): | ||
64 | self.d.setVar("FOO", "${@int('test')}") | ||
65 | self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True) | ||
66 | |||
67 | def test_python_snippet_error_path(self): | ||
68 | self.d.setVar("FOO", "foo value ${BAR}") | ||
69 | self.d.setVar("BAR", "bar value ${@int('test')}") | ||
70 | self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True) | ||
71 | |||
72 | def test_value_containing_value(self): | ||
73 | val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}") | ||
74 | self.assertEqual(str(val), "value_of_foo value_of_bar") | ||
75 | |||
76 | def test_reference_undefined_var(self): | ||
77 | val = self.d.expand("${undefinedvar} meh") | ||
78 | self.assertEqual(str(val), "${undefinedvar} meh") | ||
79 | |||
80 | def test_double_reference(self): | ||
81 | self.d.setVar("BAR", "bar value") | ||
82 | self.d.setVar("FOO", "${BAR} foo ${BAR}") | ||
83 | val = self.d.getVar("FOO", True) | ||
84 | self.assertEqual(str(val), "bar value foo bar value") | ||
85 | |||
86 | def test_direct_recursion(self): | ||
87 | self.d.setVar("FOO", "${FOO}") | ||
88 | self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True) | ||
89 | |||
90 | def test_indirect_recursion(self): | ||
91 | self.d.setVar("FOO", "${BAR}") | ||
92 | self.d.setVar("BAR", "${BAZ}") | ||
93 | self.d.setVar("BAZ", "${FOO}") | ||
94 | self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True) | ||
95 | |||
96 | def test_recursion_exception(self): | ||
97 | self.d.setVar("FOO", "${BAR}") | ||
98 | self.d.setVar("BAR", "${${@'FOO'}}") | ||
99 | self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True) | ||
100 | |||
101 | def test_incomplete_varexp_single_quotes(self): | ||
102 | self.d.setVar("FOO", "sed -i -e 's:IP{:I${:g' $pc") | ||
103 | val = self.d.getVar("FOO", True) | ||
104 | self.assertEqual(str(val), "sed -i -e 's:IP{:I${:g' $pc") | ||
105 | |||
106 | def test_nonstring(self): | ||
107 | self.d.setVar("TEST", 5) | ||
108 | val = self.d.getVar("TEST", True) | ||
109 | self.assertEqual(str(val), "5") | ||
110 | |||
111 | def test_rename(self): | ||
112 | self.d.renameVar("foo", "newfoo") | ||
113 | self.assertEqual(self.d.getVar("newfoo"), "value_of_foo") | ||
114 | self.assertEqual(self.d.getVar("foo"), None) | ||
115 | |||
116 | def test_deletion(self): | ||
117 | self.d.delVar("foo") | ||
118 | self.assertEqual(self.d.getVar("foo"), None) | ||
119 | |||
120 | def test_keys(self): | ||
121 | keys = self.d.keys() | ||
122 | self.assertEqual(keys, ['value_of_foo', 'foo', 'bar']) | ||
123 | |||
124 | class TestNestedExpansions(unittest.TestCase): | ||
125 | def setUp(self): | ||
126 | self.d = bb.data.init() | ||
127 | self.d["foo"] = "foo" | ||
128 | self.d["bar"] = "bar" | ||
129 | self.d["value_of_foobar"] = "187" | ||
130 | |||
131 | def test_refs(self): | ||
132 | val = self.d.expand("${value_of_${foo}${bar}}") | ||
133 | self.assertEqual(str(val), "187") | ||
134 | |||
135 | #def test_python_refs(self): | ||
136 | # val = self.d.expand("${@${@3}**2 + ${@4}**2}") | ||
137 | # self.assertEqual(str(val), "25") | ||
138 | |||
139 | def test_ref_in_python_ref(self): | ||
140 | val = self.d.expand("${@'${foo}' + 'bar'}") | ||
141 | self.assertEqual(str(val), "foobar") | ||
142 | |||
143 | def test_python_ref_in_ref(self): | ||
144 | val = self.d.expand("${${@'f'+'o'+'o'}}") | ||
145 | self.assertEqual(str(val), "foo") | ||
146 | |||
147 | def test_deep_nesting(self): | ||
148 | depth = 100 | ||
149 | val = self.d.expand("${" * depth + "foo" + "}" * depth) | ||
150 | self.assertEqual(str(val), "foo") | ||
151 | |||
152 | #def test_deep_python_nesting(self): | ||
153 | # depth = 50 | ||
154 | # val = self.d.expand("${@" * depth + "1" + "+1}" * depth) | ||
155 | # self.assertEqual(str(val), str(depth + 1)) | ||
156 | |||
157 | def test_mixed(self): | ||
158 | val = self.d.expand("${value_of_${@('${foo}'+'bar')[0:3]}${${@'BAR'.lower()}}}") | ||
159 | self.assertEqual(str(val), "187") | ||
160 | |||
161 | def test_runtime(self): | ||
162 | val = self.d.expand("${${@'value_of' + '_f'+'o'+'o'+'b'+'a'+'r'}}") | ||
163 | self.assertEqual(str(val), "187") | ||
164 | |||
165 | class TestMemoize(unittest.TestCase): | ||
166 | def test_memoized(self): | ||
167 | d = bb.data.init() | ||
168 | d.setVar("FOO", "bar") | ||
169 | self.assertTrue(d.getVar("FOO") is d.getVar("FOO")) | ||
170 | |||
171 | def test_not_memoized(self): | ||
172 | d1 = bb.data.init() | ||
173 | d2 = bb.data.init() | ||
174 | d1.setVar("FOO", "bar") | ||
175 | d2.setVar("FOO", "bar2") | ||
176 | self.assertTrue(d1.getVar("FOO") is not d2.getVar("FOO")) | ||
177 | |||
178 | def test_changed_after_memoized(self): | ||
179 | d = bb.data.init() | ||
180 | d.setVar("foo", "value of foo") | ||
181 | self.assertEqual(str(d.getVar("foo")), "value of foo") | ||
182 | d.setVar("foo", "second value of foo") | ||
183 | self.assertEqual(str(d.getVar("foo")), "second value of foo") | ||
184 | |||
185 | def test_same_value(self): | ||
186 | d = bb.data.init() | ||
187 | d.setVar("foo", "value of") | ||
188 | d.setVar("bar", "value of") | ||
189 | self.assertEqual(d.getVar("foo"), | ||
190 | d.getVar("bar")) | ||
191 | |||
192 | class TestConcat(unittest.TestCase): | ||
193 | def setUp(self): | ||
194 | self.d = bb.data.init() | ||
195 | self.d.setVar("FOO", "foo") | ||
196 | self.d.setVar("VAL", "val") | ||
197 | self.d.setVar("BAR", "bar") | ||
198 | |||
199 | def test_prepend(self): | ||
200 | self.d.setVar("TEST", "${VAL}") | ||
201 | self.d.prependVar("TEST", "${FOO}:") | ||
202 | self.assertEqual(self.d.getVar("TEST", True), "foo:val") | ||
203 | |||
204 | def test_append(self): | ||
205 | self.d.setVar("TEST", "${VAL}") | ||
206 | self.d.appendVar("TEST", ":${BAR}") | ||
207 | self.assertEqual(self.d.getVar("TEST", True), "val:bar") | ||
208 | |||
209 | def test_multiple_append(self): | ||
210 | self.d.setVar("TEST", "${VAL}") | ||
211 | self.d.prependVar("TEST", "${FOO}:") | ||
212 | self.d.appendVar("TEST", ":val2") | ||
213 | self.d.appendVar("TEST", ":${BAR}") | ||
214 | self.assertEqual(self.d.getVar("TEST", True), "foo:val:val2:bar") | ||
215 | |||
216 | class TestConcatOverride(unittest.TestCase): | ||
217 | def setUp(self): | ||
218 | self.d = bb.data.init() | ||
219 | self.d.setVar("FOO", "foo") | ||
220 | self.d.setVar("VAL", "val") | ||
221 | self.d.setVar("BAR", "bar") | ||
222 | |||
223 | def test_prepend(self): | ||
224 | self.d.setVar("TEST", "${VAL}") | ||
225 | self.d.setVar("TEST_prepend", "${FOO}:") | ||
226 | bb.data.update_data(self.d) | ||
227 | self.assertEqual(self.d.getVar("TEST", True), "foo:val") | ||
228 | |||
229 | def test_append(self): | ||
230 | self.d.setVar("TEST", "${VAL}") | ||
231 | self.d.setVar("TEST_append", ":${BAR}") | ||
232 | bb.data.update_data(self.d) | ||
233 | self.assertEqual(self.d.getVar("TEST", True), "val:bar") | ||
234 | |||
235 | def test_multiple_append(self): | ||
236 | self.d.setVar("TEST", "${VAL}") | ||
237 | self.d.setVar("TEST_prepend", "${FOO}:") | ||
238 | self.d.setVar("TEST_append", ":val2") | ||
239 | self.d.setVar("TEST_append", ":${BAR}") | ||
240 | bb.data.update_data(self.d) | ||
241 | self.assertEqual(self.d.getVar("TEST", True), "foo:val:val2:bar") | ||
242 | |||
243 | def test_remove(self): | ||
244 | self.d.setVar("TEST", "${VAL} ${BAR}") | ||
245 | self.d.setVar("TEST_remove", "val") | ||
246 | bb.data.update_data(self.d) | ||
247 | self.assertEqual(self.d.getVar("TEST", True), "bar") | ||
248 | |||
249 | def test_doubleref_remove(self): | ||
250 | self.d.setVar("TEST", "${VAL} ${BAR}") | ||
251 | self.d.setVar("TEST_remove", "val") | ||
252 | self.d.setVar("TEST_TEST", "${TEST} ${TEST}") | ||
253 | bb.data.update_data(self.d) | ||
254 | self.assertEqual(self.d.getVar("TEST_TEST", True), "bar bar") | ||
255 | |||
256 | def test_empty_remove(self): | ||
257 | self.d.setVar("TEST", "") | ||
258 | self.d.setVar("TEST_remove", "val") | ||
259 | bb.data.update_data(self.d) | ||
260 | self.assertEqual(self.d.getVar("TEST", True), "") | ||
261 | |||
262 | def test_remove_expansion(self): | ||
263 | self.d.setVar("BAR", "Z") | ||
264 | self.d.setVar("TEST", "${BAR}/X Y") | ||
265 | self.d.setVar("TEST_remove", "${BAR}/X") | ||
266 | bb.data.update_data(self.d) | ||
267 | self.assertEqual(self.d.getVar("TEST", True), "Y") | ||
268 | |||
269 | def test_remove_expansion_items(self): | ||
270 | self.d.setVar("TEST", "A B C D") | ||
271 | self.d.setVar("BAR", "B D") | ||
272 | self.d.setVar("TEST_remove", "${BAR}") | ||
273 | bb.data.update_data(self.d) | ||
274 | self.assertEqual(self.d.getVar("TEST", True), "A C") | ||
275 | |||
276 | class TestOverrides(unittest.TestCase): | ||
277 | def setUp(self): | ||
278 | self.d = bb.data.init() | ||
279 | self.d.setVar("OVERRIDES", "foo:bar:local") | ||
280 | self.d.setVar("TEST", "testvalue") | ||
281 | |||
282 | def test_no_override(self): | ||
283 | bb.data.update_data(self.d) | ||
284 | self.assertEqual(self.d.getVar("TEST", True), "testvalue") | ||
285 | |||
286 | def test_one_override(self): | ||
287 | self.d.setVar("TEST_bar", "testvalue2") | ||
288 | bb.data.update_data(self.d) | ||
289 | self.assertEqual(self.d.getVar("TEST", True), "testvalue2") | ||
290 | |||
291 | def test_multiple_override(self): | ||
292 | self.d.setVar("TEST_bar", "testvalue2") | ||
293 | self.d.setVar("TEST_local", "testvalue3") | ||
294 | self.d.setVar("TEST_foo", "testvalue4") | ||
295 | bb.data.update_data(self.d) | ||
296 | self.assertEqual(self.d.getVar("TEST", True), "testvalue3") | ||
297 | |||
298 | |||
299 | class TestFlags(unittest.TestCase): | ||
300 | def setUp(self): | ||
301 | self.d = bb.data.init() | ||
302 | self.d.setVar("foo", "value of foo") | ||
303 | self.d.setVarFlag("foo", "flag1", "value of flag1") | ||
304 | self.d.setVarFlag("foo", "flag2", "value of flag2") | ||
305 | |||
306 | def test_setflag(self): | ||
307 | self.assertEqual(self.d.getVarFlag("foo", "flag1"), "value of flag1") | ||
308 | self.assertEqual(self.d.getVarFlag("foo", "flag2"), "value of flag2") | ||
309 | |||
310 | def test_delflag(self): | ||
311 | self.d.delVarFlag("foo", "flag2") | ||
312 | self.assertEqual(self.d.getVarFlag("foo", "flag1"), "value of flag1") | ||
313 | self.assertEqual(self.d.getVarFlag("foo", "flag2"), None) | ||
314 | |||
315 | |||
316 | class Contains(unittest.TestCase): | ||
317 | def setUp(self): | ||
318 | self.d = bb.data.init() | ||
319 | self.d.setVar("SOMEFLAG", "a b c") | ||
320 | |||
321 | def test_contains(self): | ||
322 | self.assertTrue(bb.utils.contains("SOMEFLAG", "a", True, False, self.d)) | ||
323 | self.assertTrue(bb.utils.contains("SOMEFLAG", "b", True, False, self.d)) | ||
324 | self.assertTrue(bb.utils.contains("SOMEFLAG", "c", True, False, self.d)) | ||
325 | |||
326 | self.assertTrue(bb.utils.contains("SOMEFLAG", "a b", True, False, self.d)) | ||
327 | self.assertTrue(bb.utils.contains("SOMEFLAG", "b c", True, False, self.d)) | ||
328 | self.assertTrue(bb.utils.contains("SOMEFLAG", "c a", True, False, self.d)) | ||
329 | |||
330 | self.assertTrue(bb.utils.contains("SOMEFLAG", "a b c", True, False, self.d)) | ||
331 | self.assertTrue(bb.utils.contains("SOMEFLAG", "c b a", True, False, self.d)) | ||
332 | |||
333 | self.assertFalse(bb.utils.contains("SOMEFLAG", "x", True, False, self.d)) | ||
334 | self.assertFalse(bb.utils.contains("SOMEFLAG", "a x", True, False, self.d)) | ||
335 | self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b", True, False, self.d)) | ||
336 | self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b a", True, False, self.d)) | ||
337 | |||
338 | def test_contains_any(self): | ||
339 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a", True, False, self.d)) | ||
340 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b", True, False, self.d)) | ||
341 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c", True, False, self.d)) | ||
342 | |||
343 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a b", True, False, self.d)) | ||
344 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b c", True, False, self.d)) | ||
345 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c a", True, False, self.d)) | ||
346 | |||
347 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a x", True, False, self.d)) | ||
348 | self.assertTrue(bb.utils.contains_any("SOMEFLAG", "x c", True, False, self.d)) | ||
349 | |||
350 | self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x", True, False, self.d)) | ||
351 | self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x y z", True, False, self.d)) | ||