def test_int_two_signals(self):
msg = CANMessage(1, 'Name', 2)
sig0 = CANSignal('Signal0', 0, 8)
sig0.raw_value = 159
msg.add_signal(sig0)
sig1 = CANSignal('Signal1', 8, 8)
sig1.raw_value = 96
msg.add_signal(sig1)
assert int(msg) == int(sig0.bits) + (int(sig1.bits) << 8)
def test_value_dict(self):
sig = CANSignal('Signal', 0, 8)
sig.value_dict = {0: 'Value0'}
sig.raw_value = 0
assert sig.value == sig.value_dict[sig.raw_value]
sig.raw_value = 1
assert sig.value == sig.raw_value
def test_signal_multiplexer_settings_check(self, old_sig_is_m,
old_sig_m_id, new_sig_is_m,
new_sig_m_id, expected_result):
msg = CANMessage(1, 'Message', 2)
msg.add_signal(
CANSignal('OldSignal',
0,
8,
multiplexer_id=old_sig_m_id,
is_multiplexer=old_sig_is_m))
assert msg._check_if_multiplexer_settings_are_valid(
CANSignal('OldSignal',
0,
8,
multiplexer_id=new_sig_m_id,
is_multiplexer=new_sig_is_m)) == expected_result
def test_signal_fit_check(self, msg_size, new_sig_def, existing_sigs_def,
expected_result):
msg = CANMessage(1, 'Message', msg_size)
for i, sig_def in enumerate(existing_sigs_def):
msg.add_signal(
CANSignal('Signal{}'.format(i),
sig_def[0],
sig_def[1],
is_multiplexer=sig_def[2],
multiplexer_id=sig_def[3]))
assert msg._check_if_signal_fits(
CANSignal('NewSignal',
new_sig_def[0],
new_sig_def[1],
is_multiplexer=new_sig_def[2],
multiplexer_id=new_sig_def[3])) == expected_result
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_value_setter_min_max(self):
sig = CANSignal('Signal', 0, 8)
sig.value_min = 4
sig.value_max = 8
sig.value = 3.9
assert sig.value == 4
sig.value = 8.1
assert sig.value == 8
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_raw_value_setter_signing_exception(self):
sig = CANSignal('Signal', 0, 8)
sig.signed = False
sig.raw_value = 0
sig.raw_value = 10
with pytest.raises(AttributeError):
sig.raw_value = -1
sig.signed = True
sig.raw_value = -1
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 test_raw_value_setter_exceed_length(self):
sig = CANSignal('Signal', 0, 3)
sig.raw_value = 7
assert sig.raw_value == 7
with pytest.raises(AttributeError):
sig.raw_value = 8
sig.signed = True
sig.raw_value = 3
assert sig.raw_value == 3
sig.raw_value = -3
assert sig.raw_value == -3
with pytest.raises(AttributeError):
sig.raw_value = 4
assert sig.raw_value == -3
with pytest.raises(AttributeError):
sig.raw_value = -4
assert sig.raw_value == -3
def _parse_signal(self, signal_str):
"""Parses a signal string and updates the CANBus
Args:
signal_str: String with signal informations
Raises:
RuntimeError: If signal definition is not in a message block
"""
if self._mode[0] != 'MESSAGE':
raise RuntimeError('Signal description not in message block')
pattern = 'SG_\s+(?P<name>\S+)\s*(?P<is_multipexer>M)?(?P<multiplexer_id>m\d+)?\s*:\s*'
pattern += '(?P<start_bit>\d+)\|(?P<length>\d+)\@(?P<endianness>[0|1])(?P<sign>[\+|\-])\s*'
pattern += '\(\s*(?P<factor>\S+)\s*,\s*(?P<offset>\S+)\s*\)\s*'
pattern += '\[\s*(?P<min_value>\S+)\s*\|\s*(?P<max_value>\S+)\s*\]\s*"(?P<unit>\S*)"\s+(?P<receivers>.+)'
reg = re.search(pattern, signal_str)
little_endian = True if reg.group(
'endianness').strip() == '1' else False
signed = True if reg.group('sign').strip() == '-' else False
receivers = [
receiver.strip() for receiver in re.sub(
'\s+', ' ', reg.group('receivers')).strip().split(' ')
]
is_multiplexer = True if reg.group('is_multipexer') else False
multiplexer_id = int(reg.group('multiplexer_id').strip()
[1:]) if reg.group('multiplexer_id') else None
signal = CANSignal(name=reg.group('name').strip(),
start_bit=int(reg.group('start_bit')),
length=int(reg.group('length')),
little_endian=little_endian,
signed=signed,
factor=float(reg.group('factor')),
offset=float(reg.group('offset')),
value_min=float(reg.group('min_value')),
value_max=float(reg.group('max_value')),
unit=reg.group('unit').strip(),
is_multiplexer=is_multiplexer,
multiplexer_id=multiplexer_id)
for node_name in receivers:
node = self._can_network.nodes[node_name]
signal.add_receiver(node)
self._mode[1].add_signal(signal)
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_add_signal_with_message(self):
sig = CANSignal('Signal', 0, 8)
sig.message = CANMessage(1, 'Name', 8)
msg = CANMessage(2, 'Name', 8)
with pytest.raises(RuntimeError):
msg.add_signal(sig)
def test_int(self):
msg = CANMessage(1, 'Name', 1)
sig = CANSignal('Signal', 0, 8)
sig.raw_value = 100
msg.add_signal(sig)
assert int(msg) == 100
def test_int_splitted(self):
msg = CANMessage(1, 'Name', 2)
sig = CANSignal('Signal', 4, 8)
sig.raw_value = 100
msg.add_signal(sig)
assert int(msg) == int(sig.bits) << 4
def test_signal_multiplexer_settings_check_fail(self):
msg = CANMessage(1, 'Message', 1)
with pytest.raises(RuntimeError):
msg.add_signal(CANSignal('Signal', 0, 8, multiplexer_id=1))
def test_signal_fit_check_fail(self):
msg = CANMessage(1, 'Message', 1)
with pytest.raises(RuntimeError):
msg.add_signal(CANSignal('Signal', 0, 10))
def test_add_receiver(self):
node = CANNode('TestNode')
sig = CANSignal('Signal', 0, 8)
sig.add_receiver(node)
assert len(sig.receiver) == 1
def test_bits_setter(self):
sig = CANSignal('Signal', 0, 8)
ba = BitArray(size=8, value=200)
sig.bits = ba
assert sig.raw_value == 200
def test_value_setter_raw_value(self):
sig = CANSignal('Signal', 0, 8)
sig.value = 10
assert sig.raw_value == 10
def test_value_setter_raw_value_conversion(self):
sig = CANSignal('Signal', 0, 8)
sig.factor = 2.5
sig.offset = 1.25
sig.value = 11.25
assert sig.raw_value == 4
def test_value_getter(self):
sig = CANSignal('Signal', 0, 8)
sig.factor = 2.5
sig.offset = 1.25
sig.raw_value = 2
assert sig.value == sig.raw_value * 2.5 + 1.25
def test_raw_value_setter_only_int(self):
sig = CANSignal('Signal', 0, 3)
with pytest.raises(AttributeError):
sig.raw_value = None
with pytest.raises(AttributeError):
sig.raw_value = 'a'
def test_add_signal(self):
msg = CANMessage(1, 'Name', 8)
sig = CANSignal('Signal', 0, 8)
msg.add_signal(sig)
assert 'Signal' in msg.signals
assert sig.parent == msg
def test_raw_value_getter(self):
sig = CANSignal('Signal1', 0, 8)
sig._raw_value = 10
assert sig.raw_value == 10
def test_int_repr(self):
sig = CANSignal('Signal1', 0, 8)
sig._raw_value = 10
assert int(sig) == 10
