def test_Boolean():
v = Value.makeBoolean(False)
assert NT_BOOLEAN == v.type
assert not v.value
v = Value.makeBoolean(True)
assert NT_BOOLEAN == v.type
assert v.value
def test_SetEntryTypeValueAssignNew(storage_empty, dispatcher, entry_notifier,
is_server):
storage = storage_empty
# brand new entry
value = Value.makeBoolean(True)
storage.setEntryTypeValue("foo", value)
assert value == storage.m_entries.get("foo").value
dispatcher._queueOutgoing.assert_has_calls([
call(
Message.entryAssign("foo", 0 if is_server else 0xFFFF, 1, value,
0),
None,
None,
)
])
entry_notifier.notifyEntry.assert_has_calls(
[call(0, "foo", value, NT_NOTIFY_NEW | NT_NOTIFY_LOCAL)])
if is_server:
assert 1 == len(storage.m_idmap)
assert value == storage.m_idmap[0].value
else:
assert len(storage.m_idmap) == 0
def storage_populated(storage_empty, dispatcher, entry_notifier):
storage = storage_empty
entry_notifier.m_local_notifiers = False
entry_notifier.m_local_notifiers = False
storage.setEntryTypeValue("foo", Value.makeBoolean(True))
storage.setEntryTypeValue("foo2", Value.makeDouble(0.0))
storage.setEntryTypeValue("bar", Value.makeDouble(1.0))
storage.setEntryTypeValue("bar2", Value.makeBoolean(False))
dispatcher.reset_mock()
entry_notifier.reset_mock()
entry_notifier.m_local_notifiers = True
return storage
def test_GetEntryValueExist(storage_empty, dispatcher, entry_notifier):
storage = storage_empty
value = Value.makeBoolean(True)
storage.setEntryTypeValue("foo", value)
assert dispatcher._queueOutgoing.call_count == 1
assert entry_notifier.notifyEntry.call_count == 1
assert value == storage.getEntryValue("foo")
def test_DeleteCheckHandle(storage_populate_one, dispatcher, entry_notifier,
is_server):
storage = storage_populate_one
handle = storage.getEntryId("foo")
storage.deleteEntry("foo")
storage.setEntryTypeValue("foo", Value.makeBoolean(True))
handle2 = storage.getEntryId("foo")
assert handle == handle2
def test_SetEntryValueEmptyName(storage_empty, dispatcher, entry_notifier):
storage = storage_empty
value = Value.makeBoolean(True)
assert storage.setEntryValue("", value)
assert len(storage.m_entries) == 0
assert len(storage.m_idmap) == 0
assert dispatcher._queueOutgoing.call_count == 0
assert entry_notifier.notifyEntry.call_count == 0
def test_SetDefaultEntryExistsSameType(storage_populate_one, dispatcher,
entry_notifier):
storage = storage_populate_one
# existing entry
value = Value.makeBoolean(False)
ret_val = storage.setDefaultEntryValue("foo", value)
assert ret_val
assert value != storage.m_entries.get("foo").value
assert dispatcher._queueOutgoing.call_count == 0
assert entry_notifier.notifyEntry.call_count == 0
def test_SetEntryTypeValueEqualValue(storage_populate_one, dispatcher,
entry_notifier):
storage = storage_populate_one
# update with same type and same value: change value contents but no update
# message is issued (minimizing bandwidth usage)
value = Value.makeBoolean(True)
storage.setEntryTypeValue("foo", value)
assert value == storage.m_entries.get("foo").value
assert dispatcher._queueOutgoing.call_count == 0
assert entry_notifier.notifyEntry.call_count == 0
def storage_populate_one(storage_empty, dispatcher, entry_notifier):
storage = storage_empty
entry_notifier.m_local_notifiers = False
storage.setEntryTypeValue("foo", Value.makeBoolean(True))
dispatcher.reset_mock()
entry_notifier.reset_mock()
entry_notifier.m_local_notifiers = True
return storage
def storage_persistent(storage_empty, dispatcher, entry_notifier):
storage = storage_empty
entry_notifier.m_local_notifiers = False
storage.setEntryTypeValue("boolean/true", Value.makeBoolean(True))
storage.setEntryTypeValue("boolean/false", Value.makeBoolean(False))
storage.setEntryTypeValue("double/neg", Value.makeDouble(-1.5))
storage.setEntryTypeValue("double/zero", Value.makeDouble(0.0))
storage.setEntryTypeValue("double/big", Value.makeDouble(1.3e8))
storage.setEntryTypeValue("string/empty", Value.makeString(""))
storage.setEntryTypeValue("string/normal", Value.makeString("hello"))
storage.setEntryTypeValue("string/special", Value.makeString("\0\3\5\n"))
storage.setEntryTypeValue("string/quoted", Value.makeString('"a"'))
storage.setEntryTypeValue("raw/empty", Value.makeRaw(b""))
storage.setEntryTypeValue("raw/normal", Value.makeRaw(b"hello"))
storage.setEntryTypeValue("raw/special", Value.makeRaw(b"\0\3\5\n"))
storage.setEntryTypeValue("booleanarr/empty", Value.makeBooleanArray([]))
storage.setEntryTypeValue("booleanarr/one", Value.makeBooleanArray([True]))
storage.setEntryTypeValue("booleanarr/two",
Value.makeBooleanArray([True, False]))
storage.setEntryTypeValue("doublearr/empty", Value.makeDoubleArray([]))
storage.setEntryTypeValue("doublearr/one", Value.makeDoubleArray([0.5]))
storage.setEntryTypeValue("doublearr/two",
Value.makeDoubleArray([0.5, -0.25]))
storage.setEntryTypeValue("stringarr/empty", Value.makeStringArray([]))
storage.setEntryTypeValue("stringarr/one",
Value.makeStringArray(["hello"]))
storage.setEntryTypeValue("stringarr/two",
Value.makeStringArray(["hello", "world\n"]))
storage.setEntryTypeValue("\0\3\5\n", Value.makeBoolean(True))
storage.setEntryTypeValue("CaseSensitive/KeyName", Value.makeBoolean(True))
storage.setEntryTypeValue("=", Value.makeBoolean(True))
dispatcher.reset_mock()
entry_notifier.reset_mock()
entry_notifier.m_local_notifiers = True
return storage
def test_empty_SetDefaultEntryEmptyName(storage_empty, dispatcher,
entry_notifier):
storage = storage_empty
value = Value.makeBoolean(True)
ret_val = storage.setDefaultEntryValue("", value)
assert not ret_val
assert "foo" not in storage.m_entries
assert len(storage.m_entries) == 0
assert len(storage.m_idmap) == 0
assert dispatcher._queueOutgoing.call_count == 0
assert entry_notifier.notifyEntry.call_count == 0
def test_populated_SetDefaultEntryEmptyName(storage_populated, dispatcher,
entry_notifier, is_server):
storage = storage_populated
value = Value.makeBoolean(True)
ret_val = storage.setDefaultEntryValue("", value)
assert not ret_val
# assert that no entries get added
assert 4 == len(storage.m_entries)
if is_server:
assert 4 == len(storage.m_idmap)
else:
assert 0 == len(storage.m_idmap)
assert dispatcher._queueOutgoing.call_count == 0
assert entry_notifier.notifyEntry.call_count == 0
def test_SetDefaultEntryAssignNew(storage_empty, dispatcher, entry_notifier,
is_server):
storage = storage_empty
# brand new entry
value = Value.makeBoolean(True)
ret_val = storage.setDefaultEntryValue("foo", value)
assert ret_val
assert value == storage.m_entries.get("foo").value
dispatcher._queueOutgoing.assert_has_calls([
call(
Message.entryAssign("foo", 0 if is_server else 0xFFFF, 1, value,
0),
None,
None,
)
])
entry_notifier.notifyEntry.assert_has_calls(
[call(0, "foo", value, NT_NOTIFY_NEW | NT_NOTIFY_LOCAL)])
def test_LoadPersistentAssign(storage_empty, dispatcher, entry_notifier,
is_server):
storage = storage_empty
fp = StringIO('[NetworkTables Storage 3.0]\nboolean "foo"=true\n')
assert storage.loadPersistent(fp=fp) is None
entry = storage.m_entries.get("foo")
assert Value.makeBoolean(True) == entry.value
assert NT_PERSISTENT == entry.flags
assert entry.isPersistent
dispatcher._queueOutgoing.assert_has_calls([
call(
Message.entryAssign("foo", 0 if is_server else 0xFFFF, 1,
entry.value, NT_PERSISTENT),
None,
None,
)
])
entry_notifier.notifyEntry.assert_has_calls(
[call(0, "foo", entry.value, NT_NOTIFY_NEW | NT_NOTIFY_LOCAL)])
def test_BooleanComparison():
v1 = Value.makeBoolean(True)
v2 = Value.makeBoolean(True)
assert v1 == v2
v2 = Value.makeBoolean(False)
assert v1 != v2
def test_MixedComparison():
v2 = Value.makeBoolean(True)
v3 = Value.makeDouble(0.5)
assert v2 != v3 # boolean vs double
def test_wire_boolean(v_round_trip):
v_round_trip(Value.makeBoolean(True))
def test_wire_entryUpdate1(msg_round_trip, proto_rev):
exclude = [] if proto_rev >= 0x0300 else [4]
value = Value.makeBoolean(True)
msg_round_trip(Message.entryUpdate(0x1234, 0x4321, value), exclude=exclude)
def test_loadPersistent(storage_empty, dispatcher, entry_notifier):
storage = storage_empty
inp = "[NetworkTables Storage 3.0]\n"
inp += 'boolean "\\x00\\x03\\x05\\n"=true\n'
inp += 'boolean "CaseSensitive/KeyName"=true\n'
inp += 'boolean "boolean/false"=false\n'
inp += 'boolean "boolean/true"=true\n'
inp += 'array boolean "booleanarr/empty"=\n'
inp += 'array boolean "booleanarr/one"=true\n'
inp += 'array boolean "booleanarr/two"=true,false\n'
inp += 'double "double/big"=1.3e+08\n'
inp += 'double "double/neg"=-1.5\n'
inp += 'double "double/zero"=0\n'
inp += 'array double "doublearr/empty"=\n'
inp += 'array double "doublearr/one"=0.5\n'
inp += 'array double "doublearr/two"=0.5,-0.25\n'
inp += 'raw "raw/empty"=\n'
inp += 'raw "raw/normal"=aGVsbG8=\n'
inp += 'raw "raw/special"=AAMFCg==\n'
inp += 'string "string/empty"=""\n'
inp += 'string "string/normal"="hello"\n'
inp += 'string "string/special"="\\x00\\x03\\x05\\n"\n'
inp += 'string "string/quoted"="\\"a\\""\n'
inp += 'array string "stringarr/empty"=\n'
inp += 'array string "stringarr/one"="hello"\n'
inp += 'array string "stringarr/two"="hello","world\\n"\n'
fp = StringIO(inp)
assert storage.loadPersistent(fp=fp) is None
dispatcher._queueOutgoing.assert_has_calls([call(ANY, None, None)] * 23)
entry_notifier.notifyEntry.assert_has_calls(
[call(ANY, ANY, ANY, NT_NOTIFY_NEW | NT_NOTIFY_LOCAL)] * 23)
assert Value.makeBoolean(True) == storage.getEntryValue("boolean/true")
assert Value.makeBoolean(False) == storage.getEntryValue("boolean/false")
assert Value.makeDouble(-1.5) == storage.getEntryValue("double/neg")
assert Value.makeDouble(0.0) == storage.getEntryValue("double/zero")
assert Value.makeDouble(1.3e8) == storage.getEntryValue("double/big")
assert Value.makeString("") == storage.getEntryValue("string/empty")
assert Value.makeString("hello") == storage.getEntryValue("string/normal")
assert Value.makeString("\0\3\5\n") == storage.getEntryValue(
"string/special")
assert Value.makeString('"a"') == storage.getEntryValue("string/quoted")
assert Value.makeRaw(b"") == storage.getEntryValue("raw/empty")
assert Value.makeRaw(b"hello") == storage.getEntryValue("raw/normal")
assert Value.makeRaw(b"\0\3\5\n") == storage.getEntryValue("raw/special")
assert Value.makeBooleanArray(
[]) == storage.getEntryValue("booleanarr/empty")
assert Value.makeBooleanArray(
[True]) == storage.getEntryValue("booleanarr/one")
assert Value.makeBooleanArray(
[True, False]) == storage.getEntryValue("booleanarr/two")
assert Value.makeDoubleArray(
[]) == storage.getEntryValue("doublearr/empty")
assert Value.makeDoubleArray([0.5
]) == storage.getEntryValue("doublearr/one")
assert Value.makeDoubleArray([0.5, -0.25
]) == storage.getEntryValue("doublearr/two")
assert Value.makeStringArray(
[]) == storage.getEntryValue("stringarr/empty")
assert Value.makeStringArray(["hello"
]) == storage.getEntryValue("stringarr/one")
assert Value.makeStringArray(["hello", "world\n"
]) == storage.getEntryValue("stringarr/two")
assert Value.makeBoolean(True) == storage.getEntryValue("\0\3\5\n")
assert Value.makeBoolean(True) == storage.getEntryValue(
"CaseSensitive/KeyName")