def test_parse_message_desc(self, line, can_id, expected_desc):
parser = DBCParser()
node = CANNode('Node0')
node.add_message(CANMessage(can_id, 'CANMessage', 8))
parser._can_network.add_node(node)
parser._parse_line(line)
assert parser._can_network.nodes['Node0'].messages[1234].description == expected_desc
def test_parse_signal(self, line, signal_name, start_bit, length, little_endian, signed, factor, offset, value_min,\
value_max, unit, is_multiplexer, multiplexer_id, nodes, add_multiplexer):
parser = DBCParser()
parser._can_network.add_node(CANNode('Sender'))
for node in nodes:
parser._can_network.add_node(CANNode(node))
msg = CANMessage(2, 'CANMessage', 8)
if add_multiplexer:
msg.add_signal(CANSignal('MultiplexerSignal', 8, 8, is_multiplexer=True))
parser._can_network.nodes['Sender'].add_message(msg)
parser._mode = ('MESSAGE', msg)
parser._parse_line(line)
sig = msg.signals[signal_name]
assert sig.name == signal_name
assert sig.start_bit == start_bit
assert sig.length == length
assert sig.little_endian == little_endian
assert sig.signed == signed
assert sig.factor == factor
assert sig.value_min == value_min
assert sig.value_max == value_max
assert sig.unit == unit
assert sig.is_multiplexer == is_multiplexer
assert sig.multiplexer_id == multiplexer_id
for node in nodes:
assert parser._can_network.nodes[node] in sig.receiver
def test_get_message(self):
cn = CANNetwork()
node = CANNode('TestNode')
msg = CANMessage(1234, 'Message', 8)
node.add_message(msg)
cn.add_node(node)
assert cn.get_message(can_id=1234) == msg
def test_get_none_signal_with_message(self):
cn = CANNetwork()
node = CANNode('TestNode')
msg = CANMessage(1234, 'Message', 8)
node.add_message(msg)
sig = CANSignal('Signal', 0, 8)
cn.add_node(node)
assert cn.get_signal(can_id=1234, name='Signal') == None
def test_parse_signal_desc(self, line, can_id, signal_name, expected_desc):
parser = DBCParser()
node = CANNode('Node')
msg = CANMessage(can_id, 'Message', 8)
sig = CANSignal(signal_name, 0, 8)
msg.add_signal(sig)
node.add_message(msg)
parser._can_network.add_node(node)
parser._parse_line(line)
assert sig.description == expected_desc
def test_get_consumed_messages(self):
cn = CANNetwork()
cn.add_node(CANNode('SendingNode'))
cn.add_node(CANNode('ReceivingNode'))
cn.nodes['SendingNode'].add_message(CANMessage(1, 'Message', 1))
sig = CANSignal('Signal', 0, 8)
sig.add_receiver(cn.nodes['ReceivingNode'])
cn.nodes['SendingNode'].messages[1].add_signal(sig)
assert cn.nodes['SendingNode'].messages[1] in cn.get_consumed_messages(
cn.nodes['ReceivingNode'])
def test_parse_val(self, line, msg_id, signal_name, expected_dict, val_table_name):
parser = DBCParser()
if val_table_name:
parser._can_network.add_value_dict(val_table_name, expected_dict)
node = CANNode('Node')
parser._can_network.add_node(node)
msg = CANMessage(msg_id, 'Message', 1)
node.add_message(msg)
sig = CANSignal(signal_name, 0, 8)
msg.add_signal(sig)
parser._parse_line(line)
assert sig.value_dict == expected_dict
def _parse_nodes(self, nodes_str):
"""Parses a nodes string and updates the CANBus
Args:
nodes_str: String containing nodes informations
"""
reg = re.search('BU_\s*:\s*(?P<nodes>.+)\s*', nodes_str)
node_names_str = re.sub('\s+', ' ', reg.group('nodes')).strip()
for node_name in node_names_str.split(' '):
self._can_network.add_node(CANNode(node_name))
def test_parse_message(self, line, expected_name, expected_id, expected_length, expected_sender):
parser = DBCParser()
sender = CANNode(expected_sender)
parser._can_network.add_node(sender)
parser._parse_line(line)
msg = parser._can_network.get_message(1234)
assert msg.name == expected_name
assert msg.can_id == expected_id
assert msg.length == expected_length
assert msg.sender == sender
def test_parse_attribute(self, line, expected_value, attr_definition, cfg_dict):
parser = DBCParser()
parser._can_network.attributes.add_definition(attr_definition)
if attr_definition.obj_type == CANNetwork:
can_object = parser._can_network
if attr_definition.obj_type in [CANNode, CANMessage, CANSignal]:
cfg_dict['NODE'] = CANNode(cfg_dict['NODE'])
parser._can_network.add_node(cfg_dict['NODE'])
can_object = cfg_dict['NODE']
if attr_definition.obj_type in [CANMessage, CANSignal]:
cfg_dict['MESSAGE'] = CANMessage(cfg_dict['MESSAGE'], 'Message', 1)
cfg_dict['NODE'].add_message(cfg_dict['MESSAGE'])
can_object = cfg_dict['MESSAGE']
if attr_definition.obj_type in [CANSignal]:
cfg_dict['SIGNAL'] = CANSignal(cfg_dict['SIGNAL'], 0, 8)
cfg_dict['MESSAGE'].add_signal(cfg_dict['SIGNAL'])
can_object = cfg_dict['SIGNAL']
parser._parse_line(line)
assert can_object.attributes[attr_definition.name].value == expected_value
def test_parse_node_desc(self, line, node, expected_desc):
parser = DBCParser()
parser._can_network.add_node(CANNode(node))
parser._parse_line(line)
assert parser._can_network.nodes[node].description == expected_desc
def test_parse_signal_wrong_block(self):
parser = DBCParser()
node = CANNode('Node0')
parser._mode = ('NORMAL', None)
with pytest.raises(RuntimeError):
parser._parse_line('SG_ DUMMY_LINE')
def test_set_message_sender(self):
node = CANNode('TestNode')
node.add_message(CANMessage(1, 'Name', 8))
assert node.messages[1].sender == node
def test_add_message_with_sender(self):
msg = CANMessage(1, 'Name', 8)
msg.sender = CANNode('TestNode')
node = CANNode('TestNode')
with pytest.raises(RuntimeError):
node.add_message(msg)
def test_add_receiver(self):
node = CANNode('TestNode')
sig = CANSignal('Signal', 0, 8)
sig.add_receiver(node)
assert len(sig.receiver) == 1
def test_add_node(self):
cn = CANNetwork()
node = CANNode('TestNode')
cn.add_node(node)
assert 'TestNode' in cn.nodes
assert node.parent == cn
def test_add_message(self):
node = CANNode('TestNode')
msg = CANMessage(1, 'Name', 6)
node.add_message(msg)
assert 1 in node.messages
assert msg.parent == node
def test_get_node(self):
cn = CANNetwork()
node = CANNode('TestNode')
cn.add_node(node)
assert cn.nodes['TestNode'] == node
