def prepare_modulation_dialog(
self) -> (ModulatorDialogController, Message):
preselected_index = self.ui.cBoxModulations.currentIndex()
min_row, max_row, start, end = self.ui.tableMessages.selection_range()
if min_row > -1:
try:
selected_message = self.table_model.protocol.messages[min_row]
preselected_index = selected_message.modulator_indx
except IndexError:
selected_message = Message([True, False, True, False], 0, [],
MessageType("empty"))
else:
selected_message = Message([True, False, True, False], 0, [],
MessageType("empty"))
if len(self.table_model.protocol.messages) > 0:
selected_message.bit_len = self.table_model.protocol.messages[
0].bit_len
for m in self.modulators:
m.default_sample_rate = self.project_manager.device_conf[
"sample_rate"]
modulator_dialog = ModulatorDialogController(self.modulators,
parent=self.parent())
modulator_dialog.ui.treeViewSignals.setModel(self.tree_model)
modulator_dialog.ui.treeViewSignals.expandAll()
modulator_dialog.ui.comboBoxCustomModulations.setCurrentIndex(
preselected_index)
modulator_dialog.finished.connect(self.refresh_modulators)
modulator_dialog.finished.connect(self.refresh_pause_list)
return modulator_dialog, selected_message
def prepare_modulation_dialog(self) -> (ModulatorDialog, Message):
preselected_index = self.ui.cBoxModulations.currentIndex()
min_row, max_row, start, end = self.ui.tableMessages.selection_range()
if min_row > -1:
try:
selected_message = self.table_model.protocol.messages[min_row]
preselected_index = selected_message.modulator_index
except IndexError:
selected_message = Message(
[1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0], 0, [],
MessageType("empty"))
else:
selected_message = Message(
[1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0], 0, [],
MessageType("empty"))
if len(self.table_model.protocol.messages) > 0:
selected_message.samples_per_symbol = self.table_model.protocol.messages[
0].samples_per_symbol
for m in self.modulators:
m.default_sample_rate = self.project_manager.device_conf[
"sample_rate"]
modulator_dialog = ModulatorDialog(self.modulators,
tree_model=self.tree_model,
parent=self.parent())
modulator_dialog.ui.comboBoxCustomModulations.setCurrentIndex(
preselected_index)
modulator_dialog.finished.connect(self.refresh_modulators)
modulator_dialog.finished.connect(self.refresh_pause_list)
return modulator_dialog, selected_message
def test_configure_crc_parameters(self):
crc_label = ChecksumLabel(
"crc_label", 25, 120, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
crc_label, Message([0] * 150, 0, MessageType("test")), 0)
crc = GenericCRC(
polynomial=list(GenericCRC.DEFAULT_POLYNOMIALS.keys())[0])
self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(),
crc.polynomial_as_hex_str)
self.assertEqual(crc_widget_controller.ui.lineEditStartValue.text(),
util.bit2hex(crc.start_value))
self.assertEqual(crc_widget_controller.ui.lineEditFinalXOR.text(),
util.bit2hex(crc.final_xor))
crc_widget_controller.ui.comboBoxCRCFunction.setCurrentIndex(2)
crc.polynomial = crc.choose_polynomial(2)
self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(),
crc.polynomial_as_hex_str)
crc_widget_controller.ui.lineEditCRCPolynomial.setText("abcde")
crc_widget_controller.ui.lineEditCRCPolynomial.editingFinished.emit()
self.assertEqual(crc_label.checksum.polynomial,
array.array("B", [1]) + util.hex2bit("abcde"))
crc_widget_controller.ui.lineEditStartValue.setText("12345")
crc_widget_controller.ui.lineEditStartValue.editingFinished.emit()
self.assertEqual(util.bit2hex(crc_label.checksum.start_value), "12345")
crc_widget_controller.ui.lineEditFinalXOR.setText("cccaa")
crc_widget_controller.ui.lineEditFinalXOR.editingFinished.emit()
self.assertEqual(util.bit2hex(crc_label.checksum.final_xor), "cccaa")
def test_default_crcs(self):
crc_label = ChecksumLabel(
"crc_label", 25, 120, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
crc_label, Message([0] * 150, 0, MessageType("test")), 0)
default_crc_polynomials = GenericCRC.DEFAULT_POLYNOMIALS
special_crcs = ChecksumWidgetController.SPECIAL_CRCS
self.assertEqual(
len(default_crc_polynomials) + len(special_crcs),
crc_widget_controller.ui.comboBoxCRCFunction.count())
for i, default_polynomial_name in enumerate(default_crc_polynomials):
self.assertEqual(
default_polynomial_name,
crc_widget_controller.ui.comboBoxCRCFunction.itemText(i))
for i, special_crc in enumerate(special_crcs):
self.assertEqual(
special_crc,
crc_widget_controller.ui.comboBoxCRCFunction.itemText(
i + len(default_crc_polynomials)))
crc_widget_controller.ui.comboBoxCRCFunction.setCurrentIndex(1)
self.assertNotEqual(
crc_widget_controller.ui.comboBoxCRCFunction.currentText(),
"8_standard")
crc_widget_controller.ui.comboBoxCRCFunction.setCurrentText(
"8_standard")
self.assertEqual(
crc_widget_controller.ui.comboBoxCRCFunction.currentText(),
"8_standard")
self.assertEqual(crc_widget_controller.ui.lineEditCRCPolynomial.text(),
"d5")
def test_message_break_plugin(self):
bp = MessageBreakPlugin()
n = 1
action = bp.get_action(self.cframe.ui.tblViewProtocol,
self.cframe.protocol_undo_stack, (n, n, 4, 4),
self.cframe.proto_analyzer, 0)
self.assertEqual(self.cframe.protocol_model.row_count, 3)
original_msg = self.cframe.proto_analyzer.messages[n]
original_msg.message_type = MessageType(
"Test", [ProtocolLabel("Test Label", 2, 42, 0)])
msg_type = original_msg.message_type
old_msg_len = len(original_msg)
action.trigger()
# Now we have two messages: One before and including selection and one behind selection
msg_1 = self.cframe.proto_analyzer.messages[n]
msg_2 = self.cframe.proto_analyzer.messages[n + 1]
self.assertEqual(len(msg_1), 4)
self.assertEqual(len(msg_2), old_msg_len - 4)
self.assertEqual(msg_type, msg_1.message_type)
self.assertEqual(msg_type, msg_2.message_type)
self.assertEqual(self.cframe.protocol_model.row_count, 4)
self.cframe.protocol_undo_stack.undo()
self.assertEqual(self.cframe.protocol_model.row_count, 3)
def test_crc_widget_in_protocol_label_dialog(self):
mt = MessageType("test")
mt.append(
ChecksumLabel("test_crc", 8, 16, 0,
FieldType("test_crc", FieldType.Function.CHECKSUM)))
self.dialog = ProtocolLabelController(0, Message([0] * 100, 0, mt), 0)
self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.count(), 1)
self.assertEqual(self.dialog.ui.tabWidgetAdvancedSettings.tabText(0),
"test_crc")
def add_new_message_type(self, labels):
names = set(message_type.name for message_type in self.message_types)
name = "Message type #"
i = 0
while True:
i += 1
if name + str(i) not in names:
self.message_types.append(
MessageType(name=name + str(i), iterable=[copy.deepcopy(lbl) for lbl in labels]))
break
def create_message(self, destination, plain_bits, pause, message_type, decoder, source):
if destination is None:
destination = self.simulator_config.broadcast_part
sim_message = SimulatorMessage(destination=destination, plain_bits=plain_bits, pause=pause,
message_type=MessageType(message_type.name), decoder=decoder, source=source)
for lbl in message_type:
sim_label = SimulatorProtocolLabel(copy.deepcopy(lbl))
sim_message.insert_child(-1, sim_label)
return sim_message
def __init__(self, signal: Signal):
self.messages = [] # type: list[Message]
self.signal = signal
self.filename = self.signal.filename if self.signal is not None else ""
self.__name = "Blank" # Fallback if Signal has no Name
self.show = Qt.Checked # Show in Compare Frame?
self.qt_signals = ProtocolAnalyzerSignals()
self.decoder = Encoding(["Non Return To Zero (NRZ)"]) # For Default Encoding of Protocol
self.message_types = [MessageType("default")]
def test_homematic(self):
proto_file = get_path_for_data_file("homematic.proto.xml")
protocol = ProtocolAnalyzer(signal=None, filename=proto_file)
protocol.message_types = []
protocol.from_xml_file(filename=proto_file, read_bits=True)
# prevent interfering with preassinged labels
protocol.message_types = [MessageType("Default")]
participants = sorted({msg.participant for msg in protocol.messages})
self.clear_message_types(protocol.messages)
ff = FormatFinder(protocol.messages, participants=participants)
ff.known_participant_addresses.clear()
ff.perform_iteration()
self.assertGreater(len(ff.message_types), 0)
for i, message_type in enumerate(ff.message_types):
preamble = message_type.get_first_label_with_type(FieldType.Function.PREAMBLE)
self.assertEqual(preamble.start, 0)
self.assertEqual(preamble.length, 32)
sync = message_type.get_first_label_with_type(FieldType.Function.SYNC)
self.assertEqual(sync.start, 32)
self.assertEqual(sync.length, 32)
length = message_type.get_first_label_with_type(FieldType.Function.LENGTH)
self.assertEqual(length.start, 64)
self.assertEqual(length.length, 8)
seq = message_type.get_first_label_with_type(FieldType.Function.SEQUENCE_NUMBER)
self.assertEqual(seq.start, 72)
self.assertEqual(seq.length, 8)
src = message_type.get_first_label_with_type(FieldType.Function.SRC_ADDRESS)
self.assertEqual(src.start, 96)
self.assertEqual(src.length, 24)
dst = message_type.get_first_label_with_type(FieldType.Function.DST_ADDRESS)
self.assertEqual(dst.start, 120)
self.assertEqual(dst.length, 24)
checksum = message_type.get_first_label_with_type(FieldType.Function.CHECKSUM)
self.assertEqual(checksum.length, 16)
self.assertIn("CC1101", checksum.checksum.caption)
for msg_index in ff.existing_message_types[message_type]:
msg_len = len(protocol.messages[msg_index])
self.assertEqual(checksum.start, msg_len-16)
self.assertEqual(checksum.end, msg_len)
def test_find_unlabeled_range(self):
lbl11 = ProtocolLabel(name="Label 1.1", start=2, end=10, color_index=0)
lbl12 = ProtocolLabel(name="Label 1.2",
start=15,
end=20,
color_index=0)
lbl13 = ProtocolLabel(name="Label 1.3",
start=40,
end=60,
color_index=0)
mt1 = MessageType(name="MT1", iterable=[lbl11, lbl12, lbl13])
self.assertEqual([(0, 2), (11, 15), (21, 40), (61, None)],
mt1.unlabeled_ranges)
self.assertEqual([(0, 2), (11, 15), (21, 40), (61, None)],
mt1.unlabeled_ranges_with_other_mt(mt1))
lbl21 = ProtocolLabel(name="Label 2.1", start=1, end=11, color_index=0)
lbl22 = ProtocolLabel(name="Label 2.2",
start=14,
end=18,
color_index=0)
lbl23 = ProtocolLabel(name="Label 2.3",
start=50,
end=70,
color_index=0)
mt2 = MessageType(name="MT2", iterable=[lbl21, lbl22, lbl23])
self.assertEqual(mt1.unlabeled_ranges_with_other_mt(mt2),
mt2.unlabeled_ranges_with_other_mt(mt1))
self.assertEqual(mt1.unlabeled_ranges_with_other_mt(mt2), [(0, 1),
(11, 14),
(21, 40),
(71, None)])
def from_plain_bits_str(bits, symbols: dict):
plain_bits = []
for b in bits:
if b == "0":
plain_bits.append(False)
elif b == "1":
plain_bits.append(True)
else:
try:
plain_bits.append(symbols[b])
except KeyError:
print("[Warning] Did not find symbol name", file=sys.stderr)
plain_bits.append(Symbol(b, 0, 0, 1))
return Message(plain_bits=plain_bits, pause=0, message_type=MessageType("none"))
def generate_rwe(cls, num_messages: int, save_protocol=True):
proto_file = get_path_for_data_file("rwe.proto.xml")
protocol = ProtocolAnalyzer(signal=None, filename=proto_file)
protocol.from_xml_file(filename=proto_file, read_bits=True)
messages = protocol.messages
result = ProtocolAnalyzer(None)
message_type = MessageType("empty")
for i in range(num_messages):
msg = messages[i % len(messages)] # type: Message
msg.message_type = message_type
result.messages.append(msg)
if save_protocol:
cls.save_protocol("rwe", result)
return result
def add_empty_message(self, num_bits):
if hasattr(self.sender(), "data") and self.sender().data():
message_type = self.sender().data()
else:
message_type = MessageType("Default")
ref_item = self.context_menu_item
if isinstance(ref_item, RuleConditionItem):
position = QAbstractItemView.OnItem
else:
position = QAbstractItemView.BelowItem
message = self.scene().add_message(plain_bits=[0] * num_bits,
pause=0,
message_type=message_type,
ref_item=ref_item,
position=position)
self.jump_to_item(message)
def __init__(self, signal: Signal or None, filename=None):
self.messages = [] # type: list[Message]
self.signal = signal
if filename is None:
self.filename = self.signal.filename if self.signal is not None else ""
else:
assert signal is None
self.filename = filename
self.__name = urh_util.get_name_from_filename(filename) # Fallback if Signal has no Name
self.show = Qt.Checked # Show in Compare Frame?
self.qt_signals = ProtocolAnalyzerSignals()
self.decoder = Encoding(["Non Return To Zero (NRZ)"]) # For Default Encoding of Protocol
self.message_types = [MessageType("Default")]
def test_enocean_checksum(self):
checksum_label = ChecksumLabel(
"checksum_label", 50, 100, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
checksum_label, Message([0] * 100, 0, MessageType("test")), 0)
crc_widget_controller.ui.comboBoxCategory.setCurrentIndex(1)
self.assertEqual(
crc_widget_controller.ui.stackedWidget.currentWidget(),
crc_widget_controller.ui.page_wsp)
self.assertTrue(
crc_widget_controller.ui.radioButtonWSPAuto.isChecked())
crc_widget_controller.ui.radioButtonWSPChecksum8.click()
self.assertEqual(checksum_label.checksum.mode,
WSPChecksum.ChecksumMode.checksum8)
def generate_enocean(cls, num_messages: int, save_protocol=True):
filename = get_path_for_data_file("enocean_bits.txt")
enocean_bits = []
with open(filename, "r") as f:
for line in map(str.strip, f):
enocean_bits.append(line)
protocol = ProtocolAnalyzer(None)
message_type = MessageType("empty")
for i in range(num_messages):
msg = Message.from_plain_bits_str(enocean_bits[i %
len(enocean_bits)])
msg.message_type = message_type
protocol.messages.append(msg)
if save_protocol:
cls.save_protocol("enocean", protocol)
return protocol
def test_message_type_assign_by_value(self):
start = 8
end = 15
hex_value = "9a7d9a7d"
msg_type = MessageType("autotest")
msg_type.ruleset = Ruleset(Mode.all_apply,
[Rule(start, end, "=", hex_value, 1)])
msg_type.assigned_by_ruleset = True
self.protocol.message_types.append(msg_type)
self.protocol.update_auto_message_types()
matching_indices = [0, 2, 3, 21, 23, 24]
for i, message in enumerate(self.protocol.messages):
if i in matching_indices:
self.assertEqual(message.message_type, msg_type, msg=str(i))
else:
self.assertEqual(message.message_type,
self.protocol.default_message_type,
msg=str(i))
def on_add_message_action_triggered(self):
num_bits, ok = QInputDialog.getInt(
self, self.tr("How many bits shall the new message have?"),
self.tr("Number of bits:"), 42, 1)
if ok:
message_type = MessageType("default") if not self.sender().data(
) else self.sender().data()
ref_item = self.context_menu_item
if isinstance(ref_item, RuleConditionItem):
position = QAbstractItemView.OnItem
else:
position = QAbstractItemView.BelowItem
message = self.scene().add_message(plain_bits=[0] * num_bits,
pause=1000000,
message_type=message_type,
ref_item=ref_item,
position=position)
self.jump_to_item(message)
def add_message_type(self, message: SimulatorMessage):
names = set(message_type.name for message_type in self.proto_analyzer.message_types)
name = "Message type #"
i = next(i for i in itertools.count(start=1) if name + str(i) not in names)
msg_type_name, ok = QInputDialog.getText(self, self.tr("Enter message type name"),
self.tr("Name:"), text=name + str(i))
if ok:
msg_type = MessageType(name=msg_type_name)
for lbl in message.message_type:
msg_type.add_protocol_label(start=lbl.start, end=lbl.end - 1, name=lbl.name,
color_ind=lbl.color_index, type=lbl.field_type)
self.proto_analyzer.message_types.append(msg_type)
self.compare_frame_controller.fill_message_type_combobox()
self.compare_frame_controller.active_message_type = self.compare_frame_controller.active_message_type
message.message_type.name = msg_type_name
self.simulator_config.items_updated.emit([message])
def test_configure_crc_ranges(self):
checksum_label = ChecksumLabel(
"checksum_label", 50, 100, 0,
FieldType("crc", FieldType.Function.CHECKSUM))
crc_widget_controller = ChecksumWidgetController(
checksum_label, Message([0] * 100, 0, MessageType("test")), 0)
model = crc_widget_controller.data_range_table_model
self.assertEqual(model.data(model.index(0, 0)), 1)
self.assertEqual(model.data(model.index(0, 1)), 50)
self.assertEqual(model.rowCount(), 1)
crc_widget_controller.ui.btnAddRange.click()
self.assertEqual(model.rowCount(), 2)
crc_widget_controller.ui.btnAddRange.click()
self.assertEqual(model.rowCount(), 3)
crc_widget_controller.ui.btnRemoveRange.click()
self.assertEqual(model.rowCount(), 2)
crc_widget_controller.ui.btnRemoveRange.click()
self.assertEqual(model.rowCount(), 1)
crc_widget_controller.ui.btnRemoveRange.click()
self.assertEqual(model.rowCount(), 1)
def assign_messagetypes(self, messages, clusters):
"""
Assign message types based on the clusters. Following rules:
1) Messages from different clusters will get different message types
2) Messages from same clusters will get same message type
3) The new message type will copy over the existing labels
4) No new message type will be set for messages, that already have a custom message type assigned
For messages with clustername "default" no new message type will be created
:param messages: Messages, that messagetype needs to be clustered
:param clusters: clusters for the messages
:type messages: list[Message]
:type clusters: dict[str, set[int]]
:return:
"""
for clustername, clustercontent in clusters.items():
if clustername == "default":
# Do not force the default message type
continue
for msg_i in clustercontent:
msg = messages[msg_i]
if msg.message_type == self.messagetypes[0]:
# Message has default message type
# Copy the existing labels and create a new message type
# if it was not already done
try:
msg_type = next(mtype for mtype in self.messagetypes
if mtype.name == clustername)
except StopIteration:
msg_type = MessageType(name=clustername,
iterable=msg.message_type)
msg_type.assigned_by_logic_analyzer = True
self.messagetypes.append(msg_type)
msg.message_type = msg_type
def test_performance(self):
self.form = MainController()
self.cfc = self.form.compare_frame_controller
self.stc = self.form.simulator_tab_controller
self.gtc = self.form.generator_tab_controller
self.form.add_signalfile(get_path_for_data_file("esaver.complex16s"))
self.sframe = self.form.signal_tab_controller.signal_frames[0]
self.sim_frame = self.form.simulator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(3)
self.cfc.proto_analyzer.auto_assign_labels()
self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(raw_mode=True)
part_a = Participant("Device A", shortname="A", color_index=0)
part_b = Participant("Device B", shortname="B", color_index=1)
part_b.simulate = True
self.form.project_manager.participants.append(part_a)
self.form.project_manager.participants.append(part_b)
self.form.project_manager.project_updated.emit()
sniffer = ProtocolSniffer(100, 0.01, 0.01, 0.1, 5, "FSK", 1,
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME, BackendHandler(),
network_raw_mode=True)
sender = EndlessSender(BackendHandler(), NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
simulator = Simulator(self.stc.simulator_config, self.gtc.modulators, self.stc.sim_expression_parser,
self.form.project_manager, sniffer=sniffer, sender=sender)
pause = 100
msg_a = SimulatorMessage(part_b,
[1, 0] * 16 + [1, 1, 0, 0] * 8 + [0, 0, 1, 1] * 8 + [1, 0, 1, 1, 1, 0, 0, 1, 1, 1] * 4,
pause=pause, message_type=MessageType("empty_message_type"), source=part_a)
msg_b = SimulatorMessage(part_a,
[1, 0] * 16 + [1, 1, 0, 0] * 8 + [1, 1, 0, 0] * 8 + [1, 0, 1, 1, 1, 0, 0, 1, 1, 1] * 4,
pause=pause, message_type=MessageType("empty_message_type"), source=part_b)
self.stc.simulator_config.add_items([msg_a, msg_b], 0, None)
self.stc.simulator_config.update_active_participants()
port = self.get_free_port()
sniffer = simulator.sniffer
sniffer.rcv_device.set_server_port(port)
self.network_sdr_plugin_sender.client_port = port
sender = simulator.sender
port = self.get_free_port()
sender.device.set_client_port(port)
sender.device._VirtualDevice__dev.name = "simulator_sender"
current_index = Value("L")
elapsed = Value("f")
target_num_samples = 13600 + pause
receive_process = Process(target=receive, args=(port, current_index, target_num_samples, elapsed))
receive_process.daemon = True
receive_process.start()
# Ensure receiver is running
time.sleep(2)
# spy = QSignalSpy(self.network_sdr_plugin_receiver.rcv_index_changed)
simulator.start()
modulator = Modulator("test_modulator")
modulator.samples_per_symbol = 100
modulator.carrier_freq_hz = 55e3
# yappi.start()
self.network_sdr_plugin_sender.send_raw_data(modulator.modulate(msg_a.encoded_bits), 1)
time.sleep(0.5)
# send some zeros to simulate the end of a message
self.network_sdr_plugin_sender.send_raw_data(np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1)
time.sleep(0.5)
receive_process.join(15)
logger.info("PROCESS TIME: {0:.2f}ms".format(elapsed.value))
# self.assertEqual(current_index.value, target_num_samples)
self.assertLess(elapsed.value, 200)
# timeout = spy.wait(2000)
# yappi.get_func_stats().print_all()
# yappi.get_thread_stats().print_all()
def __init__(self, name: str):
self.name = name
self.message_type = MessageType(name)
def push_data(self, data: np.ndarray):
self.ringbuffer.push(data)
if __name__ == '__main__':
from urh.dev.BackendHandler import BackendHandler
from urh.signalprocessing.Message import Message
from urh.signalprocessing.MessageType import MessageType
from urh.signalprocessing.Modulator import Modulator
from urh.util.Logger import logger
import time
endless_sender = EndlessSender(BackendHandler(), "HackRF")
msg = Message([1, 0] * 16 + [1, 1, 0, 0] * 8 + [0, 0, 1, 1] * 8 +
[1, 0, 1, 1, 1, 0, 0, 1, 1, 1] * 4, 0,
MessageType("empty_message_type"))
modulator = Modulator("test_modulator")
modulator.samples_per_bit = 1000
modulator.carrier_freq_hz = 55e3
logger.debug("Starting endless sender")
endless_sender.start()
time.sleep(1)
logger.debug("Pushing data")
endless_sender.push_data(modulator.modulate(msg.encoded_bits))
logger.debug("Pushed data")
time.sleep(5)
logger.debug("Stopping endless sender")
endless_sender.stop()
time.sleep(1)
logger.debug("bye")
def clear_message_types(messages: list):
mt = MessageType("empty")
for msg in messages:
msg.message_type = mt
def __create_messages(self):
mt = MessageType("test")
return [
Message([True] * self.BITS_PER_MESSAGE, 1000, mt)
for _ in range(self.NUM_MESSAGES)
]
def setUp(self):
self.message_type = MessageType(name="Test")
self.dialog = MessageTypeDialog(self.message_type)
if self.SHOW:
self.dialog.show()
def from_plain_bits_str(bits):
plain_bits = list(map(int, bits))
return Message(plain_bits=plain_bits,
pause=0,
message_type=MessageType("none"))
def default_message_type(self) -> MessageType:
if len(self.message_types) == 0:
self.message_types.append(MessageType("Default"))
return self.message_types[0]
