data.py 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687
  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. # SPDX-License-Identifier: GPL-2.0-only
  10. #
  11. # This program is free software; you can redistribute it and/or modify
  12. # it under the terms of the GNU General Public License version 2 as
  13. # published by the Free Software Foundation.
  14. #
  15. # This program is distributed in the hope that it will be useful,
  16. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. # GNU General Public License for more details.
  19. #
  20. # You should have received a copy of the GNU General Public License along
  21. # with this program; if not, write to the Free Software Foundation, Inc.,
  22. # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  23. #
  24. import unittest
  25. import bb
  26. import bb.data
  27. import bb.parse
  28. import logging
  29. class LogRecord():
  30. def __enter__(self):
  31. logs = []
  32. class LogHandler(logging.Handler):
  33. def emit(self, record):
  34. logs.append(record)
  35. logger = logging.getLogger("BitBake")
  36. handler = LogHandler()
  37. self.handler = handler
  38. logger.addHandler(handler)
  39. return logs
  40. def __exit__(self, type, value, traceback):
  41. logger = logging.getLogger("BitBake")
  42. logger.removeHandler(self.handler)
  43. return
  44. def logContains(item, logs):
  45. for l in logs:
  46. m = l.getMessage()
  47. if item in m:
  48. return True
  49. return False
  50. class DataExpansions(unittest.TestCase):
  51. def setUp(self):
  52. self.d = bb.data.init()
  53. self.d["foo"] = "value_of_foo"
  54. self.d["bar"] = "value_of_bar"
  55. self.d["value_of_foo"] = "value_of_'value_of_foo'"
  56. def test_one_var(self):
  57. val = self.d.expand("${foo}")
  58. self.assertEqual(str(val), "value_of_foo")
  59. def test_indirect_one_var(self):
  60. val = self.d.expand("${${foo}}")
  61. self.assertEqual(str(val), "value_of_'value_of_foo'")
  62. def test_indirect_and_another(self):
  63. val = self.d.expand("${${foo}} ${bar}")
  64. self.assertEqual(str(val), "value_of_'value_of_foo' value_of_bar")
  65. def test_python_snippet(self):
  66. val = self.d.expand("${@5*12}")
  67. self.assertEqual(str(val), "60")
  68. def test_expand_in_python_snippet(self):
  69. val = self.d.expand("${@'boo ' + '${foo}'}")
  70. self.assertEqual(str(val), "boo value_of_foo")
  71. def test_python_snippet_getvar(self):
  72. val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
  73. self.assertEqual(str(val), "value_of_foo value_of_bar")
  74. def test_python_unexpanded(self):
  75. self.d.setVar("bar", "${unsetvar}")
  76. val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
  77. self.assertEqual(str(val), "${@d.getVar('foo') + ' ${unsetvar}'}")
  78. def test_python_snippet_syntax_error(self):
  79. self.d.setVar("FOO", "${@foo = 5}")
  80. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  81. def test_python_snippet_runtime_error(self):
  82. self.d.setVar("FOO", "${@int('test')}")
  83. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  84. def test_python_snippet_error_path(self):
  85. self.d.setVar("FOO", "foo value ${BAR}")
  86. self.d.setVar("BAR", "bar value ${@int('test')}")
  87. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  88. def test_value_containing_value(self):
  89. val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
  90. self.assertEqual(str(val), "value_of_foo value_of_bar")
  91. def test_reference_undefined_var(self):
  92. val = self.d.expand("${undefinedvar} meh")
  93. self.assertEqual(str(val), "${undefinedvar} meh")
  94. def test_double_reference(self):
  95. self.d.setVar("BAR", "bar value")
  96. self.d.setVar("FOO", "${BAR} foo ${BAR}")
  97. val = self.d.getVar("FOO")
  98. self.assertEqual(str(val), "bar value foo bar value")
  99. def test_direct_recursion(self):
  100. self.d.setVar("FOO", "${FOO}")
  101. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  102. def test_indirect_recursion(self):
  103. self.d.setVar("FOO", "${BAR}")
  104. self.d.setVar("BAR", "${BAZ}")
  105. self.d.setVar("BAZ", "${FOO}")
  106. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  107. def test_recursion_exception(self):
  108. self.d.setVar("FOO", "${BAR}")
  109. self.d.setVar("BAR", "${${@'FOO'}}")
  110. self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
  111. def test_incomplete_varexp_single_quotes(self):
  112. self.d.setVar("FOO", "sed -i -e 's:IP{:I${:g' $pc")
  113. val = self.d.getVar("FOO")
  114. self.assertEqual(str(val), "sed -i -e 's:IP{:I${:g' $pc")
  115. def test_nonstring(self):
  116. self.d.setVar("TEST", 5)
  117. val = self.d.getVar("TEST")
  118. self.assertEqual(str(val), "5")
  119. def test_rename(self):
  120. self.d.renameVar("foo", "newfoo")
  121. self.assertEqual(self.d.getVar("newfoo", False), "value_of_foo")
  122. self.assertEqual(self.d.getVar("foo", False), None)
  123. def test_deletion(self):
  124. self.d.delVar("foo")
  125. self.assertEqual(self.d.getVar("foo", False), None)
  126. def test_keys(self):
  127. keys = list(self.d.keys())
  128. self.assertCountEqual(keys, ['value_of_foo', 'foo', 'bar'])
  129. def test_keys_deletion(self):
  130. newd = bb.data.createCopy(self.d)
  131. newd.delVar("bar")
  132. keys = list(newd.keys())
  133. self.assertCountEqual(keys, ['value_of_foo', 'foo'])
  134. class TestNestedExpansions(unittest.TestCase):
  135. def setUp(self):
  136. self.d = bb.data.init()
  137. self.d["foo"] = "foo"
  138. self.d["bar"] = "bar"
  139. self.d["value_of_foobar"] = "187"
  140. def test_refs(self):
  141. val = self.d.expand("${value_of_${foo}${bar}}")
  142. self.assertEqual(str(val), "187")
  143. #def test_python_refs(self):
  144. # val = self.d.expand("${@${@3}**2 + ${@4}**2}")
  145. # self.assertEqual(str(val), "25")
  146. def test_ref_in_python_ref(self):
  147. val = self.d.expand("${@'${foo}' + 'bar'}")
  148. self.assertEqual(str(val), "foobar")
  149. def test_python_ref_in_ref(self):
  150. val = self.d.expand("${${@'f'+'o'+'o'}}")
  151. self.assertEqual(str(val), "foo")
  152. def test_deep_nesting(self):
  153. depth = 100
  154. val = self.d.expand("${" * depth + "foo" + "}" * depth)
  155. self.assertEqual(str(val), "foo")
  156. #def test_deep_python_nesting(self):
  157. # depth = 50
  158. # val = self.d.expand("${@" * depth + "1" + "+1}" * depth)
  159. # self.assertEqual(str(val), str(depth + 1))
  160. def test_mixed(self):
  161. val = self.d.expand("${value_of_${@('${foo}'+'bar')[0:3]}${${@'BAR'.lower()}}}")
  162. self.assertEqual(str(val), "187")
  163. def test_runtime(self):
  164. val = self.d.expand("${${@'value_of' + '_f'+'o'+'o'+'b'+'a'+'r'}}")
  165. self.assertEqual(str(val), "187")
  166. class TestMemoize(unittest.TestCase):
  167. def test_memoized(self):
  168. d = bb.data.init()
  169. d.setVar("FOO", "bar")
  170. self.assertTrue(d.getVar("FOO", False) is d.getVar("FOO", False))
  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", False) is not d2.getVar("FOO", False))
  177. def test_changed_after_memoized(self):
  178. d = bb.data.init()
  179. d.setVar("foo", "value of foo")
  180. self.assertEqual(str(d.getVar("foo", False)), "value of foo")
  181. d.setVar("foo", "second value of foo")
  182. self.assertEqual(str(d.getVar("foo", False)), "second value of foo")
  183. def test_same_value(self):
  184. d = bb.data.init()
  185. d.setVar("foo", "value of")
  186. d.setVar("bar", "value of")
  187. self.assertEqual(d.getVar("foo", False),
  188. d.getVar("bar", False))
  189. class TestConcat(unittest.TestCase):
  190. def setUp(self):
  191. self.d = bb.data.init()
  192. self.d.setVar("FOO", "foo")
  193. self.d.setVar("VAL", "val")
  194. self.d.setVar("BAR", "bar")
  195. def test_prepend(self):
  196. self.d.setVar("TEST", "${VAL}")
  197. self.d.prependVar("TEST", "${FOO}:")
  198. self.assertEqual(self.d.getVar("TEST"), "foo:val")
  199. def test_append(self):
  200. self.d.setVar("TEST", "${VAL}")
  201. self.d.appendVar("TEST", ":${BAR}")
  202. self.assertEqual(self.d.getVar("TEST"), "val:bar")
  203. def test_multiple_append(self):
  204. self.d.setVar("TEST", "${VAL}")
  205. self.d.prependVar("TEST", "${FOO}:")
  206. self.d.appendVar("TEST", ":val2")
  207. self.d.appendVar("TEST", ":${BAR}")
  208. self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
  209. class TestConcatOverride(unittest.TestCase):
  210. def setUp(self):
  211. self.d = bb.data.init()
  212. self.d.setVar("FOO", "foo")
  213. self.d.setVar("VAL", "val")
  214. self.d.setVar("BAR", "bar")
  215. def test_prepend(self):
  216. self.d.setVar("TEST", "${VAL}")
  217. self.d.setVar("TEST_prepend", "${FOO}:")
  218. self.assertEqual(self.d.getVar("TEST"), "foo:val")
  219. def test_append(self):
  220. self.d.setVar("TEST", "${VAL}")
  221. self.d.setVar("TEST_append", ":${BAR}")
  222. self.assertEqual(self.d.getVar("TEST"), "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. self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
  229. def test_append_unset(self):
  230. self.d.setVar("TEST_prepend", "${FOO}:")
  231. self.d.setVar("TEST_append", ":val2")
  232. self.d.setVar("TEST_append", ":${BAR}")
  233. self.assertEqual(self.d.getVar("TEST"), "foo::val2:bar")
  234. def test_remove(self):
  235. self.d.setVar("TEST", "${VAL} ${BAR}")
  236. self.d.setVar("TEST_remove", "val")
  237. self.assertEqual(self.d.getVar("TEST"), " bar")
  238. def test_remove_cleared(self):
  239. self.d.setVar("TEST", "${VAL} ${BAR}")
  240. self.d.setVar("TEST_remove", "val")
  241. self.d.setVar("TEST", "${VAL} ${BAR}")
  242. self.assertEqual(self.d.getVar("TEST"), "val bar")
  243. # Ensure the value is unchanged if we have an inactive remove override
  244. # (including that whitespace is preserved)
  245. def test_remove_inactive_override(self):
  246. self.d.setVar("TEST", "${VAL} ${BAR} 123")
  247. self.d.setVar("TEST_remove_inactiveoverride", "val")
  248. self.assertEqual(self.d.getVar("TEST"), "val bar 123")
  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. self.assertEqual(self.d.getVar("TEST_TEST"), " bar bar")
  254. def test_empty_remove(self):
  255. self.d.setVar("TEST", "")
  256. self.d.setVar("TEST_remove", "val")
  257. self.assertEqual(self.d.getVar("TEST"), "")
  258. def test_remove_expansion(self):
  259. self.d.setVar("BAR", "Z")
  260. self.d.setVar("TEST", "${BAR}/X Y")
  261. self.d.setVar("TEST_remove", "${BAR}/X")
  262. self.assertEqual(self.d.getVar("TEST"), " Y")
  263. def test_remove_expansion_items(self):
  264. self.d.setVar("TEST", "A B C D")
  265. self.d.setVar("BAR", "B D")
  266. self.d.setVar("TEST_remove", "${BAR}")
  267. self.assertEqual(self.d.getVar("TEST"), "A C ")
  268. def test_remove_preserve_whitespace(self):
  269. # When the removal isn't active, the original value should be preserved
  270. self.d.setVar("TEST", " A B")
  271. self.d.setVar("TEST_remove", "C")
  272. self.assertEqual(self.d.getVar("TEST"), " A B")
  273. def test_remove_preserve_whitespace2(self):
  274. # When the removal is active preserve the whitespace
  275. self.d.setVar("TEST", " A B")
  276. self.d.setVar("TEST_remove", "B")
  277. self.assertEqual(self.d.getVar("TEST"), " A ")
  278. class TestOverrides(unittest.TestCase):
  279. def setUp(self):
  280. self.d = bb.data.init()
  281. self.d.setVar("OVERRIDES", "foo:bar:local")
  282. self.d.setVar("TEST", "testvalue")
  283. def test_no_override(self):
  284. self.assertEqual(self.d.getVar("TEST"), "testvalue")
  285. def test_one_override(self):
  286. self.d.setVar("TEST_bar", "testvalue2")
  287. self.assertEqual(self.d.getVar("TEST"), "testvalue2")
  288. def test_one_override_unset(self):
  289. self.d.setVar("TEST2_bar", "testvalue2")
  290. self.assertEqual(self.d.getVar("TEST2"), "testvalue2")
  291. self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST2', 'OVERRIDES', 'TEST2_bar'])
  292. def test_multiple_override(self):
  293. self.d.setVar("TEST_bar", "testvalue2")
  294. self.d.setVar("TEST_local", "testvalue3")
  295. self.d.setVar("TEST_foo", "testvalue4")
  296. self.assertEqual(self.d.getVar("TEST"), "testvalue3")
  297. self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST_foo', 'OVERRIDES', 'TEST_bar', 'TEST_local'])
  298. def test_multiple_combined_overrides(self):
  299. self.d.setVar("TEST_local_foo_bar", "testvalue3")
  300. self.assertEqual(self.d.getVar("TEST"), "testvalue3")
  301. def test_multiple_overrides_unset(self):
  302. self.d.setVar("TEST2_local_foo_bar", "testvalue3")
  303. self.assertEqual(self.d.getVar("TEST2"), "testvalue3")
  304. def test_keyexpansion_override(self):
  305. self.d.setVar("LOCAL", "local")
  306. self.d.setVar("TEST_bar", "testvalue2")
  307. self.d.setVar("TEST_${LOCAL}", "testvalue3")
  308. self.d.setVar("TEST_foo", "testvalue4")
  309. bb.data.expandKeys(self.d)
  310. self.assertEqual(self.d.getVar("TEST"), "testvalue3")
  311. def test_rename_override(self):
  312. self.d.setVar("ALTERNATIVE_ncurses-tools_class-target", "a")
  313. self.d.setVar("OVERRIDES", "class-target")
  314. self.d.renameVar("ALTERNATIVE_ncurses-tools", "ALTERNATIVE_lib32-ncurses-tools")
  315. self.assertEqual(self.d.getVar("ALTERNATIVE_lib32-ncurses-tools"), "a")
  316. def test_underscore_override(self):
  317. self.d.setVar("TEST_bar", "testvalue2")
  318. self.d.setVar("TEST_some_val", "testvalue3")
  319. self.d.setVar("TEST_foo", "testvalue4")
  320. self.d.setVar("OVERRIDES", "foo:bar:some_val")
  321. self.assertEqual(self.d.getVar("TEST"), "testvalue3")
  322. def test_remove_with_override(self):
  323. self.d.setVar("TEST_bar", "testvalue2")
  324. self.d.setVar("TEST_some_val", "testvalue3 testvalue5")
  325. self.d.setVar("TEST_some_val_remove", "testvalue3")
  326. self.d.setVar("TEST_foo", "testvalue4")
  327. self.d.setVar("OVERRIDES", "foo:bar:some_val")
  328. self.assertEqual(self.d.getVar("TEST"), " testvalue5")
  329. # Test an override with _<numeric> in it based on a real world OE issue
  330. def test_underscore_override(self):
  331. self.d.setVar("TARGET_ARCH", "x86_64")
  332. self.d.setVar("PN", "test-${TARGET_ARCH}")
  333. self.d.setVar("VERSION", "1")
  334. self.d.setVar("VERSION_pn-test-${TARGET_ARCH}", "2")
  335. self.d.setVar("OVERRIDES", "pn-${PN}")
  336. bb.data.expandKeys(self.d)
  337. self.assertEqual(self.d.getVar("VERSION"), "2")
  338. class TestKeyExpansion(unittest.TestCase):
  339. def setUp(self):
  340. self.d = bb.data.init()
  341. self.d.setVar("FOO", "foo")
  342. self.d.setVar("BAR", "foo")
  343. def test_keyexpand(self):
  344. self.d.setVar("VAL_${FOO}", "A")
  345. self.d.setVar("VAL_${BAR}", "B")
  346. with LogRecord() as logs:
  347. bb.data.expandKeys(self.d)
  348. self.assertTrue(logContains("Variable key VAL_${FOO} (A) replaces original key VAL_foo (B)", logs))
  349. self.assertEqual(self.d.getVar("VAL_foo"), "A")
  350. class TestFlags(unittest.TestCase):
  351. def setUp(self):
  352. self.d = bb.data.init()
  353. self.d.setVar("foo", "value of foo")
  354. self.d.setVarFlag("foo", "flag1", "value of flag1")
  355. self.d.setVarFlag("foo", "flag2", "value of flag2")
  356. def test_setflag(self):
  357. self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
  358. self.assertEqual(self.d.getVarFlag("foo", "flag2", False), "value of flag2")
  359. def test_delflag(self):
  360. self.d.delVarFlag("foo", "flag2")
  361. self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
  362. self.assertEqual(self.d.getVarFlag("foo", "flag2", False), None)
  363. class Contains(unittest.TestCase):
  364. def setUp(self):
  365. self.d = bb.data.init()
  366. self.d.setVar("SOMEFLAG", "a b c")
  367. def test_contains(self):
  368. self.assertTrue(bb.utils.contains("SOMEFLAG", "a", True, False, self.d))
  369. self.assertTrue(bb.utils.contains("SOMEFLAG", "b", True, False, self.d))
  370. self.assertTrue(bb.utils.contains("SOMEFLAG", "c", True, False, self.d))
  371. self.assertTrue(bb.utils.contains("SOMEFLAG", "a b", True, False, self.d))
  372. self.assertTrue(bb.utils.contains("SOMEFLAG", "b c", True, False, self.d))
  373. self.assertTrue(bb.utils.contains("SOMEFLAG", "c a", True, False, self.d))
  374. self.assertTrue(bb.utils.contains("SOMEFLAG", "a b c", True, False, self.d))
  375. self.assertTrue(bb.utils.contains("SOMEFLAG", "c b a", True, False, self.d))
  376. self.assertFalse(bb.utils.contains("SOMEFLAG", "x", True, False, self.d))
  377. self.assertFalse(bb.utils.contains("SOMEFLAG", "a x", True, False, self.d))
  378. self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b", True, False, self.d))
  379. self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b a", True, False, self.d))
  380. def test_contains_any(self):
  381. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a", True, False, self.d))
  382. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b", True, False, self.d))
  383. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c", True, False, self.d))
  384. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a b", True, False, self.d))
  385. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b c", True, False, self.d))
  386. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c a", True, False, self.d))
  387. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a x", True, False, self.d))
  388. self.assertTrue(bb.utils.contains_any("SOMEFLAG", "x c", True, False, self.d))
  389. self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x", True, False, self.d))
  390. self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x y z", True, False, self.d))
  391. class TaskHash(unittest.TestCase):
  392. def test_taskhashes(self):
  393. def gettask_bashhash(taskname, d):
  394. tasklist, gendeps, lookupcache = bb.data.generate_dependencies(d)
  395. taskdeps, basehash = bb.data.generate_dependency_hash(tasklist, gendeps, lookupcache, set(), "somefile")
  396. bb.warn(str(lookupcache))
  397. return basehash["somefile." + taskname]
  398. d = bb.data.init()
  399. d.setVar("__BBTASKS", ["mytask"])
  400. d.setVar("__exportlist", [])
  401. d.setVar("mytask", "${MYCOMMAND}")
  402. d.setVar("MYCOMMAND", "${VAR}; foo; bar; exit 0")
  403. d.setVar("VAR", "val")
  404. orighash = gettask_bashhash("mytask", d)
  405. # Changing a variable should change the hash
  406. d.setVar("VAR", "val2")
  407. nexthash = gettask_bashhash("mytask", d)
  408. self.assertNotEqual(orighash, nexthash)
  409. d.setVar("VAR", "val")
  410. # Adding an inactive removal shouldn't change the hash
  411. d.setVar("BAR", "notbar")
  412. d.setVar("MYCOMMAND_remove", "${BAR}")
  413. nexthash = gettask_bashhash("mytask", d)
  414. self.assertEqual(orighash, nexthash)
  415. # Adding an active removal should change the hash
  416. d.setVar("BAR", "bar;")
  417. nexthash = gettask_bashhash("mytask", d)
  418. self.assertNotEqual(orighash, nexthash)
  419. # Setup an inactive contains()
  420. d.setVar("VAR", "${@bb.utils.contains('VAR2', 'A', 'val', '', d)}")
  421. orighash = gettask_bashhash("mytask", d)
  422. # Activate the contains() and the hash should change
  423. d.setVar("VAR2", "A")
  424. nexthash = gettask_bashhash("mytask", d)
  425. self.assertNotEqual(orighash, nexthash)
  426. # The contains should be inactive but even though VAR2 has a
  427. # different value the hash should match the original
  428. d.setVar("VAR2", "B")
  429. nexthash = gettask_bashhash("mytask", d)
  430. self.assertEqual(orighash, nexthash)
  431. class Serialize(unittest.TestCase):
  432. def test_serialize(self):
  433. import tempfile
  434. import pickle
  435. d = bb.data.init()
  436. d.enableTracking()
  437. d.setVar('HELLO', 'world')
  438. d.setVarFlag('HELLO', 'other', 'planet')
  439. with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
  440. tmpfilename = tmpfile.name
  441. pickle.dump(d, tmpfile)
  442. with open(tmpfilename, 'rb') as f:
  443. newd = pickle.load(f)
  444. os.remove(tmpfilename)
  445. self.assertEqual(d, newd)
  446. self.assertEqual(newd.getVar('HELLO'), 'world')
  447. self.assertEqual(newd.getVarFlag('HELLO', 'other'), 'planet')
  448. # Remote datastore tests
  449. # These really only test the interface, since in actual usage we have a
  450. # tinfoil connector that does everything over RPC, and this doesn't test
  451. # that.
  452. class TestConnector:
  453. d = None
  454. def __init__(self, d):
  455. self.d = d
  456. def getVar(self, name):
  457. return self.d._findVar(name)
  458. def getKeys(self):
  459. return set(self.d.keys())
  460. def getVarHistory(self, name):
  461. return self.d.varhistory.variable(name)
  462. def expandPythonRef(self, varname, expr, d):
  463. localdata = self.d.createCopy()
  464. for key in d.localkeys():
  465. localdata.setVar(d.getVar(key))
  466. varparse = bb.data_smart.VariableParse(varname, localdata)
  467. return varparse.python_sub(expr)
  468. def setVar(self, name, value):
  469. self.d.setVar(name, value)
  470. def setVarFlag(self, name, flag, value):
  471. self.d.setVarFlag(name, flag, value)
  472. def delVar(self, name):
  473. self.d.delVar(name)
  474. return False
  475. def delVarFlag(self, name, flag):
  476. self.d.delVarFlag(name, flag)
  477. return False
  478. def renameVar(self, name, newname):
  479. self.d.renameVar(name, newname)
  480. return False
  481. class Remote(unittest.TestCase):
  482. def test_remote(self):
  483. d1 = bb.data.init()
  484. d1.enableTracking()
  485. d2 = bb.data.init()
  486. d2.enableTracking()
  487. connector = TestConnector(d1)
  488. d2.setVar('_remote_data', connector)
  489. d1.setVar('HELLO', 'world')
  490. d1.setVarFlag('OTHER', 'flagname', 'flagvalue')
  491. self.assertEqual(d2.getVar('HELLO'), 'world')
  492. self.assertEqual(d2.expand('${HELLO}'), 'world')
  493. self.assertEqual(d2.expand('${@d.getVar("HELLO")}'), 'world')
  494. self.assertIn('flagname', d2.getVarFlags('OTHER'))
  495. self.assertEqual(d2.getVarFlag('OTHER', 'flagname'), 'flagvalue')
  496. self.assertEqual(d1.varhistory.variable('HELLO'), d2.varhistory.variable('HELLO'))
  497. # Test setVar on client side affects server
  498. d2.setVar('HELLO', 'other-world')
  499. self.assertEqual(d1.getVar('HELLO'), 'other-world')
  500. # Test setVarFlag on client side affects server
  501. d2.setVarFlag('HELLO', 'flagname', 'flagvalue')
  502. self.assertEqual(d1.getVarFlag('HELLO', 'flagname'), 'flagvalue')
  503. # Test client side data is incorporated in python expansion (which is done on server)
  504. d2.setVar('FOO', 'bar')
  505. self.assertEqual(d2.expand('${@d.getVar("FOO")}'), 'bar')
  506. # Test overrides work
  507. d1.setVar('FOO_test', 'baz')
  508. d1.appendVar('OVERRIDES', ':test')
  509. self.assertEqual(d2.getVar('FOO'), 'baz')
  510. # Remote equivalents of local test classes
  511. # Note that these aren't perfect since we only test in one direction
  512. class RemoteDataExpansions(DataExpansions):
  513. def setUp(self):
  514. self.d1 = bb.data.init()
  515. self.d = bb.data.init()
  516. self.d1["foo"] = "value_of_foo"
  517. self.d1["bar"] = "value_of_bar"
  518. self.d1["value_of_foo"] = "value_of_'value_of_foo'"
  519. connector = TestConnector(self.d1)
  520. self.d.setVar('_remote_data', connector)
  521. class TestRemoteNestedExpansions(TestNestedExpansions):
  522. def setUp(self):
  523. self.d1 = bb.data.init()
  524. self.d = bb.data.init()
  525. self.d1["foo"] = "foo"
  526. self.d1["bar"] = "bar"
  527. self.d1["value_of_foobar"] = "187"
  528. connector = TestConnector(self.d1)
  529. self.d.setVar('_remote_data', connector)
  530. class TestRemoteConcat(TestConcat):
  531. def setUp(self):
  532. self.d1 = bb.data.init()
  533. self.d = bb.data.init()
  534. self.d1.setVar("FOO", "foo")
  535. self.d1.setVar("VAL", "val")
  536. self.d1.setVar("BAR", "bar")
  537. connector = TestConnector(self.d1)
  538. self.d.setVar('_remote_data', connector)
  539. class TestRemoteConcatOverride(TestConcatOverride):
  540. def setUp(self):
  541. self.d1 = bb.data.init()
  542. self.d = bb.data.init()
  543. self.d1.setVar("FOO", "foo")
  544. self.d1.setVar("VAL", "val")
  545. self.d1.setVar("BAR", "bar")
  546. connector = TestConnector(self.d1)
  547. self.d.setVar('_remote_data', connector)
  548. class TestRemoteOverrides(TestOverrides):
  549. def setUp(self):
  550. self.d1 = bb.data.init()
  551. self.d = bb.data.init()
  552. self.d1.setVar("OVERRIDES", "foo:bar:local")
  553. self.d1.setVar("TEST", "testvalue")
  554. connector = TestConnector(self.d1)
  555. self.d.setVar('_remote_data', connector)
  556. class TestRemoteKeyExpansion(TestKeyExpansion):
  557. def setUp(self):
  558. self.d1 = bb.data.init()
  559. self.d = bb.data.init()
  560. self.d1.setVar("FOO", "foo")
  561. self.d1.setVar("BAR", "foo")
  562. connector = TestConnector(self.d1)
  563. self.d.setVar('_remote_data', connector)
  564. class TestRemoteFlags(TestFlags):
  565. def setUp(self):
  566. self.d1 = bb.data.init()
  567. self.d = bb.data.init()
  568. self.d1.setVar("foo", "value of foo")
  569. self.d1.setVarFlag("foo", "flag1", "value of flag1")
  570. self.d1.setVarFlag("foo", "flag2", "value of flag2")
  571. connector = TestConnector(self.d1)
  572. self.d.setVar('_remote_data', connector)