def test_slotid_binary_parsing():
"""Make sure we can generate and parse binary descriptors."""
slot_id = SlotIdentifier.FromString('slot 1')
assert SlotIdentifier.FromEncoded(slot_id.encode()) == slot_id
con = SlotIdentifier.FromString('controller')
assert SlotIdentifier.FromEncoded(con.encode()) == con
def test_streamers(parser):
"""Make sure we can compile streamer statements."""
parser.parse_file(get_path(u'basic_streamer.sgf'))
model = DeviceModel()
parser.compile(model=model)
streamers = parser.sensor_graph.streamers
assert len(streamers) == 3
assert streamers[0].dest == SlotIdentifier.FromString('controller')
assert streamers[1].dest == SlotIdentifier.FromString('slot 1')
assert streamers[1].with_other == 0
assert streamers[2].dest == SlotIdentifier.FromString('controller')
assert streamers[2].report_type == 'broadcast'
def Restore(cls, state):
"""Unserialize this object."""
target = SlotIdentifier.FromString(state.get('target'))
data = base64.b64decode(state.get('data'))
var_id = state.get('var_id')
valid = state.get('valid')
return ConfigEntry(target, var_id, data, valid)
def test_config_block(parser):
"""Make sure config blocks and statement are parsed."""
parser.parse_file(get_path(u'basic_config.sgf'))
model = DeviceModel()
parser.compile(model=model)
sg = parser.sensor_graph
assert len(sg.config_database) == 5
assert sg.get_config(SlotIdentifier.FromString('controller'),
0x2000) == (u'uint32_t', 5)
assert sg.get_config(SlotIdentifier.FromString('slot 1'),
0x5000) == (u'uint8_t', 10)
assert sg.get_config(SlotIdentifier.FromString('slot 2'),
0x5100) == (u'int8_t', -10)
assert sg.get_config(SlotIdentifier.FromString('slot 3'),
0x5200) == (u'uint8_t[]', u'[10,20,30,40]')
assert sg.get_config(SlotIdentifier.FromString('slot 4'),
0x5300) == (u'string', u'test')
def test_usertick():
"""Make sure we properly can set the user tick input."""
model = DeviceModel()
log = SensorLog(model=model)
sg = SensorGraph(log, model=model)
assert sg.get_tick('fast') == 0
sg.add_config(SlotIdentifier.FromString('controller'), config_fast_tick_secs, 'uint32_t', 1)
assert sg.get_tick('fast') == 1
def test_config_block_binary(parser):
"""Make sure config blocks can parse binary config variables."""
parser.parse_file(get_path(u'binary_config.sgf'))
model = DeviceModel()
parser.compile(model=model)
sg = parser.sensor_graph
assert len(sg.config_database) == 2
valtype, val = sg.get_config(SlotIdentifier.FromString('slot 1'), 0x2000)
assert valtype == u'binary'
assert isinstance(val, bytes)
def __init__(self, parsed, location=None):
realtime = 'realtime' in parsed
broadcast = 'broadcast' in parsed
encrypted = 'security' in parsed and parsed['security'] == 'encrypted'
signed = 'security' in parsed and parsed['security'] == 'signed'
self.auto = 'manual' not in parsed
self.with_other = None
if 'with_other' in parsed:
self.with_other = parsed['with_other']
self.auto = False
dest = SlotIdentifier.FromString('controller')
if 'explicit_tile' in parsed:
dest = parsed['explicit_tile']
selector = parsed['selector']
# Make sure all of the combination are valid
if realtime and (encrypted or signed):
raise SensorGraphSemanticError(
"Realtime streamers cannot be either signed or encrypted")
if broadcast and (encrypted or signed):
raise SensorGraphSemanticError(
"Broadcast streamers cannot be either signed or encrypted")
super(StreamerStatement, self).__init__([], location)
self.report_type = 'broadcast' if broadcast else 'telegram'
self.dest = dest
self.selector = selector
if realtime or broadcast:
self.report_format = u'individual'
elif signed:
self.report_format = u'signedlist_userkey'
elif encrypted:
raise SensorGraphSemanticError(
"Encrypted streamers are not yet supported")
else:
self.report_format = u'hashedlist'
def process_mock_rpc(input_string):
"""Process a mock RPC argument.
Args:
input_string (str): The input string that should be in the format
<slot id>:<rpc id> = value
"""
spec, equals, value = input_string.partition(u'=')
if len(equals) == 0:
print("Could not parse mock RPC argument: {}".format(input_string))
sys.exit(1)
try:
value = int(value.strip(), 0)
except ValueError as exc:
print("Could not parse mock RPC value: {}".format(str(exc)))
sys.exit(1)
slot, part, rpc_id = spec.partition(u":")
if len(part) == 0:
print("Could not parse mock RPC slot/rpc definition: {}".format(spec))
sys.exit(1)
try:
slot = SlotIdentifier.FromString(slot)
except ArgumentError as exc:
print("Could not parse slot id in mock RPC definition: {}".format(
exc.msg))
sys.exit(1)
try:
rpc_id = int(rpc_id, 0)
except ValueError as exc:
print("Could not parse mock RPC number: {}".format(str(exc)))
sys.exit(1)
return slot, rpc_id, value
def test_language_constructs():
"""Make sure the basic sensor graph language constructs work."""
# Create the parser
language.get_language()
# Test time interval parsing
parsed = language.time_interval.parseString('1 day')
assert parsed.asList()[0] == 60*60*24
# Test block id parsing
parsed = language.block_id.parseString('every 1 day')
assert parsed.asList()[0][1][0] == 60*60*24
# Test block parsing
parsed = language.block_bnf.parseString('every 1 day {}')
assert parsed.asList()[0][0][1][0] == 60*60*24
# Test stream parsing
parsed = language.stream.parseString('output 1')
assert isinstance(parsed.asList()[0], DataStream)
# Test call_rpc statement
parsed = language.callrpc_stmt.parseString(u'call 0x4001 on slot 1 => output 1;')
assert parsed.asList()[0][0] == 0x4001
# Test block with statement parsing
parsed = language.block_bnf.parseString(u'every 1 day { call 0x5001 on slot 2 => output 1; }')
assert parsed.asList()[0][0][1][0] == 60*60*24
# Test parsing stream_trigger
parsed = language.stream_trigger.parseString(u'value(input 2) == 10')
assert parsed[0].getName() == u'stream_trigger'
parsed = language.stream_trigger.parseString(u'count(output 1) <= 10')
assert parsed[0].getName() == u'stream_trigger'
# Test parsing on block with identifier
parsed = language.block_bnf.parseString(u'on test_identifier {}')
print(parsed)
assert parsed[0][0][1][0][0].getName() == u'identifier'
assert parsed[0][0][1][0][0][0] == u'test_identifier'
parsed = language.block_bnf.parseString(u'on value(input 2) >= 5 {}')
assert parsed[0][0][1][0][0].getName() == u'stream_trigger'
assert parsed[0][0][1][0][0][0] == u'value'
assert parsed[0][0][1][0][0][1] == DataStream.FromString('input 2')
assert parsed[0][0][1][0][0][2] == u'>='
assert parsed[0][0][1][0][0][3] == 5
# Test parsing on block with 2 conditions
parsed = language.block_bnf.parseString(u'on test_identifier and hello_id {}')
assert parsed[0][0][1][0][0].getName() == u'identifier'
assert parsed[0][0][1][0][0][0] == u'test_identifier'
assert parsed[0][0][1][2][0].getName() == u'identifier'
assert parsed[0][0][1][2][0][0] == u'hello_id'
assert parsed[0][0][1][1] == u'and'
parsed = language.block_bnf.parseString(u'on test_identifier or value(constant 1) == 2 {}')
assert parsed[0][0][1][0][0].getName() == u'identifier'
assert parsed[0][0][1][0][0][0] == u'test_identifier'
assert parsed[0][0][1][1] == u'or'
# Test parsing subtract statements
parsed = language.subtract_stmt.parseString(u"subtract constant 1 => unbuffered 2, default 10;")
assert parsed[0].getName() == 'subtract_statement'
assert parsed[0][0] == DataStream.FromString('constant 1')
assert parsed[0][1] == DataStream.FromString('unbuffered 2')
assert parsed[0]['default'] == 10
parsed = language.subtract_stmt.parseString(u"subtract constant 1 => unbuffered 2;")
assert parsed[0].getName() == 'subtract_statement'
assert parsed[0][0] == DataStream.FromString('constant 1')
assert parsed[0][1] == DataStream.FromString('unbuffered 2')
# Test parser streamer statements
parsed = language.streamer_stmt.parseString(u'manual streamer on output 1;')
assert parsed[0]['selector'] == DataStreamSelector.FromString('output 1')
parsed = language.streamer_stmt.parseString(u'manual streamer on all system outputs;')
assert parsed[0]['selector'] == DataStreamSelector.FromString('all system outputs')
parsed = language.streamer_stmt.parseString(u'manual signed streamer on output 1 to slot 1;')
assert parsed[0]['selector'] == DataStreamSelector.FromString('output 1')
assert parsed[0]['explicit_tile'] == SlotIdentifier.FromString('slot 1')
assert parsed[0]['security'] == u'signed'
parsed = language.streamer_stmt.parseString(u'manual broadcast streamer on output 1 to slot 1;')
assert parsed[0]['selector'] == DataStreamSelector.FromString('output 1')
assert parsed[0]['explicit_tile'] == SlotIdentifier.FromString('slot 1')
assert parsed[0]['broadcast'] == u'broadcast'
# Test parsing copy statements
parsed = language.simple_statement.parseString(u'copy unbuffered 1 => unbuffered 2;')
assert parsed[0]['explicit_input'][0] == DataStream.FromString('unbuffered 1')
parsed = language.simple_statement.parseString(u'copy 15 => unbuffered 2;')
assert parsed[0]['constant_input'] == 15
parsed = language.simple_statement.parseString(u'copy 0x20 => unbuffered 2;')
assert parsed[0]['constant_input'] == 0x20
def test_slotid_parsing():
"""Make sure we can parse slot identifiers correctly."""
slot_id = SlotIdentifier.FromString('slot 1')
assert slot_id.address == 11
slot_id = SlotIdentifier.FromString(u'slot 1')
assert slot_id.address == 11
slot_id = SlotIdentifier.FromString(u'slot 0x1')
assert slot_id.address == 11
slot_id = SlotIdentifier.FromString('controller')
assert slot_id.address == 8
slot_id = SlotIdentifier.FromString(u'controller')
assert slot_id.address == 8
with pytest.raises(ArgumentError):
SlotIdentifier.FromString(u'asdf')
with pytest.raises(ArgumentError):
SlotIdentifier.FromString(u'controller 15')
with pytest.raises(ArgumentError):
SlotIdentifier.FromString(u'slot ab')
slot1 = SlotIdentifier.FromString('slot 1')
slot2 = SlotIdentifier.FromString('slot 1')
con = SlotIdentifier.FromString('controller')
assert slot1 == slot2
assert not con == slot1
assert con != slot1
