data.py 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446
  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. import unittest
  23. import bb
  24. import bb.data
  25. import bb.parse
  26. import logging
  27. class LogRecord():
  28. def __enter__(self):
  29. logs = []
  30. class LogHandler(logging.Handler):
  31. def emit(self, record):
  32. logs.append(record)
  33. logger = logging.getLogger("BitBake")
  34. handler = LogHandler()
  35. self.handler = handler
  36. logger.addHandler(handler)
  37. return logs
  38. def __exit__(self, type, value, traceback):
  39. logger = logging.getLogger("BitBake")
  40. logger.removeHandler(self.handler)
  41. return
  42. def logContains(item, logs):
  43. for l in logs:
  44. m = l.getMessage()
  45. if item in m:
  46. return True
  47. return False
  48. class DataExpansions(unittest.TestCase):
  49. def setUp(self):
  50. self.d = bb.data.init()
  51. self.d["foo"] = "value_of_foo"
  52. self.d["bar"] = "value_of_bar"
  53. self.d["value_of_foo"] = "value_of_'value_of_foo'"
  54. def test_one_var(self):
  55. val = self.d.expand("${foo}")
  56. self.assertEqual(str(val), "value_of_foo")
  57. def test_indirect_one_var(self):
  58. val = self.d.expand("${${foo}}")
  59. self.assertEqual(str(val), "value_of_'value_of_foo'")
  60. def test_indirect_and_another(self):
  61. val = self.d.expand("${${foo}} ${bar}")
  62. self.assertEqual(str(val), "value_of_'value_of_foo' value_of_bar")
  63. def test_python_snippet(self):
  64. val = self.d.expand("${@5*12}")
  65. self.assertEqual(str(val), "60")
  66. def test_expand_in_python_snippet(self):
  67. val = self.d.expand("${@'boo ' + '${foo}'}")
  68. self.assertEqual(str(val), "boo value_of_foo")
  69. def test_python_snippet_getvar(self):
  70. val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}")
  71. self.assertEqual(str(val), "value_of_foo value_of_bar")
  72. def test_python_unexpanded(self):
  73. self.d.setVar("bar", "${unsetvar}")
  74. val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}")
  75. self.assertEqual(str(val), "${@d.getVar('foo', True) + ' ${unsetvar}'}")
  76. def test_python_snippet_syntax_error(self):
  77. self.d.setVar("FOO", "${@foo = 5}")
  78. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  79. def test_python_snippet_runtime_error(self):
  80. self.d.setVar("FOO", "${@int('test')}")
  81. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  82. def test_python_snippet_error_path(self):
  83. self.d.setVar("FOO", "foo value ${BAR}")
  84. self.d.setVar("BAR", "bar value ${@int('test')}")
  85. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  86. def test_value_containing_value(self):
  87. val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}")
  88. self.assertEqual(str(val), "value_of_foo value_of_bar")
  89. def test_reference_undefined_var(self):
  90. val = self.d.expand("${undefinedvar} meh")
  91. self.assertEqual(str(val), "${undefinedvar} meh")
  92. def test_double_reference(self):
  93. self.d.setVar("BAR", "bar value")
  94. self.d.setVar("FOO", "${BAR} foo ${BAR}")
  95. val = self.d.getVar("FOO", True)
  96. self.assertEqual(str(val), "bar value foo bar value")
  97. def test_direct_recursion(self):
  98. self.d.setVar("FOO", "${FOO}")
  99. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  100. def test_indirect_recursion(self):
  101. self.d.setVar("FOO", "${BAR}")
  102. self.d.setVar("BAR", "${BAZ}")
  103. self.d.setVar("BAZ", "${FOO}")
  104. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  105. def test_recursion_exception(self):
  106. self.d.setVar("FOO", "${BAR}")
  107. self.d.setVar("BAR", "${${@'FOO'}}")
  108. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  109. def test_incomplete_varexp_single_quotes(self):
  110. self.d.setVar("FOO", "sed -i -e 's:IP{:I${:g' $pc")
  111. val = self.d.getVar("FOO", True)
  112. self.assertEqual(str(val), "sed -i -e 's:IP{:I${:g' $pc")
  113. def test_nonstring(self):
  114. self.d.setVar("TEST", 5)
  115. val = self.d.getVar("TEST", True)
  116. self.assertEqual(str(val), "5")
  117. def test_rename(self):
  118. self.d.renameVar("foo", "newfoo")
  119. self.assertEqual(self.d.getVar("newfoo", False), "value_of_foo")
  120. self.assertEqual(self.d.getVar("foo", False), None)
  121. def test_deletion(self):
  122. self.d.delVar("foo")
  123. self.assertEqual(self.d.getVar("foo", False), None)
  124. def test_keys(self):
  125. keys = list(self.d.keys())
  126. self.assertCountEqual(keys, ['value_of_foo', 'foo', 'bar'])
  127. def test_keys_deletion(self):
  128. newd = bb.data.createCopy(self.d)
  129. newd.delVar("bar")
  130. keys = list(newd.keys())
  131. self.assertCountEqual(keys, ['value_of_foo', 'foo'])
  132. class TestNestedExpansions(unittest.TestCase):
  133. def setUp(self):
  134. self.d = bb.data.init()
  135. self.d["foo"] = "foo"
  136. self.d["bar"] = "bar"
  137. self.d["value_of_foobar"] = "187"
  138. def test_refs(self):
  139. val = self.d.expand("${value_of_${foo}${bar}}")
  140. self.assertEqual(str(val), "187")
  141. #def test_python_refs(self):
  142. # val = self.d.expand("${@${@3}**2 + ${@4}**2}")
  143. # self.assertEqual(str(val), "25")
  144. def test_ref_in_python_ref(self):
  145. val = self.d.expand("${@'${foo}' + 'bar'}")
  146. self.assertEqual(str(val), "foobar")
  147. def test_python_ref_in_ref(self):
  148. val = self.d.expand("${${@'f'+'o'+'o'}}")
  149. self.assertEqual(str(val), "foo")
  150. def test_deep_nesting(self):
  151. depth = 100
  152. val = self.d.expand("${" * depth + "foo" + "}" * depth)
  153. self.assertEqual(str(val), "foo")
  154. #def test_deep_python_nesting(self):
  155. # depth = 50
  156. # val = self.d.expand("${@" * depth + "1" + "+1}" * depth)
  157. # self.assertEqual(str(val), str(depth + 1))
  158. def test_mixed(self):
  159. val = self.d.expand("${value_of_${@('${foo}'+'bar')[0:3]}${${@'BAR'.lower()}}}")
  160. self.assertEqual(str(val), "187")
  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. class TestMemoize(unittest.TestCase):
  165. def test_memoized(self):
  166. d = bb.data.init()
  167. d.setVar("FOO", "bar")
  168. self.assertTrue(d.getVar("FOO", False) is d.getVar("FOO", False))
  169. def test_not_memoized(self):
  170. d1 = bb.data.init()
  171. d2 = bb.data.init()
  172. d1.setVar("FOO", "bar")
  173. d2.setVar("FOO", "bar2")
  174. self.assertTrue(d1.getVar("FOO", False) is not d2.getVar("FOO", False))
  175. def test_changed_after_memoized(self):
  176. d = bb.data.init()
  177. d.setVar("foo", "value of foo")
  178. self.assertEqual(str(d.getVar("foo", False)), "value of foo")
  179. d.setVar("foo", "second value of foo")
  180. self.assertEqual(str(d.getVar("foo", False)), "second value of foo")
  181. def test_same_value(self):
  182. d = bb.data.init()
  183. d.setVar("foo", "value of")
  184. d.setVar("bar", "value of")
  185. self.assertEqual(d.getVar("foo", False),
  186. d.getVar("bar", False))
  187. class TestConcat(unittest.TestCase):
  188. def setUp(self):
  189. self.d = bb.data.init()
  190. self.d.setVar("FOO", "foo")
  191. self.d.setVar("VAL", "val")
  192. self.d.setVar("BAR", "bar")
  193. def test_prepend(self):
  194. self.d.setVar("TEST", "${VAL}")
  195. self.d.prependVar("TEST", "${FOO}:")
  196. self.assertEqual(self.d.getVar("TEST", True), "foo:val")
  197. def test_append(self):
  198. self.d.setVar("TEST", "${VAL}")
  199. self.d.appendVar("TEST", ":${BAR}")
  200. self.assertEqual(self.d.getVar("TEST", True), "val:bar")
  201. def test_multiple_append(self):
  202. self.d.setVar("TEST", "${VAL}")
  203. self.d.prependVar("TEST", "${FOO}:")
  204. self.d.appendVar("TEST", ":val2")
  205. self.d.appendVar("TEST", ":${BAR}")
  206. self.assertEqual(self.d.getVar("TEST", True), "foo:val:val2:bar")
  207. class TestConcatOverride(unittest.TestCase):
  208. def setUp(self):
  209. self.d = bb.data.init()
  210. self.d.setVar("FOO", "foo")
  211. self.d.setVar("VAL", "val")
  212. self.d.setVar("BAR", "bar")
  213. def test_prepend(self):
  214. self.d.setVar("TEST", "${VAL}")
  215. self.d.setVar("TEST_prepend", "${FOO}:")
  216. bb.data.update_data(self.d)
  217. self.assertEqual(self.d.getVar("TEST", True), "foo:val")
  218. def test_append(self):
  219. self.d.setVar("TEST", "${VAL}")
  220. self.d.setVar("TEST_append", ":${BAR}")
  221. bb.data.update_data(self.d)
  222. self.assertEqual(self.d.getVar("TEST", True), "val:bar")
  223. def test_multiple_append(self):
  224. self.d.setVar("TEST", "${VAL}")
  225. self.d.setVar("TEST_prepend", "${FOO}:")
  226. self.d.setVar("TEST_append", ":val2")
  227. self.d.setVar("TEST_append", ":${BAR}")
  228. bb.data.update_data(self.d)
  229. self.assertEqual(self.d.getVar("TEST", True), "foo:val:val2:bar")
  230. def test_append_unset(self):
  231. self.d.setVar("TEST_prepend", "${FOO}:")
  232. self.d.setVar("TEST_append", ":val2")
  233. self.d.setVar("TEST_append", ":${BAR}")
  234. bb.data.update_data(self.d)
  235. self.assertEqual(self.d.getVar("TEST", True), "foo::val2:bar")
  236. def test_remove(self):
  237. self.d.setVar("TEST", "${VAL} ${BAR}")
  238. self.d.setVar("TEST_remove", "val")
  239. bb.data.update_data(self.d)
  240. self.assertEqual(self.d.getVar("TEST", True), "bar")
  241. def test_doubleref_remove(self):
  242. self.d.setVar("TEST", "${VAL} ${BAR}")
  243. self.d.setVar("TEST_remove", "val")
  244. self.d.setVar("TEST_TEST", "${TEST} ${TEST}")
  245. bb.data.update_data(self.d)
  246. self.assertEqual(self.d.getVar("TEST_TEST", True), "bar bar")
  247. def test_empty_remove(self):
  248. self.d.setVar("TEST", "")
  249. self.d.setVar("TEST_remove", "val")
  250. bb.data.update_data(self.d)
  251. self.assertEqual(self.d.getVar("TEST", True), "")
  252. def test_remove_expansion(self):
  253. self.d.setVar("BAR", "Z")
  254. self.d.setVar("TEST", "${BAR}/X Y")
  255. self.d.setVar("TEST_remove", "${BAR}/X")
  256. bb.data.update_data(self.d)
  257. self.assertEqual(self.d.getVar("TEST", True), "Y")
  258. def test_remove_expansion_items(self):
  259. self.d.setVar("TEST", "A B C D")
  260. self.d.setVar("BAR", "B D")
  261. self.d.setVar("TEST_remove", "${BAR}")
  262. bb.data.update_data(self.d)
  263. self.assertEqual(self.d.getVar("TEST", True), "A C")
  264. class TestOverrides(unittest.TestCase):
  265. def setUp(self):
  266. self.d = bb.data.init()
  267. self.d.setVar("OVERRIDES", "foo:bar:local")
  268. self.d.setVar("TEST", "testvalue")
  269. def test_no_override(self):
  270. bb.data.update_data(self.d)
  271. self.assertEqual(self.d.getVar("TEST", True), "testvalue")
  272. def test_one_override(self):
  273. self.d.setVar("TEST_bar", "testvalue2")
  274. bb.data.update_data(self.d)
  275. self.assertEqual(self.d.getVar("TEST", True), "testvalue2")
  276. def test_one_override_unset(self):
  277. self.d.setVar("TEST2_bar", "testvalue2")
  278. bb.data.update_data(self.d)
  279. self.assertEqual(self.d.getVar("TEST2", True), "testvalue2")
  280. self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST2', 'OVERRIDES', 'TEST2_bar'])
  281. def test_multiple_override(self):
  282. self.d.setVar("TEST_bar", "testvalue2")
  283. self.d.setVar("TEST_local", "testvalue3")
  284. self.d.setVar("TEST_foo", "testvalue4")
  285. bb.data.update_data(self.d)
  286. self.assertEqual(self.d.getVar("TEST", True), "testvalue3")
  287. self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST_foo', 'OVERRIDES', 'TEST_bar', 'TEST_local'])
  288. def test_multiple_combined_overrides(self):
  289. self.d.setVar("TEST_local_foo_bar", "testvalue3")
  290. bb.data.update_data(self.d)
  291. self.assertEqual(self.d.getVar("TEST", True), "testvalue3")
  292. def test_multiple_overrides_unset(self):
  293. self.d.setVar("TEST2_local_foo_bar", "testvalue3")
  294. bb.data.update_data(self.d)
  295. self.assertEqual(self.d.getVar("TEST2", True), "testvalue3")
  296. def test_keyexpansion_override(self):
  297. self.d.setVar("LOCAL", "local")
  298. self.d.setVar("TEST_bar", "testvalue2")
  299. self.d.setVar("TEST_${LOCAL}", "testvalue3")
  300. self.d.setVar("TEST_foo", "testvalue4")
  301. bb.data.update_data(self.d)
  302. bb.data.expandKeys(self.d)
  303. self.assertEqual(self.d.getVar("TEST", True), "testvalue3")
  304. def test_rename_override(self):
  305. self.d.setVar("ALTERNATIVE_ncurses-tools_class-target", "a")
  306. self.d.setVar("OVERRIDES", "class-target")
  307. bb.data.update_data(self.d)
  308. self.d.renameVar("ALTERNATIVE_ncurses-tools", "ALTERNATIVE_lib32-ncurses-tools")
  309. self.assertEqual(self.d.getVar("ALTERNATIVE_lib32-ncurses-tools", True), "a")
  310. def test_underscore_override(self):
  311. self.d.setVar("TEST_bar", "testvalue2")
  312. self.d.setVar("TEST_some_val", "testvalue3")
  313. self.d.setVar("TEST_foo", "testvalue4")
  314. self.d.setVar("OVERRIDES", "foo:bar:some_val")
  315. self.assertEqual(self.d.getVar("TEST", True), "testvalue3")
  316. class TestKeyExpansion(unittest.TestCase):
  317. def setUp(self):
  318. self.d = bb.data.init()
  319. self.d.setVar("FOO", "foo")
  320. self.d.setVar("BAR", "foo")
  321. def test_keyexpand(self):
  322. self.d.setVar("VAL_${FOO}", "A")
  323. self.d.setVar("VAL_${BAR}", "B")
  324. with LogRecord() as logs:
  325. bb.data.expandKeys(self.d)
  326. self.assertTrue(logContains("Variable key VAL_${FOO} (A) replaces original key VAL_foo (B)", logs))
  327. self.assertEqual(self.d.getVar("VAL_foo", True), "A")
  328. class TestFlags(unittest.TestCase):
  329. def setUp(self):
  330. self.d = bb.data.init()
  331. self.d.setVar("foo", "value of foo")
  332. self.d.setVarFlag("foo", "flag1", "value of flag1")
  333. self.d.setVarFlag("foo", "flag2", "value of flag2")
  334. def test_setflag(self):
  335. self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
  336. self.assertEqual(self.d.getVarFlag("foo", "flag2", False), "value of flag2")
  337. def test_delflag(self):
  338. self.d.delVarFlag("foo", "flag2")
  339. self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
  340. self.assertEqual(self.d.getVarFlag("foo", "flag2", False), None)
  341. class Contains(unittest.TestCase):
  342. def setUp(self):
  343. self.d = bb.data.init()
  344. self.d.setVar("SOMEFLAG", "a b c")
  345. def test_contains(self):
  346. self.assertTrue(bb.utils.contains("SOMEFLAG", "a", True, False, self.d))
  347. self.assertTrue(bb.utils.contains("SOMEFLAG", "b", True, False, self.d))
  348. self.assertTrue(bb.utils.contains("SOMEFLAG", "c", True, False, self.d))
  349. self.assertTrue(bb.utils.contains("SOMEFLAG", "a b", True, False, self.d))
  350. self.assertTrue(bb.utils.contains("SOMEFLAG", "b c", True, False, self.d))
  351. self.assertTrue(bb.utils.contains("SOMEFLAG", "c a", True, False, self.d))
  352. self.assertTrue(bb.utils.contains("SOMEFLAG", "a b c", True, False, self.d))
  353. self.assertTrue(bb.utils.contains("SOMEFLAG", "c b a", True, False, self.d))
  354. self.assertFalse(bb.utils.contains("SOMEFLAG", "x", True, False, self.d))
  355. self.assertFalse(bb.utils.contains("SOMEFLAG", "a x", True, False, self.d))
  356. self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b", True, False, self.d))
  357. self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b a", True, False, self.d))
  358. def test_contains_any(self):
  359. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a", True, False, self.d))
  360. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b", True, False, self.d))
  361. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c", True, False, self.d))
  362. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a b", True, False, self.d))
  363. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b c", True, False, self.d))
  364. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c a", True, False, self.d))
  365. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a x", True, False, self.d))
  366. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "x c", True, False, self.d))
  367. self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x", True, False, self.d))
  368. self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x y z", True, False, self.d))