mirror of
https://git.yoctoproject.org/poky
synced 2026-02-12 19:53:03 +01:00
8f8a9ef669
If you're expanding a value that refers to the value of a variable in
python code, we need to ensure that the datastore that gets used to get
the value of that variable is the client-side datastore and not just the
part of it that's on the server side. For example, suppose you are in
client code doing the following:
d.setVar('HELLO', 'there')
result = d.expand('${@d.getVar("HELLO", True)}')
result should be "there" but if the client part wasn't taken into
account, it would be whatever value HELLO had in the server portion of
the datastore (if any).
(Bitbake rev: cbc22a0a9aadc8606b927dbac0f1407ec2736b35)
Signed-off-by: Paul Eggleton <paul.eggleton@linux.intel.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
492 lines
19 KiB
Python
492 lines
19 KiB
Python
# ex:ts=4:sw=4:sts=4:et
|
|
# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
|
|
#
|
|
# BitBake Tests for the Data Store (data.py/data_smart.py)
|
|
#
|
|
# Copyright (C) 2010 Chris Larson
|
|
# Copyright (C) 2012 Richard Purdie
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License version 2 as
|
|
# published by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program; if not, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
|
|
import unittest
|
|
import bb
|
|
import bb.data
|
|
import bb.parse
|
|
import logging
|
|
|
|
class LogRecord():
|
|
def __enter__(self):
|
|
logs = []
|
|
class LogHandler(logging.Handler):
|
|
def emit(self, record):
|
|
logs.append(record)
|
|
logger = logging.getLogger("BitBake")
|
|
handler = LogHandler()
|
|
self.handler = handler
|
|
logger.addHandler(handler)
|
|
return logs
|
|
def __exit__(self, type, value, traceback):
|
|
logger = logging.getLogger("BitBake")
|
|
logger.removeHandler(self.handler)
|
|
return
|
|
|
|
def logContains(item, logs):
|
|
for l in logs:
|
|
m = l.getMessage()
|
|
if item in m:
|
|
return True
|
|
return False
|
|
|
|
class DataExpansions(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d["foo"] = "value_of_foo"
|
|
self.d["bar"] = "value_of_bar"
|
|
self.d["value_of_foo"] = "value_of_'value_of_foo'"
|
|
|
|
def test_one_var(self):
|
|
val = self.d.expand("${foo}")
|
|
self.assertEqual(str(val), "value_of_foo")
|
|
|
|
def test_indirect_one_var(self):
|
|
val = self.d.expand("${${foo}}")
|
|
self.assertEqual(str(val), "value_of_'value_of_foo'")
|
|
|
|
def test_indirect_and_another(self):
|
|
val = self.d.expand("${${foo}} ${bar}")
|
|
self.assertEqual(str(val), "value_of_'value_of_foo' value_of_bar")
|
|
|
|
def test_python_snippet(self):
|
|
val = self.d.expand("${@5*12}")
|
|
self.assertEqual(str(val), "60")
|
|
|
|
def test_expand_in_python_snippet(self):
|
|
val = self.d.expand("${@'boo ' + '${foo}'}")
|
|
self.assertEqual(str(val), "boo value_of_foo")
|
|
|
|
def test_python_snippet_getvar(self):
|
|
val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
|
|
self.assertEqual(str(val), "value_of_foo value_of_bar")
|
|
|
|
def test_python_unexpanded(self):
|
|
self.d.setVar("bar", "${unsetvar}")
|
|
val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
|
|
self.assertEqual(str(val), "${@d.getVar('foo') + ' ${unsetvar}'}")
|
|
|
|
def test_python_snippet_syntax_error(self):
|
|
self.d.setVar("FOO", "${@foo = 5}")
|
|
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
|
|
|
|
def test_python_snippet_runtime_error(self):
|
|
self.d.setVar("FOO", "${@int('test')}")
|
|
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
|
|
|
|
def test_python_snippet_error_path(self):
|
|
self.d.setVar("FOO", "foo value ${BAR}")
|
|
self.d.setVar("BAR", "bar value ${@int('test')}")
|
|
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
|
|
|
|
def test_value_containing_value(self):
|
|
val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
|
|
self.assertEqual(str(val), "value_of_foo value_of_bar")
|
|
|
|
def test_reference_undefined_var(self):
|
|
val = self.d.expand("${undefinedvar} meh")
|
|
self.assertEqual(str(val), "${undefinedvar} meh")
|
|
|
|
def test_double_reference(self):
|
|
self.d.setVar("BAR", "bar value")
|
|
self.d.setVar("FOO", "${BAR} foo ${BAR}")
|
|
val = self.d.getVar("FOO")
|
|
self.assertEqual(str(val), "bar value foo bar value")
|
|
|
|
def test_direct_recursion(self):
|
|
self.d.setVar("FOO", "${FOO}")
|
|
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
|
|
|
|
def test_indirect_recursion(self):
|
|
self.d.setVar("FOO", "${BAR}")
|
|
self.d.setVar("BAR", "${BAZ}")
|
|
self.d.setVar("BAZ", "${FOO}")
|
|
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
|
|
|
|
def test_recursion_exception(self):
|
|
self.d.setVar("FOO", "${BAR}")
|
|
self.d.setVar("BAR", "${${@'FOO'}}")
|
|
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
|
|
|
|
def test_incomplete_varexp_single_quotes(self):
|
|
self.d.setVar("FOO", "sed -i -e 's:IP{:I${:g' $pc")
|
|
val = self.d.getVar("FOO")
|
|
self.assertEqual(str(val), "sed -i -e 's:IP{:I${:g' $pc")
|
|
|
|
def test_nonstring(self):
|
|
self.d.setVar("TEST", 5)
|
|
val = self.d.getVar("TEST")
|
|
self.assertEqual(str(val), "5")
|
|
|
|
def test_rename(self):
|
|
self.d.renameVar("foo", "newfoo")
|
|
self.assertEqual(self.d.getVar("newfoo", False), "value_of_foo")
|
|
self.assertEqual(self.d.getVar("foo", False), None)
|
|
|
|
def test_deletion(self):
|
|
self.d.delVar("foo")
|
|
self.assertEqual(self.d.getVar("foo", False), None)
|
|
|
|
def test_keys(self):
|
|
keys = list(self.d.keys())
|
|
self.assertCountEqual(keys, ['value_of_foo', 'foo', 'bar'])
|
|
|
|
def test_keys_deletion(self):
|
|
newd = bb.data.createCopy(self.d)
|
|
newd.delVar("bar")
|
|
keys = list(newd.keys())
|
|
self.assertCountEqual(keys, ['value_of_foo', 'foo'])
|
|
|
|
class TestNestedExpansions(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d["foo"] = "foo"
|
|
self.d["bar"] = "bar"
|
|
self.d["value_of_foobar"] = "187"
|
|
|
|
def test_refs(self):
|
|
val = self.d.expand("${value_of_${foo}${bar}}")
|
|
self.assertEqual(str(val), "187")
|
|
|
|
#def test_python_refs(self):
|
|
# val = self.d.expand("${@${@3}**2 + ${@4}**2}")
|
|
# self.assertEqual(str(val), "25")
|
|
|
|
def test_ref_in_python_ref(self):
|
|
val = self.d.expand("${@'${foo}' + 'bar'}")
|
|
self.assertEqual(str(val), "foobar")
|
|
|
|
def test_python_ref_in_ref(self):
|
|
val = self.d.expand("${${@'f'+'o'+'o'}}")
|
|
self.assertEqual(str(val), "foo")
|
|
|
|
def test_deep_nesting(self):
|
|
depth = 100
|
|
val = self.d.expand("${" * depth + "foo" + "}" * depth)
|
|
self.assertEqual(str(val), "foo")
|
|
|
|
#def test_deep_python_nesting(self):
|
|
# depth = 50
|
|
# val = self.d.expand("${@" * depth + "1" + "+1}" * depth)
|
|
# self.assertEqual(str(val), str(depth + 1))
|
|
|
|
def test_mixed(self):
|
|
val = self.d.expand("${value_of_${@('${foo}'+'bar')[0:3]}${${@'BAR'.lower()}}}")
|
|
self.assertEqual(str(val), "187")
|
|
|
|
def test_runtime(self):
|
|
val = self.d.expand("${${@'value_of' + '_f'+'o'+'o'+'b'+'a'+'r'}}")
|
|
self.assertEqual(str(val), "187")
|
|
|
|
class TestMemoize(unittest.TestCase):
|
|
def test_memoized(self):
|
|
d = bb.data.init()
|
|
d.setVar("FOO", "bar")
|
|
self.assertTrue(d.getVar("FOO", False) is d.getVar("FOO", False))
|
|
|
|
def test_not_memoized(self):
|
|
d1 = bb.data.init()
|
|
d2 = bb.data.init()
|
|
d1.setVar("FOO", "bar")
|
|
d2.setVar("FOO", "bar2")
|
|
self.assertTrue(d1.getVar("FOO", False) is not d2.getVar("FOO", False))
|
|
|
|
def test_changed_after_memoized(self):
|
|
d = bb.data.init()
|
|
d.setVar("foo", "value of foo")
|
|
self.assertEqual(str(d.getVar("foo", False)), "value of foo")
|
|
d.setVar("foo", "second value of foo")
|
|
self.assertEqual(str(d.getVar("foo", False)), "second value of foo")
|
|
|
|
def test_same_value(self):
|
|
d = bb.data.init()
|
|
d.setVar("foo", "value of")
|
|
d.setVar("bar", "value of")
|
|
self.assertEqual(d.getVar("foo", False),
|
|
d.getVar("bar", False))
|
|
|
|
class TestConcat(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d.setVar("FOO", "foo")
|
|
self.d.setVar("VAL", "val")
|
|
self.d.setVar("BAR", "bar")
|
|
|
|
def test_prepend(self):
|
|
self.d.setVar("TEST", "${VAL}")
|
|
self.d.prependVar("TEST", "${FOO}:")
|
|
self.assertEqual(self.d.getVar("TEST"), "foo:val")
|
|
|
|
def test_append(self):
|
|
self.d.setVar("TEST", "${VAL}")
|
|
self.d.appendVar("TEST", ":${BAR}")
|
|
self.assertEqual(self.d.getVar("TEST"), "val:bar")
|
|
|
|
def test_multiple_append(self):
|
|
self.d.setVar("TEST", "${VAL}")
|
|
self.d.prependVar("TEST", "${FOO}:")
|
|
self.d.appendVar("TEST", ":val2")
|
|
self.d.appendVar("TEST", ":${BAR}")
|
|
self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
|
|
|
|
class TestConcatOverride(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d.setVar("FOO", "foo")
|
|
self.d.setVar("VAL", "val")
|
|
self.d.setVar("BAR", "bar")
|
|
|
|
def test_prepend(self):
|
|
self.d.setVar("TEST", "${VAL}")
|
|
self.d.setVar("TEST_prepend", "${FOO}:")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "foo:val")
|
|
|
|
def test_append(self):
|
|
self.d.setVar("TEST", "${VAL}")
|
|
self.d.setVar("TEST_append", ":${BAR}")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "val:bar")
|
|
|
|
def test_multiple_append(self):
|
|
self.d.setVar("TEST", "${VAL}")
|
|
self.d.setVar("TEST_prepend", "${FOO}:")
|
|
self.d.setVar("TEST_append", ":val2")
|
|
self.d.setVar("TEST_append", ":${BAR}")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
|
|
|
|
def test_append_unset(self):
|
|
self.d.setVar("TEST_prepend", "${FOO}:")
|
|
self.d.setVar("TEST_append", ":val2")
|
|
self.d.setVar("TEST_append", ":${BAR}")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "foo::val2:bar")
|
|
|
|
def test_remove(self):
|
|
self.d.setVar("TEST", "${VAL} ${BAR}")
|
|
self.d.setVar("TEST_remove", "val")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "bar")
|
|
|
|
def test_doubleref_remove(self):
|
|
self.d.setVar("TEST", "${VAL} ${BAR}")
|
|
self.d.setVar("TEST_remove", "val")
|
|
self.d.setVar("TEST_TEST", "${TEST} ${TEST}")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST_TEST"), "bar bar")
|
|
|
|
def test_empty_remove(self):
|
|
self.d.setVar("TEST", "")
|
|
self.d.setVar("TEST_remove", "val")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "")
|
|
|
|
def test_remove_expansion(self):
|
|
self.d.setVar("BAR", "Z")
|
|
self.d.setVar("TEST", "${BAR}/X Y")
|
|
self.d.setVar("TEST_remove", "${BAR}/X")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "Y")
|
|
|
|
def test_remove_expansion_items(self):
|
|
self.d.setVar("TEST", "A B C D")
|
|
self.d.setVar("BAR", "B D")
|
|
self.d.setVar("TEST_remove", "${BAR}")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "A C")
|
|
|
|
class TestOverrides(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d.setVar("OVERRIDES", "foo:bar:local")
|
|
self.d.setVar("TEST", "testvalue")
|
|
|
|
def test_no_override(self):
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "testvalue")
|
|
|
|
def test_one_override(self):
|
|
self.d.setVar("TEST_bar", "testvalue2")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "testvalue2")
|
|
|
|
def test_one_override_unset(self):
|
|
self.d.setVar("TEST2_bar", "testvalue2")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST2"), "testvalue2")
|
|
self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST2', 'OVERRIDES', 'TEST2_bar'])
|
|
|
|
def test_multiple_override(self):
|
|
self.d.setVar("TEST_bar", "testvalue2")
|
|
self.d.setVar("TEST_local", "testvalue3")
|
|
self.d.setVar("TEST_foo", "testvalue4")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
|
|
self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST_foo', 'OVERRIDES', 'TEST_bar', 'TEST_local'])
|
|
|
|
def test_multiple_combined_overrides(self):
|
|
self.d.setVar("TEST_local_foo_bar", "testvalue3")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
|
|
|
|
def test_multiple_overrides_unset(self):
|
|
self.d.setVar("TEST2_local_foo_bar", "testvalue3")
|
|
bb.data.update_data(self.d)
|
|
self.assertEqual(self.d.getVar("TEST2"), "testvalue3")
|
|
|
|
def test_keyexpansion_override(self):
|
|
self.d.setVar("LOCAL", "local")
|
|
self.d.setVar("TEST_bar", "testvalue2")
|
|
self.d.setVar("TEST_${LOCAL}", "testvalue3")
|
|
self.d.setVar("TEST_foo", "testvalue4")
|
|
bb.data.update_data(self.d)
|
|
bb.data.expandKeys(self.d)
|
|
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
|
|
|
|
def test_rename_override(self):
|
|
self.d.setVar("ALTERNATIVE_ncurses-tools_class-target", "a")
|
|
self.d.setVar("OVERRIDES", "class-target")
|
|
bb.data.update_data(self.d)
|
|
self.d.renameVar("ALTERNATIVE_ncurses-tools", "ALTERNATIVE_lib32-ncurses-tools")
|
|
self.assertEqual(self.d.getVar("ALTERNATIVE_lib32-ncurses-tools"), "a")
|
|
|
|
def test_underscore_override(self):
|
|
self.d.setVar("TEST_bar", "testvalue2")
|
|
self.d.setVar("TEST_some_val", "testvalue3")
|
|
self.d.setVar("TEST_foo", "testvalue4")
|
|
self.d.setVar("OVERRIDES", "foo:bar:some_val")
|
|
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
|
|
|
|
class TestKeyExpansion(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d.setVar("FOO", "foo")
|
|
self.d.setVar("BAR", "foo")
|
|
|
|
def test_keyexpand(self):
|
|
self.d.setVar("VAL_${FOO}", "A")
|
|
self.d.setVar("VAL_${BAR}", "B")
|
|
with LogRecord() as logs:
|
|
bb.data.expandKeys(self.d)
|
|
self.assertTrue(logContains("Variable key VAL_${FOO} (A) replaces original key VAL_foo (B)", logs))
|
|
self.assertEqual(self.d.getVar("VAL_foo"), "A")
|
|
|
|
class TestFlags(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d.setVar("foo", "value of foo")
|
|
self.d.setVarFlag("foo", "flag1", "value of flag1")
|
|
self.d.setVarFlag("foo", "flag2", "value of flag2")
|
|
|
|
def test_setflag(self):
|
|
self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
|
|
self.assertEqual(self.d.getVarFlag("foo", "flag2", False), "value of flag2")
|
|
|
|
def test_delflag(self):
|
|
self.d.delVarFlag("foo", "flag2")
|
|
self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
|
|
self.assertEqual(self.d.getVarFlag("foo", "flag2", False), None)
|
|
|
|
|
|
class Contains(unittest.TestCase):
|
|
def setUp(self):
|
|
self.d = bb.data.init()
|
|
self.d.setVar("SOMEFLAG", "a b c")
|
|
|
|
def test_contains(self):
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "a", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "b", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "c", True, False, self.d))
|
|
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "a b", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "b c", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "c a", True, False, self.d))
|
|
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "a b c", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains("SOMEFLAG", "c b a", True, False, self.d))
|
|
|
|
self.assertFalse(bb.utils.contains("SOMEFLAG", "x", True, False, self.d))
|
|
self.assertFalse(bb.utils.contains("SOMEFLAG", "a x", True, False, self.d))
|
|
self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b", True, False, self.d))
|
|
self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b a", True, False, self.d))
|
|
|
|
def test_contains_any(self):
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c", True, False, self.d))
|
|
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a b", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b c", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c a", True, False, self.d))
|
|
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a x", True, False, self.d))
|
|
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "x c", True, False, self.d))
|
|
|
|
self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x", True, False, self.d))
|
|
self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x y z", True, False, self.d))
|
|
|
|
|
|
class Remote(unittest.TestCase):
|
|
def test_remote(self):
|
|
class TestConnector:
|
|
d = None
|
|
def __init__(self, d):
|
|
self.d = d
|
|
def getVar(self, name):
|
|
return self.d._findVar(name)
|
|
def getKeys(self):
|
|
return self.d.localkeys()
|
|
def getVarHistory(self, name):
|
|
return self.d.varhistory.variable(name)
|
|
def expandPythonRef(self, varname, expr, d):
|
|
localdata = self.d.createCopy()
|
|
for key in d.localkeys():
|
|
localdata.setVar(d.getVar(key))
|
|
varparse = bb.data_smart.VariableParse(varname, localdata)
|
|
return varparse.python_sub(expr)
|
|
def setVar(self, name, value):
|
|
self.d.setVar(name, value)
|
|
|
|
d1 = bb.data.init()
|
|
d1.enableTracking()
|
|
d2 = bb.data.init()
|
|
d2.enableTracking()
|
|
connector = TestConnector(d1)
|
|
|
|
d2.setVar('_remote_data', connector)
|
|
|
|
d1.setVar('HELLO', 'world')
|
|
d1.setVarFlag('OTHER', 'flagname', 'flagvalue')
|
|
self.assertEqual(d2.getVar('HELLO'), 'world')
|
|
self.assertEqual(d2.expand('${HELLO}'), 'world')
|
|
self.assertEqual(d2.expand('${@d.getVar("HELLO")}'), 'world')
|
|
self.assertIn('flagname', d2.getVarFlags('OTHER'))
|
|
self.assertEqual(d2.getVarFlag('OTHER', 'flagname'), 'flagvalue')
|
|
self.assertEqual(d1.varhistory.variable('HELLO'), d2.varhistory.variable('HELLO'))
|
|
# Test setVar on client side affects server
|
|
d2.setVar('HELLO', 'other-world')
|
|
self.assertEqual(d1.getVar('HELLO'), 'other-world')
|
|
# Test client side data is incorporated in python expansion (which is done on server)
|
|
d2.setVar('FOO', 'bar')
|
|
self.assertEqual(d2.expand('${@d.getVar("FOO")}'), 'bar')
|