class TestTextEditProtocolView(unittest.TestCase):
def test_create_context_menu(self):
logger.debug("Init form")
self.form = MainController()
tests.utils_testing.short_wait()
logger.debug("Intialized form")
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
logger.debug("added signalfile")
app.processEvents()
self.form.signal_tab_controller.signal_frames[
0].ui.cbProtoView.setCurrentIndex(2)
app.processEvents()
logger.debug("Get text edit")
text_edit = self.form.signal_tab_controller.signal_frames[
0].ui.txtEdProto
menu = text_edit.create_context_menu()
app.processEvents()
line_wrap_action = next(action for action in menu.actions()
if action.text().startswith("Linewrap"))
checked = line_wrap_action.isChecked()
line_wrap_action.trigger()
menu = text_edit.create_context_menu()
app.processEvents()
line_wrap_action = next(action for action in menu.actions()
if action.text().startswith("Linewrap"))
self.assertNotEqual(checked, line_wrap_action.isChecked())
class QtTestCase(unittest.TestCase):
CLOSE_TIMEOUT = 10
WAIT_TIMEOUT_BEFORE_NEW = 10
SHOW = os.path.exists(os.path.join(os.path.dirname(os.path.realpath(__file__)), "show_gui"))
@classmethod
def setUpClass(cls):
write_settings()
cls.app = QApplication(sys.argv)
@classmethod
def tearDownClass(cls):
cls.app.quit()
sip.delete(cls.app)
cls.app = None
def setUp(self):
self.form = MainController()
if self.SHOW:
self.form.show()
def add_signal_to_form(self, filename: str):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
self.form.add_signalfile(get_path_for_data_file(filename))
def tearDown(self):
if hasattr(self, "dialog"):
self.dialog.close()
if hasattr(self, "form"):
self.form.close_all()
if self.SHOW:
self.form.close()
QApplication.instance().processEvents()
QTest.qWait(self.CLOSE_TIMEOUT)
class TestMaincontrollerGUI(unittest.TestCase):
def setUp(self):
self.form = MainController()
def test_open_recent(self):
self.form.add_signalfile(
tests.utils_testing.get_path_for_data_file("esaver.complex"))
app.processEvents()
self.assertEqual(len(self.form.signal_tab_controller.signal_frames), 1)
self.form.close_all()
app.processEvents()
QTest.qWait(10)
self.assertEqual(len(self.form.signal_tab_controller.signal_frames), 0)
self.form.recentFileActionList[0].trigger()
self.assertEqual(len(self.form.signal_tab_controller.signal_frames), 1)
def test_update_decodings(self):
self.form.update_decodings()
self.assertTrue(True)
def test_options_changed(self):
self.form.add_signalfile(
tests.utils_testing.get_path_for_data_file("esaver.complex"))
self.form.on_options_changed({
"rel_symbol_length": 0,
"show_pause_as_time": True,
"default_view": 0
})
self.assertEqual(
self.form.signal_tab_controller.signal_frames[0].ui.cbProtoView.
currentIndex(), 0)
class QtTestCase(unittest.TestCase):
CLOSE_TIMEOUT = 10
WAIT_TIMEOUT_BEFORE_NEW = 10
SHOW = os.path.exists(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "show_gui"))
@classmethod
def setUpClass(cls):
write_settings()
cls.app = QApplication(sys.argv)
@classmethod
def tearDownClass(cls):
cls.app.quit()
sip.delete(cls.app)
cls.app = None
def setUp(self):
self.form = MainController()
if self.SHOW:
self.form.show()
def wait_before_new_file(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
def add_signal_to_form(self, filename: str):
self.wait_before_new_file()
self.form.add_signalfile(get_path_for_data_file(filename))
def get_path_for_filename(self, filename) -> str:
return get_path_for_data_file(filename)
def add_signal_to_generator(self, signal_index: int):
gframe = self.form.generator_tab_controller
item = gframe.tree_model.rootItem.children[0].children[signal_index]
index = gframe.tree_model.createIndex(signal_index, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(
gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1,
gframe.table_model.createIndex(0, 0))
def tearDown(self):
if hasattr(self, "dialog"):
self.dialog.close()
if hasattr(self, "form"):
self.form.close_all()
if self.SHOW:
self.form.close()
QApplication.instance().processEvents()
QTest.qWait(self.CLOSE_TIMEOUT)
class TestDecodingGUI(unittest.TestCase):
def setUp(self):
short_wait()
self.form = MainController()
short_wait()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.dialog = DecoderWidgetController(decodings=self.form.compare_frame_controller.decodings,
signals=[self.signal], parent=self.form,
project_manager=self.form.project_manager)
def tearDown(self):
self.dialog.close()
self.dialog.setParent(None)
short_wait()
self.form.close()
short_wait(interval=10)
def test_edit_decoding(self):
self.dialog.ui.combobox_decodings.setCurrentIndex(1) # NRZI
self.assertEqual(self.dialog.ui.decoderchain.count(), 1) # One Invert
self.dialog.save_to_file()
def test_build_decoding(self):
self.dialog.ui.combobox_decodings.setCurrentIndex(4)
chain = [constants.DECODING_INVERT, constants.DECODING_ENOCEAN, constants.DECODING_DIFFERENTIAL,
constants.DECODING_REDUNDANCY,
constants.DECODING_CARRIER, constants.DECODING_BITORDER, constants.DECODING_EDGE,
constants.DECODING_DATAWHITENING,
constants.DECODING_SUBSTITUTION, constants.DECODING_EXTERNAL, constants.DECODING_CUT]
decoding = Encoder(chain=chain)
self.dialog.decodings[4] = decoding
self.dialog.set_e()
self.assertEqual(len(chain), self.dialog.ui.decoderchain.count())
for i in range(0, self.dialog.ui.decoderchain.count()):
self.dialog.ui.decoderchain.setCurrentRow(i)
self.dialog.set_information(2)
self.assertIn(chain[i], self.dialog.ui.info.text())
def test_set_signal(self):
self.dialog.ui.combobox_signals.currentIndexChanged.emit(0)
self.assertEqual(self.dialog.ui.inpt.text(), "10010110")
def test_select_items(self):
for i in range(0, self.dialog.ui.basefunctions.count()):
self.dialog.ui.basefunctions.setCurrentRow(i)
self.assertIn(self.dialog.ui.basefunctions.currentItem().text(), self.dialog.ui.info.text())
for i in range(0, self.dialog.ui.additionalfunctions.count()):
self.dialog.ui.additionalfunctions.setCurrentRow(i)
self.assertIn(self.dialog.ui.additionalfunctions.currentItem().text(), self.dialog.ui.info.text())
class TestProjectManager(unittest.TestCase):
def setUp(self):
self.form = MainController()
self.form.project_manager.set_project_folder("./data")
QTest.qWait(100)
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
def test_save_modulations(self):
self.gframe.modulators[0].name = "Test"
amplitude = random.random()
self.gframe.modulators[0].carrier_amplitude = amplitude
self.gframe.modulators[0].carrier_freq_hz = 1337
self.gframe.modulators[0].carrier_phase_deg = 42
self.gframe.modulators[0].modulation_type = 1
self.gframe.modulators[0].sample_rate = 10**3
self.gframe.modulators.append(Modulator("test 2"))
self.gframe.modulators = self.gframe.modulators[:
2] # Take only the first two
self.form.project_manager.saveProject()
loaded_mods = self.form.project_manager.read_modulators_from_project_file(
)
self.assertEqual(len(loaded_mods), 2)
self.assertEqual(loaded_mods[0].name, "Test")
self.assertEqual(loaded_mods[1].name, "test 2")
self.assertEqual(loaded_mods[0].carrier_freq_hz, 1337)
self.assertEqual(loaded_mods[0].carrier_phase_deg, 42)
self.assertEqual(loaded_mods[0].modulation_type, 1)
self.assertEqual(loaded_mods[0].sample_rate, 10**3)
self.gframe.modulators.clear()
self.assertEqual(len(self.gframe.modulators), 0)
self.form.project_manager.set_project_folder(
self.form.project_manager.project_path)
self.assertEqual(len(self.gframe.modulators), 2)
def test_close_all(self):
self.form.close_all()
QTest.qWait(10)
self.form.add_signalfile("./data/ask.complex")
self.form.add_signalfile("./data/fsk.complex")
QTest.qWait(10)
self.assertEqual(self.form.signal_tab_controller.num_signals, 2)
self.form.close_all()
QTest.qWait(10)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
self.assertIsNone(self.form.project_manager.project_file)
class QtTestCase(unittest.TestCase):
CLOSE_TIMEOUT = 10
WAIT_TIMEOUT_BEFORE_NEW = 10
SHOW = os.path.exists(os.path.join(os.path.dirname(os.path.realpath(__file__)), "show_gui"))
@classmethod
def setUpClass(cls):
write_settings()
cls.app = QApplication(sys.argv)
@classmethod
def tearDownClass(cls):
cls.app.quit()
sip.delete(cls.app)
cls.app = None
def setUp(self):
self.form = MainController()
if self.SHOW:
self.form.show()
def wait_before_new_file(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
def add_signal_to_form(self, filename: str):
self.wait_before_new_file()
self.form.add_signalfile(get_path_for_data_file(filename))
def add_signal_to_generator(self, signal_index: int):
gframe = self.form.generator_tab_controller
item = gframe.tree_model.rootItem.children[0].children[signal_index]
index = gframe.tree_model.createIndex(signal_index, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(), Qt.LeftButton, pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1, gframe.table_model.createIndex(0, 0))
def tearDown(self):
if hasattr(self, "dialog"):
self.dialog.close()
if hasattr(self, "form"):
self.form.close_all()
if self.SHOW:
self.form.close()
QApplication.instance().processEvents()
QTest.qWait(self.CLOSE_TIMEOUT)
class TestProtocolDecoding(unittest.TestCase):
def setUp(self):
self.form = MainController()
self.cframe = self.form.compare_frame_controller
self.form.ui.tabWidget.setCurrentIndex(1)
def test_set_decoding(self):
"""
Check if decoding is applied for newly added protocol
:return:
"""
self.form.add_signalfile("./data/esaver.complex")
QTest.qWait(100)
self.assertEqual(self.cframe.protocol_model.row_count, 3)
display_bits = copy.deepcopy(self.cframe.protocol_model.display_data)
self.cframe.ui.cbDecoding.setCurrentIndex(1) # NRZ-I
QTest.qWait(100)
for i, line in enumerate(self.cframe.protocol_model.display_data):
for j, bit in enumerate(line):
self.assertTrue(self.__is_inv(display_bits[i][j], bit),
msg="Pos: {0}/{1} Bit1: {2} Bit2: {3}".format(
i, j, display_bits[i][j], bit))
self.form.add_signalfile("./data/esaver.complex")
QTest.qWait(100)
self.assertEqual(self.cframe.protocol_model.row_count, 6)
cfc_bits = self.cframe.protocol_model.display_data
for i, line in enumerate(display_bits):
for j, bit in enumerate(line):
self.assertTrue(self.__is_inv(cfc_bits[i + 3][j], bit),
msg="Pos: {0}/{1} Bit1: {2} Bit2: {3}".format(
i, j, cfc_bits[i + 3][j], bit))
def __is_inv(self, a: str, b: str):
# We only check bits here
if a not in ("0", "1") or b not in ("0", "1"):
return True
if a == "0" and b == "1":
return True
if a == "1" and b == "0":
return True
return False
class TestSignalTabGUI(unittest.TestCase):
def setUp(self):
self.form = MainController()
def test_close_all(self):
# Add a bunch of signals
NUM_SIGNALS = 10
for _ in range(NUM_SIGNALS):
self.form.add_signalfile("./data/esaver.complex")
QTest.qWait(10)
self.assertEqual(self.form.signal_tab_controller.num_signals, NUM_SIGNALS)
self.form.close_all()
QTest.qWait(10)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
self.form.add_signalfile("./data/ask.complex")
QTest.qWait(10)
self.assertEqual(self.form.signal_tab_controller.num_signals, 1)
class TestTextEditProtocolView(unittest.TestCase):
def setUp(self):
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.form.signal_tab_controller.signal_frames[
0].ui.cbProtoView.setCurrentIndex(2)
self.text_edit = self.form.signal_tab_controller.signal_frames[
0].ui.txtEdProto
def test_create_context_menu(self):
menu = self.text_edit.create_context_menu()
line_wrap_action = next(action for action in menu.actions()
if action.text().startswith("Linewrap"))
checked = line_wrap_action.isChecked()
line_wrap_action.trigger()
menu = self.text_edit.create_context_menu()
line_wrap_action = next(action for action in menu.actions()
if action.text().startswith("Linewrap"))
self.assertNotEqual(checked, line_wrap_action.isChecked())
class TestDecodingGUI(unittest.TestCase):
def setUp(self):
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.dialog = DecoderWidgetController(decodings=self.form.compare_frame_controller.decodings,
signals=[self.signal],
project_manager=self.form.project_manager)
def test_edit_decoding(self):
self.dialog.ui.combobox_decodings.setCurrentIndex(1) # NRZI
self.assertEqual(self.dialog.ui.decoderchain.count(), 1) # One Invert
def test_select_items(self):
for i in range(0, self.dialog.ui.basefunctions.count()):
self.dialog.ui.basefunctions.setCurrentRow(i)
self.assertIn(self.dialog.ui.basefunctions.currentItem().text(), self.dialog.ui.info.text())
for i in range(0, self.dialog.ui.additionalfunctions.count()):
self.dialog.ui.additionalfunctions.setCurrentRow(i)
self.assertIn(self.dialog.ui.additionalfunctions.currentItem().text(), self.dialog.ui.info.text())
class TestSignalTabGUI(unittest.TestCase):
def setUp(self):
self.form = MainController()
def test_close_all(self):
# Add a bunch of signals
NUM_SIGNALS = 10
for _ in range(NUM_SIGNALS):
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, NUM_SIGNALS)
self.form.close_all()
QTest.qWait(1)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, 1)
def test_zoom(self):
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
frame = self.form.signal_tab_controller.signal_frames[0]
x_zoom = frame.ui.spinBoxXZoom.value()
self.assertEqual(x_zoom, 100)
for _ in range(10):
frame.ui.gvSignal.zoom(1.01)
self.assertGreater(frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = frame.ui.spinBoxXZoom.value()
for _ in range(10):
frame.ui.gvSignal.zoom(0.99)
self.assertLess(frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = frame.ui.spinBoxXZoom.value()
class TestSignalTabGUI(unittest.TestCase):
def setUp(self):
constants.SETTINGS.setValue("not_show_save_dialog", True)
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.frame = self.form.signal_tab_controller.signal_frames[0]
def test_close_all(self):
self.form.close_all()
QTest.qWait(250)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
# Add a bunch of signals
num_signals = 10
for _ in range(num_signals):
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, num_signals)
self.form.close_all()
QTest.qWait(250)
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, 1)
def test_zoom(self):
x_zoom = self.frame.ui.spinBoxXZoom.value()
self.assertEqual(x_zoom, 100)
for _ in range(10):
self.frame.ui.gvSignal.zoom(1.01)
self.assertGreater(self.frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = self.frame.ui.spinBoxXZoom.value()
for _ in range(10):
self.frame.ui.gvSignal.zoom(0.99)
self.assertLess(self.frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = self.frame.ui.spinBoxXZoom.value()
samples_in_view = self.frame.ui.lSamplesInView.text()
self.frame.ui.spinBoxXZoom.setValue(self.frame.ui.spinBoxXZoom.value() + 400)
self.assertNotEqual(samples_in_view, self.frame.ui.lSamplesInView.text())
def test_load_proto(self):
self.form.add_files([get_path_for_data_file("protocol.proto")])
self.assertEqual(self.form.signal_tab_controller.signal_frames[1].ui.lSignalTyp.text(), "Protocol (*.proto)")
def test_graphic_view_selection(self):
self.frame.ui.gvSignal.selection_area.start = 0
self.frame.ui.gvSignal.selection_area.end = 4000
self.frame.ui.gvSignal.sel_area_start_end_changed.emit(0, 4000)
self.assertEqual(self.frame.ui.lNumSelectedSamples.text(), "4000")
noise_val = self.frame.ui.spinBoxNoiseTreshold.value()
self.frame.ui.gvSignal.set_noise_clicked.emit()
self.assertNotEqual(noise_val, self.frame.ui.spinBoxNoiseTreshold.value())
self.frame.ui.spinBoxSelectionStart.setValue(300)
self.assertEqual(self.frame.ui.gvSignal.selection_area.start, 300)
self.frame.ui.spinBoxSelectionEnd.setValue(6000)
self.assertEqual(self.frame.ui.gvSignal.selection_area.end, 6000)
def test_graphic_view_zoom_to_selection(self):
self.frame.ui.gvSignal.context_menu_position = QPoint(0, 0)
menu = self.frame.ui.gvSignal.create_context_menu()
self.assertTrue(self.frame.ui.gvSignal.selection_area.is_empty)
self.assertIsNone(next((action for action in menu.actions() if action.text() == "Zoom selection"), None))
self.frame.ui.gvSignal.selection_area.start = 1337
self.frame.ui.gvSignal.selection_area.end = 4711
self.frame.ui.gvSignal.sel_area_start_end_changed.emit(1337, 4711)
menu = self.frame.ui.gvSignal.create_context_menu()
self.assertFalse(self.frame.ui.gvSignal.selection_area.is_empty)
zoom_action = next(action for action in menu.actions() if action.text() == "Zoom selection")
zoom_action.trigger()
self.assertEqual(self.frame.ui.spinBoxSelectionStart.value(), 1337)
self.assertEqual(self.frame.ui.spinBoxSelectionEnd.value(), 4711)
def test_show_hide_start_end(self):
self.assertEqual(self.frame.ui.btnShowHideStartEnd.text(), "+")
self.frame.ui.btnShowHideStartEnd.click()
self.assertEqual(self.frame.ui.btnShowHideStartEnd.text(), "-")
def test_apply_to_all(self):
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
frame2 = self.form.signal_tab_controller.signal_frames[1]
self.frame.ui.spinBoxInfoLen.setValue(42)
self.frame.ui.spinBoxInfoLen.editingFinished.emit()
self.frame.ui.spinBoxCenterOffset.setValue(0.1)
self.frame.ui.spinBoxCenterOffset.editingFinished.emit()
self.frame.ui.spinBoxNoiseTreshold.setValue(0.5)
self.frame.ui.spinBoxNoiseTreshold.editingFinished.emit()
self.frame.ui.spinBoxTolerance.setValue(10)
self.frame.ui.spinBoxTolerance.editingFinished.emit()
self.frame.apply_to_all_clicked.emit(self.frame.signal)
self.assertEqual(42, frame2.ui.spinBoxInfoLen.value())
self.assertEqual(0.1, frame2.ui.spinBoxCenterOffset.value())
self.assertEqual(0.5, frame2.ui.spinBoxNoiseTreshold.value())
self.assertEqual(10, frame2.ui.spinBoxTolerance.value())
def test_save_all(self):
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
frame2 = self.form.signal_tab_controller.signal_frames[1]
self.frame.signal.changed = True
self.frame.signal.filename = os.path.join(QDir.tempPath(), "sig1.complex")
frame2.signal.changed = True
frame2.signal.filename = os.path.join(QDir.tempPath(), "sig2.complex")
self.assertFalse(os.path.isfile(self.frame.signal.filename))
self.assertFalse(os.path.isfile(frame2.signal.filename))
self.form.signal_tab_controller.save_all()
self.assertTrue(os.path.isfile(self.frame.signal.filename))
self.assertTrue(os.path.isfile(frame2.signal.filename))
os.remove(self.frame.signal.filename)
os.remove(frame2.signal.filename)
def test_crop_and_save_signal(self):
self.frame.ui.gvSignal.selection_area.end = 4000
self.frame.ui.gvSignal.selection_area.start = 1000
self.assertEqual(self.frame.ui.gvSignal.selection_area.end, 4000)
self.assertEqual(self.frame.ui.gvSignal.selection_area.width, 3000)
self.frame.ui.gvSignal.sel_area_start_end_changed.emit(1000, 4000)
self.frame.ui.gvSignal.on_crop_action_triggered()
self.assertEqual(self.frame.signal.num_samples, 3000)
self.assertTrue(self.frame.signal.changed)
self.frame.signal.filename = os.path.join(QDir.tempPath(), "sig.complex")
self.assertFalse(os.path.isfile(self.frame.signal.filename))
self.frame.ui.btnSaveSignal.click()
self.form.close_signal_frame(self.frame)
QTest.qWait(50)
self.form.add_signalfile(os.path.join(QDir.tempPath(), "sig.complex"))
self.assertEqual(self.form.signal_tab_controller.signal_frames[0].signal.num_samples, 3000)
os.remove(os.path.join(QDir.tempPath(), "sig.complex"))
class TestSignalTabGUI(unittest.TestCase):
def setUp(self):
constants.SETTINGS.setValue("not_show_save_dialog", True)
logger.debug("Init Form")
tests.utils_testing.short_wait()
self.form = MainController()
tests.utils_testing.short_wait()
logger.debug("Add Signal")
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
logger.debug("Added Signal")
app.processEvents()
self.frame = self.form.signal_tab_controller.signal_frames[0]
self.frame.signal.noise_threshold = 0.0023
self.frame.signal.qad_center = 0.3817
self.frame.signal.bit_len = 84
def tearDown(self):
self.form.close_all()
tests.utils_testing.short_wait()
self.form.close()
self.form.setParent(None)
self.form.deleteLater()
tests.utils_testing.short_wait()
def test_close_all(self):
logger.debug("Close all")
self.form.close_all()
tests.utils_testing.short_wait()
logger.debug("Called close all")
app.processEvents()
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
# Add a bunch of signals
num_signals = 5
for _ in range(num_signals):
tests.utils_testing.short_wait()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals,
num_signals)
self.form.close_all()
tests.utils_testing.short_wait()
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, 1)
def test_zoom(self):
tests.utils_testing.short_wait()
x_zoom = self.frame.ui.spinBoxXZoom.value()
self.assertEqual(x_zoom, 100)
for _ in range(10):
self.frame.ui.gvSignal.zoom(1.01)
self.assertGreater(self.frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = self.frame.ui.spinBoxXZoom.value()
for _ in range(10):
self.frame.ui.gvSignal.zoom(0.99)
self.assertLess(self.frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = self.frame.ui.spinBoxXZoom.value()
samples_in_view = self.frame.ui.lSamplesInView.text()
self.frame.ui.spinBoxXZoom.setValue(
self.frame.ui.spinBoxXZoom.value() + 400)
self.assertNotEqual(samples_in_view,
self.frame.ui.lSamplesInView.text())
def test_load_proto(self):
self.form.add_files([get_path_for_data_file("protocol.proto")])
self.assertEqual(
self.form.signal_tab_controller.signal_frames[1].ui.lSignalTyp.
text(), "Protocol (*.proto)")
def test_graphic_view_selection(self):
self.frame.ui.gvSignal.selection_area.start = 0
self.frame.ui.gvSignal.selection_area.end = 4000
self.frame.ui.gvSignal.sel_area_start_end_changed.emit(0, 4000)
self.assertEqual(self.frame.ui.lNumSelectedSamples.text(), "4000")
noise_val = self.frame.ui.spinBoxNoiseTreshold.value()
self.frame.ui.gvSignal.set_noise_clicked.emit()
self.assertNotEqual(noise_val,
self.frame.ui.spinBoxNoiseTreshold.value())
self.frame.ui.spinBoxSelectionStart.setValue(300)
self.assertEqual(self.frame.ui.gvSignal.selection_area.start, 300)
self.frame.ui.spinBoxSelectionEnd.setValue(6000)
self.assertEqual(self.frame.ui.gvSignal.selection_area.end, 6000)
def test_graphic_view_zoom_to_selection(self):
self.frame.ui.gvSignal.context_menu_position = QPoint(0, 0)
menu = self.frame.ui.gvSignal.create_context_menu()
self.assertTrue(self.frame.ui.gvSignal.selection_area.is_empty)
self.assertIsNone(
next((action for action in menu.actions()
if action.text() == "Zoom selection"), None))
self.frame.ui.gvSignal.selection_area.start = 1337
self.frame.ui.gvSignal.selection_area.end = 4711
self.frame.ui.gvSignal.sel_area_start_end_changed.emit(1337, 4711)
menu = self.frame.ui.gvSignal.create_context_menu()
self.assertFalse(self.frame.ui.gvSignal.selection_area.is_empty)
zoom_action = next(action for action in menu.actions()
if action.text() == "Zoom selection")
zoom_action.trigger()
self.assertEqual(self.frame.ui.spinBoxSelectionStart.value(), 1337)
self.assertEqual(self.frame.ui.spinBoxSelectionEnd.value(), 4711)
def test_show_hide_start_end(self):
self.assertEqual(self.frame.ui.btnShowHideStartEnd.text(), "+")
self.frame.ui.btnShowHideStartEnd.click()
self.assertEqual(self.frame.ui.btnShowHideStartEnd.text(), "-")
def test_apply_to_all(self):
logger.debug("Test apply to all")
tests.utils_testing.short_wait()
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
logger.debug("added new signal")
frame2 = self.form.signal_tab_controller.signal_frames[1]
self.frame.ui.spinBoxInfoLen.setValue(42)
self.frame.ui.spinBoxInfoLen.editingFinished.emit()
self.frame.ui.spinBoxCenterOffset.setValue(0.1)
self.frame.ui.spinBoxCenterOffset.editingFinished.emit()
self.frame.ui.spinBoxNoiseTreshold.setValue(0.5)
self.frame.ui.spinBoxNoiseTreshold.editingFinished.emit()
self.frame.ui.spinBoxTolerance.setValue(10)
self.frame.ui.spinBoxTolerance.editingFinished.emit()
self.frame.apply_to_all_clicked.emit(self.frame.signal)
self.assertEqual(42, frame2.ui.spinBoxInfoLen.value())
self.assertEqual(0.1, frame2.ui.spinBoxCenterOffset.value())
self.assertEqual(0.5, frame2.ui.spinBoxNoiseTreshold.value())
self.assertEqual(10, frame2.ui.spinBoxTolerance.value())
def test_save_all(self):
logger.debug("Test save all")
tests.utils_testing.short_wait()
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
frame2 = self.form.signal_tab_controller.signal_frames[1]
self.frame.signal.changed = True
self.frame.signal.filename = os.path.join(QDir.tempPath(),
"sig1.complex")
frame2.signal.changed = True
frame2.signal.filename = os.path.join(QDir.tempPath(), "sig2.complex")
self.assertFalse(os.path.isfile(self.frame.signal.filename))
self.assertFalse(os.path.isfile(frame2.signal.filename))
self.form.signal_tab_controller.save_all()
self.assertTrue(os.path.isfile(self.frame.signal.filename))
self.assertTrue(os.path.isfile(frame2.signal.filename))
os.remove(self.frame.signal.filename)
os.remove(frame2.signal.filename)
def test_crop_and_save_signal(self):
self.frame.ui.gvSignal.selection_area.end = 4000
self.frame.ui.gvSignal.selection_area.start = 1000
self.assertEqual(self.frame.ui.gvSignal.selection_area.end, 4000)
self.assertEqual(self.frame.ui.gvSignal.selection_area.width, 3000)
self.frame.ui.gvSignal.sel_area_start_end_changed.emit(1000, 4000)
self.frame.ui.gvSignal.on_crop_action_triggered()
self.assertEqual(self.frame.signal.num_samples, 3000)
self.assertTrue(self.frame.signal.changed)
self.frame.signal.filename = os.path.join(QDir.tempPath(),
"sig.complex")
if os.path.isfile(self.frame.signal.filename):
os.remove(self.frame.signal.filename)
self.assertFalse(os.path.isfile(self.frame.signal.filename))
self.frame.ui.btnSaveSignal.click()
self.form.close_signal_frame(self.frame)
tests.utils_testing.short_wait()
self.form.add_signalfile(os.path.join(QDir.tempPath(), "sig.complex"))
self.assertEqual(
self.form.signal_tab_controller.signal_frames[0].signal.
num_samples, 3000)
os.remove(os.path.join(QDir.tempPath(), "sig.complex"))
def test_selection_sync(self):
self.frame.ui.gvSignal.selection_area.end = 128440
self.frame.ui.gvSignal.selection_area.start = 89383
self.frame.ui.gvSignal.sel_area_start_end_changed.emit(89383, 128440)
tests.utils_testing.short_wait()
self.assertEqual(self.frame.proto_analyzer.messages[0].plain_bits_str,
self.frame.ui.txtEdProto.selected_text)
self.frame.ui.txtEdProto.show_proto_clicked.emit()
tests.utils_testing.short_wait()
self.assertAlmostEqual(
(128440 - 89383) / 1000000,
(self.frame.ui.gvSignal.view_rect().width()) / 1000000,
places=1)
def test_show_demod_view(self):
self.assertTrue(self.frame.ui.gvLegend.isHidden())
self.frame.ui.cbSignalView.setCurrentIndex(1)
self.assertFalse(self.frame.ui.gvLegend.isHidden())
def test_auto_detect_button(self):
self.assertTrue(self.frame.ui.btnAutoDetect.isChecked())
self.frame.ui.btnAutoDetect.click()
self.assertFalse(self.frame.ui.btnAutoDetect.isChecked())
class TestSignalTabGUI(unittest.TestCase):
def setUp(self):
self.form = MainController()
def test_close_all(self):
# Add a bunch of signals
NUM_SIGNALS = 10
for _ in range(NUM_SIGNALS):
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals,
NUM_SIGNALS)
self.form.close_all()
QTest.qWait(100)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, 1)
def test_zoom(self):
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
frame = self.form.signal_tab_controller.signal_frames[0]
x_zoom = frame.ui.spinBoxXZoom.value()
self.assertEqual(x_zoom, 100)
for _ in range(10):
frame.ui.gvSignal.zoom(1.01)
self.assertGreater(frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = frame.ui.spinBoxXZoom.value()
for _ in range(10):
frame.ui.gvSignal.zoom(0.99)
self.assertLess(frame.ui.spinBoxXZoom.value(), x_zoom)
x_zoom = frame.ui.spinBoxXZoom.value()
samples_in_view = frame.ui.lSamplesInView.text()
frame.ui.spinBoxXZoom.setValue(frame.ui.spinBoxXZoom.value() + 400)
self.assertNotEqual(samples_in_view, frame.ui.lSamplesInView.text())
def test_load_proto(self):
self.form.add_files([get_path_for_data_file("protocol.proto")])
self.assertEqual(
self.form.signal_tab_controller.signal_frames[0].ui.lSignalTyp.
text(), "Protocol (*.proto)")
def test_graphic_view_selection(self):
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
frame = self.form.signal_tab_controller.signal_frames[0]
frame.ui.gvSignal.selection_area.start = 0
frame.ui.gvSignal.selection_area.end = 4000
frame.ui.gvSignal.sel_area_start_end_changed.emit(0, 4000)
self.assertEqual(frame.ui.lNumSelectedSamples.text(), "4000")
noise_val = frame.ui.spinBoxNoiseTreshold.value()
frame.ui.gvSignal.set_noise_clicked.emit()
self.assertNotEqual(noise_val, frame.ui.spinBoxNoiseTreshold.value())
frame.ui.spinBoxSelectionStart.setValue(300)
self.assertEqual(frame.ui.gvSignal.selection_area.start, 300)
frame.ui.spinBoxSelectionEnd.setValue(6000)
self.assertEqual(frame.ui.gvSignal.selection_area.end, 6000)
def test_show_hide_start_end(self):
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
frame = self.form.signal_tab_controller.signal_frames[0]
self.assertEqual(frame.ui.btnShowHideStartEnd.text(), "+")
frame.ui.btnShowHideStartEnd.click()
self.assertEqual(frame.ui.btnShowHideStartEnd.text(), "-")
class TestSimulator(QtTestCase):
def setUp(self):
super().setUp()
SettingsProxy.OVERWRITE_RECEIVE_BUFFER_SIZE = 10 * 10**6
self.num_zeros_for_pause = 1000
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.complex"))
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.1,
5,
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 = 100000
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 = 113600 - 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_bit = 100
modulator.carrier_freq_hz = 55e3
# yappi.start()
self.network_sdr_plugin_sender.send_raw_data(
modulator.modulate(msg_a.encoded_bits), 1)
QTest.qWait(10)
# 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)
QTest.qWait(100)
receive_process.join(10)
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 test_simulation_flow(self):
"""
test a simulation flow with an increasing sequence number
:return:
"""
profile = self.get_path_for_filename("testprofile.sim.xml")
self.form.add_files([profile])
self.assertEqual(
len(self.form.simulator_tab_controller.simulator_scene.
get_all_message_items()), 6)
port = self.get_free_port()
self.alice = NetworkSDRInterfacePlugin(raw_mode=True)
self.alice.client_port = port
dialog = self.form.simulator_tab_controller.get_simulator_dialog()
name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
dialog.device_settings_rx_widget.ui.cbDevice.setCurrentText(name)
dialog.device_settings_tx_widget.ui.cbDevice.setCurrentText(name)
QTest.qWait(10)
simulator = dialog.simulator
simulator.sniffer.rcv_device.set_server_port(port)
port = self.get_free_port()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
s.bind(("", port))
s.listen(1)
QTest.qWait(10)
simulator.sender.device.set_client_port(port)
dialog.ui.btnStartStop.click()
QTest.qWait(1500)
conn, addr = s.accept()
msg = next(msg for msg in dialog.simulator_config.get_all_messages()
if msg.source.name == "Alice")
checksum_label = next(
lbl for lbl in msg.message_type
if lbl.is_checksum_label).label # type: ChecksumLabel
modulator = dialog.project_manager.modulators[0] # type: Modulator
preamble_str = "10101010"
sync_str = "1001"
preamble = list(map(int, preamble_str))
sync = list(map(int, sync_str))
seq = list(map(int, "00000010"))
data = list(map(int, "11001101"))
seq_num = int("".join(map(str, seq)), 2)
checksum = list(checksum_label.calculate_checksum(seq + data))
msg1 = preamble + sync + seq + data + checksum
self.alice.send_raw_data(modulator.modulate(msg1), 1)
self.alice.send_raw_data(
np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1)
bits = self.__demodulate(conn)
self.assertEqual(len(bits), 1)
bits = bits[0]
self.assertTrue(bits.startswith(preamble_str + sync_str))
bits = bits.replace(preamble_str + sync_str, "")
self.assertEqual(int(bits, 2), seq_num + 1)
seq = list(map(int, "{0:08b}".format(seq_num + 2)))
checksum = list(checksum_label.calculate_checksum(seq + data))
msg2 = preamble + sync + seq + data + checksum
self.alice.send_raw_data(modulator.modulate(msg2), 1)
self.alice.send_raw_data(
np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1)
bits = self.__demodulate(conn)
self.assertEqual(len(bits), 1)
bits = bits[0]
self.assertTrue(bits.startswith(preamble_str + sync_str))
bits = bits.replace(preamble_str + sync_str, "")
self.assertEqual(int(bits, 2), seq_num + 3)
seq = list(map(int, "{0:08b}".format(seq_num + 4)))
checksum = list(checksum_label.calculate_checksum(seq + data))
msg3 = preamble + sync + seq + data + checksum
self.alice.send_raw_data(modulator.modulate(msg3), 1)
self.alice.send_raw_data(
np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1)
bits = self.__demodulate(conn)
self.assertEqual(len(bits), 1)
bits = bits[0]
self.assertTrue(bits.startswith(preamble_str + sync_str))
bits = bits.replace(preamble_str + sync_str, "")
self.assertEqual(int(bits, 2), seq_num + 5)
QTest.qWait(50)
self.assertTrue(simulator.simulation_is_finished())
time.sleep(1)
conn.close()
s.close()
QTest.qWait(100)
def test_external_program_simulator(self):
stc = self.form.simulator_tab_controller
stc.ui.btnAddParticipant.click()
stc.ui.btnAddParticipant.click()
stc.simulator_scene.add_counter_action(None, 0)
action = next(item for item in stc.simulator_scene.items()
if isinstance(item, CounterActionItem))
action.model_item.start = 3
action.model_item.step = 2
counter_item_str = "item" + str(
action.model_item.index()) + ".counter_value"
stc.ui.gvSimulator.add_empty_message(42)
stc.ui.gvSimulator.add_empty_message(42)
stc.ui.cbViewType.setCurrentIndex(0)
stc.create_simulator_label(0, 10, 20)
stc.create_simulator_label(1, 10, 20)
messages = stc.simulator_config.get_all_messages()
messages[0].source = stc.project_manager.participants[0]
messages[0].destination = stc.project_manager.participants[1]
messages[0].destination.simulate = True
messages[1].source = stc.project_manager.participants[1]
messages[1].destination = stc.project_manager.participants[0]
stc.simulator_scene.add_trigger_command_action(None, 200)
stc.simulator_scene.add_sleep_action(None, 200)
lbl1 = messages[0].message_type[0] # type: SimulatorProtocolLabel
lbl2 = messages[1].message_type[0] # type: SimulatorProtocolLabel
lbl1.value_type_index = 3
lbl1.external_program = get_path_for_data_file(
"external_program_simulator.py") + " " + counter_item_str
lbl2.value_type_index = 3
lbl2.external_program = get_path_for_data_file(
"external_program_simulator.py") + " " + counter_item_str
action = next(item for item in stc.simulator_scene.items()
if isinstance(item, SleepActionItem))
action.model_item.sleep_time = 0.001
stc.simulator_scene.clearSelection()
action = next(item for item in stc.simulator_scene.items()
if isinstance(item, TriggerCommandActionItem))
action.setSelected(True)
self.assertEqual(stc.ui.detail_view_widget.currentIndex(), 4)
fname = tempfile.mktemp()
self.assertFalse(os.path.isfile(fname))
external_command = "cmd.exe /C copy NUL {}".format(
fname) if os.name == "nt" else "touch {}".format(fname)
stc.ui.lineEditTriggerCommand.setText(external_command)
self.assertEqual(action.model_item.command, external_command)
port = self.get_free_port()
self.alice = NetworkSDRInterfacePlugin(raw_mode=True)
self.alice.client_port = port
dialog = stc.get_simulator_dialog()
name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
dialog.device_settings_rx_widget.ui.cbDevice.setCurrentText(name)
dialog.device_settings_tx_widget.ui.cbDevice.setCurrentText(name)
QTest.qWait(10)
simulator = dialog.simulator
simulator.sniffer.rcv_device.set_server_port(port)
port = self.get_free_port()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
s.bind(("", port))
s.listen(1)
QTest.qWait(10)
simulator.sender.device.set_client_port(port)
dialog.ui.btnStartStop.click()
QTest.qWait(1500)
conn, addr = s.accept()
modulator = dialog.project_manager.modulators[0] # type: Modulator
self.alice.send_raw_data(modulator.modulate("100" + "10101010" * 42),
1)
self.alice.send_raw_data(
np.zeros(self.num_zeros_for_pause, dtype=np.complex64), 1)
bits = self.__demodulate(conn)
self.assertEqual(bits[0], "101010101")
QTest.qWait(500)
self.assertTrue(simulator.simulation_is_finished())
conn.close()
s.close()
QTest.qWait(100)
self.assertTrue(os.path.isfile(fname))
def __demodulate(self, connection):
QTest.qWait(100)
data = connection.recv(65536)
while len(data) % 8 != 0:
data += connection.recv(65536)
arr = np.array(np.frombuffer(data, dtype=np.complex64))
signal = Signal("", "")
signal._fulldata = arr
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
return pa.plain_bits_str
class TestLabels(unittest.TestCase):
def setUp(self):
self.old_sym_len = constants.SETTINGS.value('rel_symbol_length', type=int)
constants.SETTINGS.setValue('rel_symbol_length', 0) # Disable Symbols for this Test
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.sframe = self.form.signal_tab_controller.signal_frames[0]
self.cframe = self.form.compare_frame_controller
self.cframe.ui.cbProtoView.setCurrentIndex(0)
self.gframe = self.form.generator_tab_controller
self.gframe.ui.cbViewType.setCurrentIndex(0)
# Create two labels on Compare Frame
self.form.ui.tabWidget.setCurrentIndex(1)
self.cframe.add_protocol_label(start=0, end=40, messagenr=1, proto_view=0, edit_label_name = False) # Sync
self.cframe.add_protocol_label(start=43, end=43, messagenr=2, proto_view=0, edit_label_name = False) # FuzzBit
self.assertEqual(len(self.cframe.active_message_type), 2)
def tearDown(self):
constants.SETTINGS.setValue('rel_symbol_length', self.old_sym_len) # Restore Symbol Length
def test_show_labels_only(self):
self.cframe.ui.chkBoxOnlyShowLabelsInProtocol.setChecked(True)
for i in range(0, 40):
self.assertFalse(self.cframe.ui.tblViewProtocol.isColumnHidden(i), msg = "Bit " + str(i))
self.assertFalse(self.cframe.ui.tblViewProtocol.isColumnHidden(43), msg = "Bit 43")
for i in range(44, self.cframe.protocol_model.col_count):
self.assertTrue(self.cframe.ui.tblViewProtocol.isColumnHidden(i), msg = "Bit " + str(i))
self.cframe.ui.cbProtoView.setCurrentIndex(1) # Hex View
for i in range(0, 10):
self.assertFalse(self.cframe.ui.tblViewProtocol.isColumnHidden(i), msg = "Hex " + str(i))
for i in range(13, self.cframe.protocol_model.col_count):
self.assertTrue(self.cframe.ui.tblViewProtocol.isColumnHidden(i), msg = "Hex " + str(i))
def test_generator_label(self):
labels = self.cframe.proto_analyzer.protocol_labels
self.assertEqual(len(labels), 2)
# Open Protocol in Generator
self.form.ui.tabWidget.setCurrentIndex(2)
item = self.gframe.tree_model.rootItem.children[0].children[0]
index = self.gframe.tree_model.createIndex(0, 0, item)
rect = self.gframe.ui.treeProtocols.visualRect(index)
self.assertEqual(len(self.gframe.ui.treeProtocols.selectedIndexes()), 0)
QTest.mousePress(self.gframe.ui.treeProtocols.viewport(), Qt.LeftButton, pos=rect.center())
self.assertEqual(self.gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = self.gframe.tree_model.mimeData(self.gframe.ui.treeProtocols.selectedIndexes())
self.gframe.table_model.dropMimeData(mimedata, 1, -1, -1, self.gframe.table_model.createIndex(0, 0))
self.assertEqual(self.gframe.table_model.row_count, 3)
# Check Label in Generator
labels = self.gframe.table_model.protocol.protocol_labels
self.assertEqual(len(labels), 2)
# Fuzz Label
lbl = self.gframe.table_model.protocol.messages[0].message_type[1]
lbl.fuzz_values.append("1")
lbl.add_fuzz_value()
lbl.add_fuzz_value()
lbl.add_fuzz_value()
lbl.add_fuzz_value()
lbl.fuzz_me = Qt.Checked
self.assertEqual(len(lbl.fuzz_values), 5)
self.gframe.refresh_label_list()
self.gframe.refresh_table()
self.gframe.ui.btnFuzz.setEnabled(True)
self.gframe.ui.btnFuzz.click()
self.assertTrue(lbl.active_fuzzing)
self.assertIn(lbl, self.gframe.table_model.protocol.messages[0].message_type)
self.assertEqual(self.gframe.table_model.row_count, 4 + 3)
# Check if Background for fuzzed labels is drawn correctly
self.__check_background_is_drawn(lbl, 43, 43)
# Delete a line
old_row_count = self.gframe.table_model.row_count
self.gframe.ui.tableMessages.selectRow(2)
QTest.keyClick(self.gframe.ui.tableMessages, Qt.Key_Delete)
self.assertEqual(self.gframe.table_model.row_count, old_row_count - 1)
self.__check_background_is_drawn(lbl, 43, 43)
# Remove everything
for i in range(old_row_count):
self.gframe.ui.tableMessages.selectRow(0)
QTest.keyClick(self.gframe.ui.tableMessages, Qt.Key_Delete)
self.assertEqual(self.gframe.table_model.row_count, 0)
def __check_background_is_drawn(self, lbl, lbl_start, lbl_end):
pac = self.gframe.table_model.protocol
for i in range(self.gframe.table_model.row_count):
labels_for_message = pac.messages[i].message_type
self.assertIn(lbl, labels_for_message)
start, end = pac.messages[i].get_label_range(lbl, self.gframe.table_model.proto_view, False)
self.assertEqual(start, lbl_start)
self.assertEqual(end, lbl_end + 1)
class TestPlugins(unittest.TestCase):
def setUp(self):
self.old_sym_len = constants.SETTINGS.value('rel_symbol_length',
type=int)
constants.SETTINGS.setValue('rel_symbol_length',
0) # Disable Symbols for this Test
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.sframe = self.form.signal_tab_controller.signal_frames[0]
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(1)
self.assertEqual(self.cframe.protocol_model.row_count, 3)
self.signal = self.sframe.signal
def tearDown(self):
constants.SETTINGS.setValue('rel_symbol_length',
self.old_sym_len) # Restore Symbol Length
def test_message_break_plugin(self):
bp = MessageBreakPlugin()
action = bp.get_action(self.cframe.ui.tblViewProtocol,
self.cframe.protocol_undo_stack, (1, 1, 4, 4),
self.cframe.proto_analyzer, 0)
self.assertEqual(self.cframe.protocol_model.row_count, 3)
action.trigger()
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_zero_hide_plugin_gui(self):
self.assertEqual(
len(self.cframe.proto_analyzer.decoded_proto_bits_str[0]), 377)
zh = ZeroHidePlugin()
zh.following_zeros = 188
action = zh.get_action(self.cframe.ui.tblViewProtocol,
self.cframe.protocol_undo_stack, (),
self.cframe.proto_analyzer, 0)
action.trigger()
self.assertEqual(
len(self.cframe.proto_analyzer.decoded_proto_bits_str[0]),
377 - 188)
self.cframe.protocol_undo_stack.undo()
self.assertEqual(
len(self.cframe.proto_analyzer.decoded_proto_bits_str[0]), 377)
def test_zero_hide_plugin_function(self):
zh = ZeroHidePlugin()
zh.following_zeros = 3
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
self.form.ui.tabWidget.setCurrentIndex(1)
test_bits = "10110010010110110110110110110110110001000000"
self.assertEqual(self.cframe.proto_analyzer.decoded_proto_bits_str[3],
test_bits)
action = zh.get_action(self.cframe.ui.tblViewProtocol,
self.cframe.protocol_undo_stack, (),
self.cframe.proto_analyzer, 0)
action.trigger()
self.assertEqual(self.cframe.proto_analyzer.decoded_proto_bits_str[3],
"10110010010110110110110110110110111")
def test_sdr_interface_plugin(self):
si = NetworkSDRInterfacePlugin()
test_bits = [
"10101011111", "1010100011000111110001011001010101010101",
"1010100011000111110001011001010100100", "1101010101011000011",
"11010101010110000110", "11100010101001110000",
"111100000011011101010101010000101010101010100001010011010101010011"
]
for bits in test_bits:
byte_vals = si.bit_str_to_bytearray(bits)
self.assertEqual(len(byte_vals),
int(math.ceil(len(bits) / 8)),
msg=bits)
recalculated = si.bytearray_to_bit_str(byte_vals)
if len(bits) % 8 == 0:
self.assertEqual(bits, recalculated)
elif bits.endswith("1"):
self.assertEqual(bits, recalculated.rstrip("0"))
else:
self.assertTrue(recalculated.startswith(bits))
def test_insert_sine_plugin(self):
insert_sine_plugin = self.sframe.ui.gvSignal.insert_sine_plugin
num_samples = 10000
dialog = insert_sine_plugin.get_insert_sine_dialog(
original_data=self.signal.data,
position=2000,
sample_rate=self.signal.sample_rate,
num_samples=num_samples)
graphics_view = dialog.graphicsViewSineWave # type: ZoomableGraphicView
while not dialog.doubleSpinBoxAmplitude.isEnabled():
app.processEvents()
QTest.qWait(100)
self.assertEqual(int(graphics_view.sceneRect().width()),
self.signal.num_samples + num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().width(),
num_samples)
self.assertEqual(insert_sine_plugin.insert_indicator.rect().x(), 2000)
dialog.doubleSpinBoxAmplitude.setValue(0.1)
dialog.doubleSpinBoxAmplitude.editingFinished.emit()
self.assertEqual(insert_sine_plugin.amplitude, 0.1)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
app.processEvents()
QTest.qWait(100)
dialog.doubleSpinBoxFrequency.setValue(1e6)
dialog.doubleSpinBoxFrequency.editingFinished.emit()
self.assertEqual(insert_sine_plugin.frequency, 1e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
app.processEvents()
QTest.qWait(100)
dialog.doubleSpinBoxPhase.setValue(100)
dialog.doubleSpinBoxPhase.editingFinished.emit()
self.assertEqual(insert_sine_plugin.phase, 100)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
app.processEvents()
QTest.qWait(100)
dialog.doubleSpinBoxSampleRate.setValue(2e6)
dialog.doubleSpinBoxSampleRate.editingFinished.emit()
self.assertEqual(insert_sine_plugin.sample_rate, 2e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
app.processEvents()
QTest.qWait(100)
dialog.doubleSpinBoxNSamples.setValue(0.5e6)
dialog.doubleSpinBoxNSamples.editingFinished.emit()
self.assertEqual(insert_sine_plugin.num_samples, 0.5e6)
while not dialog.doubleSpinBoxAmplitude.isEnabled():
app.processEvents()
QTest.qWait(100)
sep = Formatter.local_decimal_seperator()
self.assertEqual(dialog.lineEditTime.text(), "250" + sep + "000m")
class TestProjectManager(unittest.TestCase):
def setUp(self):
self.form = MainController()
self.form.project_manager.set_project_folder(
get_path_for_data_file(""), ask_for_new_project=False)
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
self.dialog = ProjectDialogController(
project_manager=self.form.project_manager, parent=self.form)
def test_save_modulations(self):
self.gframe.modulators[0].name = "Test"
amplitude = random.random()
self.gframe.modulators[0].carrier_amplitude = amplitude
self.gframe.modulators[0].carrier_freq_hz = 1337
self.gframe.modulators[0].carrier_phase_deg = 42
self.gframe.modulators[0].modulation_type = 1
self.gframe.modulators[0].sample_rate = 10**3
self.gframe.modulators.append(Modulator("test 2"))
self.gframe.modulators = self.gframe.modulators[:
2] # Take only the first two
self.form.project_manager.saveProject()
loaded_mods = self.form.project_manager.read_modulators_from_project_file(
)
self.assertEqual(len(loaded_mods), 2)
self.assertEqual(loaded_mods[0].name, "Test")
self.assertEqual(loaded_mods[1].name, "test 2")
self.assertEqual(loaded_mods[0].carrier_freq_hz, 1337)
self.assertEqual(loaded_mods[0].carrier_phase_deg, 42)
self.assertEqual(loaded_mods[0].modulation_type, 1)
self.assertEqual(loaded_mods[0].sample_rate, 10**3)
self.gframe.modulators.clear()
self.assertEqual(len(self.gframe.modulators), 0)
self.form.project_manager.set_project_folder(
self.form.project_manager.project_path)
self.assertEqual(len(self.gframe.modulators), 2)
def test_close_all(self):
self.form.close_all()
QTest.qWait(1500)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
self.form.add_signalfile(get_path_for_data_file("fsk.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, 2)
self.form.close_all()
QTest.qWait(1500)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
self.assertEqual(self.form.project_manager.project_file, None)
def test_project_dialog(self):
frequency = 1e9
sample_rate = 10e9
bandwidth = 10
gain = 42
descr = "URH rockz."
self.dialog.ui.spinBoxFreq.setValue(frequency)
self.assertEqual(self.dialog.freq, frequency)
self.dialog.ui.spinBoxSampleRate.setValue(sample_rate)
self.assertEqual(self.dialog.sample_rate, sample_rate)
self.dialog.ui.spinBoxBandwidth.setValue(bandwidth)
self.assertEqual(self.dialog.bandwidth, bandwidth)
self.dialog.ui.spinBoxGain.setValue(gain)
self.assertEqual(self.dialog.gain, gain)
self.dialog.ui.txtEdDescription.setPlainText(descr)
self.assertEqual(self.dialog.description, descr)
self.dialog.ui.lineEditBroadcastAddress.setText("abcd")
self.dialog.ui.lineEditBroadcastAddress.textEdited.emit("abcd")
self.assertEqual(self.dialog.broadcast_address_hex, "abcd")
if len(self.dialog.participants) == 0:
self.dialog.ui.btnAddParticipant.click()
self.assertEqual(len(self.dialog.participants), 1)
model = self.dialog.participant_table_model
model.setData(model.index(0, 0), "Testing")
model.setData(model.index(0, 1), "T")
model.setData(model.index(0, 2), 5)
model.setData(model.index(0, 3), 0)
model.setData(model.index(0, 4), "aaaa")
participant = self.dialog.participants[0]
self.assertEqual(participant.name, "Testing")
self.assertEqual(participant.shortname, "T")
self.assertEqual(participant.color_index, 5)
self.assertEqual(participant.relative_rssi, 0)
self.assertEqual(participant.address_hex, "aaaa")
num_participants = len(self.dialog.participants)
self.dialog.ui.btnAddParticipant.click()
self.dialog.ui.btnAddParticipant.click()
self.dialog.ui.btnAddParticipant.click()
self.assertEqual(len(self.dialog.participants), num_participants + 3)
self.dialog.ui.btnRemoveParticipant.click()
self.dialog.ui.btnRemoveParticipant.click()
self.dialog.ui.btnRemoveParticipant.click()
self.assertEqual(len(self.dialog.participants), num_participants)
test_path = os.path.join(QDir.tempPath(), "urh_test")
self.dialog.ui.lineEdit_Path.setText(test_path)
self.dialog.ui.lineEdit_Path.textEdited.emit(test_path)
self.assertEqual(self.dialog.path, test_path)
self.dialog.ui.btnOK.click()
self.assertTrue(os.path.isdir(test_path))
self.form.project_manager.from_dialog(self.dialog)
self.dialog = ProjectDialogController(
project_manager=self.form.project_manager,
parent=self.form,
new_project=False)
self.assertEqual(self.dialog.ui.spinBoxFreq.value(), frequency)
self.assertEqual(self.dialog.ui.spinBoxSampleRate.value(), sample_rate)
self.assertEqual(self.dialog.ui.spinBoxBandwidth.value(), bandwidth)
self.assertEqual(self.dialog.ui.spinBoxGain.value(), gain)
self.assertEqual(self.dialog.ui.txtEdDescription.toPlainText(), descr)
self.assertFalse(self.dialog.ui.lineEdit_Path.isEnabled())
class TestSendRecvDialog(unittest.TestCase):
def setUp(self):
constants.SETTINGS.setValue("NetworkSDRInterface", True)
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.gframe = self.form.generator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(2)
project_manager = self.form.project_manager
self.receive_dialog = ReceiveDialogController(
project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
testing_mode=True)
self.send_dialog = SendDialogController(
project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
modulated_data=self.signal.data,
testing_mode=True)
self.send_dialog.graphics_view.show_full_scene(reinitialize=True)
self.spectrum_dialog = SpectrumDialogController(
project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
testing_mode=True)
self.sniff_dialog = ProtocolSniffDialogController(
project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
self.signal.noise_threshold,
self.signal.qad_center,
self.signal.bit_len,
self.signal.tolerance,
self.signal.modulation_type,
testing_mode=True)
self.dialogs = [
self.receive_dialog, self.send_dialog, self.spectrum_dialog,
self.sniff_dialog
]
def test_network_sdr_enabled(self):
for dialog in self.dialogs:
items = [
dialog.ui.cbDevice.itemText(i)
for i in range(dialog.ui.cbDevice.count())
]
if isinstance(dialog, SpectrumDialogController):
self.assertNotIn(NetworkSDRInterfacePlugin.NETWORK_SDR_NAME,
items)
else:
self.assertIn(NetworkSDRInterfacePlugin.NETWORK_SDR_NAME,
items)
def test_receive(self):
self.receive_dialog.ui.cbDevice.setCurrentText(
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
self.receive_dialog.device.set_server_port(2222)
self.receive_dialog.ui.btnStart.click()
data = np.array([complex(
1, 2), complex(3, 4), complex(5, 6)],
dtype=np.complex64)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("127.0.0.1", 2222))
sock.sendall(data.tostring())
sock.close()
QTest.qWait(100)
self.assertEqual(self.receive_dialog.device.current_index, 3)
self.assertTrue(
np.array_equal(self.receive_dialog.device.data[:3], data))
self.receive_dialog.ui.btnStop.click()
self.receive_dialog.ui.btnClear.click()
self.assertEqual(self.receive_dialog.device.current_index, 0)
def test_send(self):
self.receive_dialog.ui.cbDevice.setCurrentText(
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
self.receive_dialog.device.set_server_port(3333)
self.receive_dialog.ui.btnStart.click()
self.send_dialog.ui.cbDevice.setCurrentText(
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
self.send_dialog.device.set_client_port(3333)
self.send_dialog.ui.spinBoxNRepeat.setValue(2)
self.send_dialog.ui.btnStart.click()
QTest.qWait(500)
self.assertEqual(self.receive_dialog.device.current_index,
2 * self.signal.num_samples)
self.assertTrue(
np.array_equal(
self.receive_dialog.device.
data[:self.receive_dialog.device.current_index // 2],
self.signal.data))
self.assertEqual(self.send_dialog.send_indicator.rect().width(),
self.signal.num_samples)
self.assertFalse(self.send_dialog.ui.btnClear.isEnabled())
self.send_dialog.on_clear_clicked()
self.assertEqual(self.send_dialog.send_indicator.rect().width(), 0)
def test_sniff(self):
# Move with encoding to generator
gframe = self.form.generator_tab_controller
gframe.ui.cbViewType.setCurrentIndex(0)
item = gframe.tree_model.rootItem.children[0].children[0]
index = gframe.tree_model.createIndex(0, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(
gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1,
gframe.table_model.createIndex(0, 0))
self.assertEqual(gframe.table_model.rowCount(), 3)
self.sniff_dialog.ui.cbDevice.setCurrentText(
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
self.assertEqual(self.sniff_dialog.device.name,
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME)
self.sniff_dialog.device.set_server_port(4444)
gframe.network_sdr_plugin.client_port = 4444
self.sniff_dialog.ui.btnStart.click()
gframe.ui.btnNetworkSDRSend.click()
QTest.qWait(500)
received_msgs = self.sniff_dialog.ui.txtEd_sniff_Preview.toPlainText(
).split("\n")
orig_msgs = gframe.table_model.protocol.plain_bits_str
self.assertEqual(len(received_msgs), len(orig_msgs))
for received, orig in zip(received_msgs, orig_msgs):
pad = 0 if len(orig) % 8 == 0 else 8 - len(orig) % 8
self.assertEqual(received, orig + "0" * pad)
self.sniff_dialog.ui.btnStop.click()
target_file = os.path.join(QDir.tempPath(), "sniff_file")
self.assertFalse(os.path.isfile(target_file))
self.sniff_dialog.ui.btnClear.click()
self.sniff_dialog.ui.lineEdit_sniff_OutputFile.setText(target_file)
self.sniff_dialog.ui.btnStart.click()
self.assertFalse(self.sniff_dialog.ui.btnAccept.isEnabled())
gframe.ui.btnNetworkSDRSend.click()
QTest.qWait(500)
with open(target_file, "r") as f:
for i, line in enumerate(f):
pad = 0 if len(
orig_msgs[i]) % 8 == 0 else 8 - len(orig_msgs[i]) % 8
self.assertEqual(line.strip(), orig_msgs[i] + "0" * pad)
os.remove(target_file)
def test_send_dialog_scene_zoom(self):
self.assertEqual(self.send_dialog.graphics_view.sceneRect().width(),
self.signal.num_samples)
view_width = self.send_dialog.graphics_view.view_rect().width()
self.send_dialog.graphics_view.zoom(1.1)
self.assertLess(self.send_dialog.graphics_view.view_rect().width(),
view_width)
self.send_dialog.graphics_view.zoom(0.5)
self.assertGreater(self.send_dialog.graphics_view.view_rect().width(),
view_width)
def test_send_dialog_delete(self):
num_samples = self.signal.num_samples
self.assertEqual(num_samples,
self.send_dialog.scene_manager.signal.num_samples)
self.assertEqual(num_samples,
len(self.send_dialog.device.samples_to_send))
self.send_dialog.graphics_view.set_selection_area(0, 1337)
self.send_dialog.graphics_view.delete_action.trigger()
self.assertEqual(self.send_dialog.scene_manager.signal.num_samples,
num_samples - 1337)
self.assertEqual(len(self.send_dialog.device.samples_to_send),
num_samples - 1337)
def test_send_dialog_y_slider(self):
y, h = self.send_dialog.graphics_view.view_rect().y(
), self.send_dialog.graphics_view.view_rect().height()
self.send_dialog.ui.sliderYscale.setValue(
self.send_dialog.ui.sliderYscale.value() +
self.send_dialog.ui.sliderYscale.singleStep())
self.assertNotEqual(y, self.send_dialog.graphics_view.view_rect().y())
self.assertNotEqual(
h,
self.send_dialog.graphics_view.view_rect().height())
def test_change_device_parameters(self):
for dialog in self.dialogs:
dialog.ui.cbDevice.setCurrentText("HackRF")
self.assertEqual(dialog.device.name, "HackRF", msg=type(dialog))
dialog.ui.cbDevice.setCurrentText("USRP")
self.assertEqual(dialog.device.name, "USRP", msg=type(dialog))
dialog.ui.lineEditIP.setText("1.3.3.7")
dialog.ui.lineEditIP.editingFinished.emit()
self.assertEqual(dialog.device.ip, "1.3.3.7", msg=type(dialog))
dialog.ui.spinBoxFreq.setValue(10e9)
dialog.ui.spinBoxFreq.editingFinished.emit()
self.assertEqual(dialog.ui.spinBoxFreq.text()[-1], "G")
self.assertEqual(dialog.device.frequency, 10e9)
dialog.ui.spinBoxSampleRate.setValue(10e9)
dialog.ui.spinBoxSampleRate.editingFinished.emit()
self.assertEqual(dialog.ui.spinBoxSampleRate.text()[-1], "G")
self.assertEqual(dialog.device.sample_rate, 10e9)
dialog.ui.spinBoxBandwidth.setValue(1e3)
dialog.ui.spinBoxBandwidth.editingFinished.emit()
self.assertEqual(dialog.ui.spinBoxBandwidth.text()[-1], "K")
self.assertEqual(dialog.device.bandwidth, 1e3)
dialog.ui.spinBoxGain.setValue(5)
dialog.ui.spinBoxGain.editingFinished.emit()
self.assertEqual(dialog.device.gain, 5)
dialog.ui.spinBoxNRepeat.setValue(10)
dialog.ui.spinBoxNRepeat.editingFinished.emit()
if isinstance(dialog, SendDialogController):
self.assertEqual(dialog.device.num_sending_repeats, 10)
else:
self.assertEqual(dialog.device.num_sending_repeats, None)
class TestAnalysisTabGUI(unittest.TestCase):
def setUp(self):
short_wait()
self.form = MainController()
short_wait()
self.cfc = self.form.compare_frame_controller
self.form.add_signalfile(
get_path_for_data_file("two_participants.complex"))
app.processEvents()
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.signal.noise_threshold = 0.0175
self.signal.qad_center = 0
self.signal.bit_len = 100
self.signal.tolerance = 5
def test_analyze_button_fsk(self):
self.form.add_signalfile(get_path_for_data_file("fsk.complex"))
self.cfc.ui.btnAnalyze.click()
self.assertTrue(True)
def test_analyze_button_enocean(self):
self.form.add_signalfile(get_path_for_data_file("enocean.complex"))
w = self.form.signal_tab_controller.signal_frames[
1].ui.spinBoxCenterOffset
w.setValue(0)
QTest.keyClick(w, Qt.Key_Enter)
w = self.form.signal_tab_controller.signal_frames[
1].ui.spinBoxNoiseTreshold
w.setValue(0.0111)
QTest.keyClick(w, Qt.Key_Enter)
self.cfc.ui.btnAnalyze.click()
self.assertTrue(True)
def test_table_selection(self):
self.form.ui.tabWidget.setCurrentIndex(1)
self.cfc.ui.cbProtoView.setCurrentIndex(0)
self.cfc.ui.tblViewProtocol.selectRow(1)
app.processEvents()
self.assertEqual(self.cfc.ui.lBitsSelection.text(),
self.cfc.proto_analyzer.messages[1].plain_bits_str)
self.cfc.ui.tblViewProtocol.clearSelection()
app.processEvents()
self.assertEqual("", self.cfc.ui.lBitsSelection.text())
self.cfc.ui.tblViewProtocol.select(0, 0, 0, 3)
app.processEvents()
self.assertEqual("1010", self.cfc.ui.lBitsSelection.text())
self.cfc.ui.cbProtoView.setCurrentIndex(1)
app.processEvents()
min_row, max_row, start, end = self.cfc.ui.tblViewProtocol.selection_range(
)
self.assertEqual(min_row, 0)
self.assertEqual(max_row, 0)
self.assertEqual(start, 0)
self.assertEqual(end, 1)
def test_search(self):
search_str = "100110001"
self.cfc.ui.cbProtoView.setCurrentIndex(0)
self.cfc.ui.tblViewProtocol.clearSelection()
self.cfc.ui.lineEditSearch.setText(search_str)
self.cfc.ui.btnSearchSelectFilter.click()
selected_now = self.cfc.ui.tblViewProtocol.selectedIndexes()
self.assertEqual(len(self.cfc.ui.tblViewProtocol.selectedIndexes()),
len(search_str))
self.cfc.ui.btnNextSearch.click()
self.assertNotEqual(selected_now,
self.cfc.ui.tblViewProtocol.selectedIndexes())
self.cfc.ui.btnPrevSearch.click()
self.assertEqual(selected_now,
self.cfc.ui.tblViewProtocol.selectedIndexes())
self.cfc.select_action.trigger()
self.assertEqual(self.cfc.ui.btnSearchSelectFilter.text(),
"Select all")
self.cfc.ui.btnSearchSelectFilter.click()
self.assertGreater(len(self.cfc.ui.tblViewProtocol.selectedIndexes()),
len(selected_now))
self.cfc.filter_action.trigger()
self.assertEqual(self.cfc.ui.btnSearchSelectFilter.text(), "Filter")
self.cfc.ui.btnSearchSelectFilter.click()
hidden_rows = [
i for i in range(self.cfc.protocol_model.row_count)
if self.cfc.ui.tblViewProtocol.isRowHidden(i)
]
self.assertEqual(hidden_rows, [0, 5, 6, 10, 13, 14, 16, 17])
def test_show_diff(self):
hidden_columns_before = [
i for i in range(self.cfc.protocol_model.col_count)
if self.cfc.ui.tblViewProtocol.isColumnHidden(i)
]
self.assertEqual(len(hidden_columns_before), 0)
self.cfc.ui.chkBoxShowOnlyDiffs.click()
self.assertTrue(self.cfc.ui.cbShowDiffs.isChecked())
hidden_columns_now = [
i for i in range(self.cfc.protocol_model.col_count)
if self.cfc.ui.tblViewProtocol.isColumnHidden(i)
]
self.assertNotEqual(hidden_columns_before, hidden_columns_now)
self.cfc.ui.chkBoxOnlyShowLabelsInProtocol.click()
hidden_columns_now = [
i for i in range(self.cfc.protocol_model.col_count)
if self.cfc.ui.tblViewProtocol.isColumnHidden(i)
]
self.assertEqual(len(hidden_columns_now),
self.cfc.protocol_model.col_count)
def test_add_message_type(self):
self.assertEqual(len(self.cfc.proto_analyzer.message_types), 1)
self.cfc.ui.btnAddMessagetype.click()
self.assertEqual(len(self.cfc.proto_analyzer.message_types), 2)
self.cfc.ui.btnRemoveMessagetype.click()
self.assertEqual(len(self.cfc.proto_analyzer.message_types), 1)
def test_create_context_menu(self):
# Add protocol label should be disabled if table is empty
self.cfc.proto_tree_model.rootItem.child(0).show = False
app.processEvents()
self.assertEqual(self.cfc.protocol_model.rowCount(), 0)
self.cfc.ui.tblViewProtocol.context_menu_pos = QPoint(0, 0)
app.processEvents()
menu = self.cfc.ui.tblViewProtocol.create_context_menu()
create_label_action = next(a for a in menu.actions()
if a.text() == "Add protocol label")
self.assertFalse(create_label_action.isEnabled())
def test_show_in_interpretation(self):
self.form.ui.tabWidget.setCurrentIndex(1)
self.assertEqual(self.form.ui.tabWidget.currentIndex(), 1)
self.cfc.ui.cbProtoView.setCurrentIndex(0)
self.cfc.ui.tblViewProtocol.selectRow(1)
min_row, max_row, start, end = self.cfc.ui.tblViewProtocol.selection_range(
)
self.cfc.ui.tblViewProtocol.show_interpretation_clicked.emit(
min_row, start, max_row, end - 1)
self.assertEqual(self.form.ui.tabWidget.currentIndex(), 0)
self.assertFalse(self.form.signal_tab_controller.signal_frames[0].ui.
gvSignal.selection_area.is_empty)
def test_hide_row(self):
num_messages = len(self.cfc.proto_analyzer.messages)
self.form.ui.tabWidget.setCurrentIndex(1)
self.assertGreater(num_messages, 0)
self.assertEqual(self.cfc.protocol_model.rowCount(), num_messages)
self.cfc.ui.tblViewProtocol.hide_row(0)
self.assertTrue(self.cfc.ui.tblViewProtocol.isRowHidden(0))
self.assertEqual(len(self.cfc.protocol_model.hidden_rows), 1)
for msg in range(1, num_messages):
self.assertFalse(self.cfc.ui.tblViewProtocol.isRowHidden(msg))
self.form.ui.tabWidget.setCurrentIndex(2)
short_wait()
self.form.ui.tabWidget.setCurrentIndex(1)
short_wait()
self.assertEqual(self.cfc.protocol_model.rowCount(), num_messages)
self.assertTrue(self.cfc.ui.tblViewProtocol.isRowHidden(0))
for msg in range(1, num_messages):
self.assertFalse(self.cfc.ui.tblViewProtocol.isRowHidden(msg))
self.assertEqual(len(self.cfc.protocol_model.hidden_rows), 1)
def test_refresh_existing_decodings(self):
self.assertEqual(self.cfc.proto_analyzer.messages[0].decoder,
self.cfc.decodings[0])
decoder = copy.deepcopy(self.cfc.proto_analyzer.messages[0].decoder)
decoder.chain.append(decoder.code_invert)
self.cfc.proto_analyzer.messages[0].decoder = decoder
self.assertNotEqual(self.cfc.proto_analyzer.messages[0].decoder,
self.cfc.decodings[0])
self.cfc.refresh_existing_encodings()
self.assertEqual(self.cfc.proto_analyzer.messages[0].decoder,
self.cfc.decodings[0])
def test_get_labels_from_selection(self):
self.cfc.ui.tblViewProtocol.selectRow(1)
self.assertEqual(
len(
self.cfc.get_labels_from_selection(
*self.cfc.ui.tblViewProtocol.selection_range())), 0)
def test_refresh_field_types_for_labels(self):
self.cfc.add_protocol_label(0, 10, 0, 0, edit_label_name=False)
n = len(self.cfc.field_types)
self.cfc.refresh_field_types_for_labels()
self.assertEqual(len(self.cfc.field_types), n)
def test_tree_view_selection_changed(self):
self.cfc.proto_tree_model.addGroup()
self.cfc.proto_tree_model.addGroup()
app.processEvents()
self.assertEqual(len(self.cfc.active_group_ids), 1)
self.cfc.ui.treeViewProtocols.selectAll()
self.cfc.ui.treeViewProtocols.selection_changed.emit()
app.processEvents()
self.assertEqual(len(self.cfc.active_group_ids), 1)
def test_label_selection_changed(self):
self.assertEqual(
self.cfc.ui.tblViewProtocol.horizontalScrollBar().value(), 0)
self.cfc.add_protocol_label(40, 60, 2, 0, edit_label_name=False)
self.assertEqual(self.cfc.protocol_label_list_model.rowCount(), 1)
self.cfc.ui.listViewLabelNames.selectAll()
self.assertEqual(len(self.cfc.ui.listViewLabelNames.selectedIndexes()),
1)
self.assertGreater(
self.cfc.ui.tblViewProtocol.horizontalScrollBar().value(), 0)
def test_remove_label(self):
self.cfc.add_protocol_label(10, 20, 2, 0, edit_label_name=False)
self.assertEqual(self.cfc.protocol_label_list_model.rowCount(), 1)
self.cfc.protocol_label_list_model.delete_label_at(0)
self.assertEqual(self.cfc.protocol_label_list_model.rowCount(), 0)
class TestSendRecvDialog(unittest.TestCase):
def setUp(self):
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.gframe = self.form.generator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(2)
project_manager = self.form.project_manager
self.receive_dialog = SendRecvDialogController(
project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
Mode.receive,
testing_mode=True)
self.send_dialog = SendRecvDialogController(
project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
Mode.send,
modulated_data=self.signal.data,
testing_mode=True)
self.send_dialog.graphics_view.show_full_scene(reinitialize=True)
self.spectrum_dialog = SendRecvDialogController(
project_manager.frequency,
project_manager.sample_rate,
project_manager.bandwidth,
project_manager.gain,
project_manager.device,
Mode.spectrum,
testing_mode=True)
self.dialogs = [
self.receive_dialog, self.send_dialog, self.spectrum_dialog
]
def test_send_dialog_scene_zoom(self):
self.assertEqual(self.send_dialog.graphics_view.sceneRect().width(),
self.signal.num_samples)
view_width = self.send_dialog.graphics_view.view_rect().width()
self.send_dialog.graphics_view.zoom(1.1)
self.assertLess(self.send_dialog.graphics_view.view_rect().width(),
view_width)
self.send_dialog.graphics_view.zoom(0.5)
self.assertGreater(self.send_dialog.graphics_view.view_rect().width(),
view_width)
def test_send_dialog_delete(self):
num_samples = self.signal.num_samples
self.assertEqual(num_samples,
self.send_dialog.scene_manager.signal.num_samples)
self.assertEqual(num_samples,
len(self.send_dialog.device.samples_to_send))
self.send_dialog.graphics_view.set_selection_area(0, 1337)
self.send_dialog.graphics_view.delete_action.trigger()
self.assertEqual(self.send_dialog.scene_manager.signal.num_samples,
num_samples - 1337)
self.assertEqual(len(self.send_dialog.device.samples_to_send),
num_samples - 1337)
def test_send_dialog_y_slider(self):
y, h = self.send_dialog.graphics_view.view_rect().y(
), self.send_dialog.graphics_view.view_rect().height()
self.send_dialog.ui.sliderYscale.setValue(
self.send_dialog.ui.sliderYscale.value() +
self.send_dialog.ui.sliderYscale.singleStep())
self.assertNotEqual(y, self.send_dialog.graphics_view.view_rect().y())
self.assertNotEqual(
h,
self.send_dialog.graphics_view.view_rect().height())
def test_change_device_parameters(self):
for dialog in self.dialogs:
dialog.ui.cbDevice.setCurrentText("HackRF")
self.assertEqual(dialog.device.name, "HackRF", msg=dialog.mode)
dialog.ui.cbDevice.setCurrentText("USRP")
self.assertEqual(dialog.device.name, "USRP", msg=dialog.mode)
dialog.ui.lineEditIP.setText("1.3.3.7")
dialog.ui.lineEditIP.editingFinished.emit()
self.assertEqual(dialog.device.ip, "1.3.3.7")
dialog.ui.spinBoxFreq.setValue(10e9)
dialog.ui.spinBoxFreq.editingFinished.emit()
self.assertEqual(dialog.ui.spinBoxFreq.text()[-1], "G")
self.assertEqual(dialog.device.frequency, 10e9)
dialog.ui.spinBoxSampleRate.setValue(10e9)
dialog.ui.spinBoxSampleRate.editingFinished.emit()
self.assertEqual(dialog.ui.spinBoxSampleRate.text()[-1], "G")
self.assertEqual(dialog.device.sample_rate, 10e9)
dialog.ui.spinBoxBandwidth.setValue(1e3)
dialog.ui.spinBoxBandwidth.editingFinished.emit()
self.assertEqual(dialog.ui.spinBoxBandwidth.text()[-1], "K")
self.assertEqual(dialog.device.bandwidth, 1e3)
dialog.ui.spinBoxGain.setValue(5)
dialog.ui.spinBoxGain.editingFinished.emit()
self.assertEqual(dialog.device.gain, 5)
dialog.ui.spinBoxNRepeat.setValue(10)
dialog.ui.spinBoxNRepeat.editingFinished.emit()
if dialog.mode == Mode.send:
self.assertEqual(dialog.device.num_sending_repeats, 10)
else:
self.assertEqual(dialog.device.num_sending_repeats, None)
class QtTestCase(unittest.TestCase):
CLOSE_TIMEOUT = 10
WAIT_TIMEOUT_BEFORE_NEW = 10
SHOW = os.path.exists(os.path.join(os.path.dirname(os.path.realpath(__file__)), "show_gui"))
@classmethod
def setUpClass(cls):
import multiprocessing as mp
try:
mp.set_start_method("spawn")
except RuntimeError:
pass
assert mp.get_start_method() == "spawn"
write_settings()
cls.app = QApplication([cls.__name__])
@classmethod
def tearDownClass(cls):
cls.app.quit()
cls.app = None
QTest.qWait(10)
time.sleep(0.1)
def setUp(self):
ProtocolSniffer.BUFFER_SIZE_MB = 0.5
self.form = MainController()
if self.SHOW:
self.form.show()
def tearDown(self):
if hasattr(self, "dialog"):
self.dialog.close()
sip.delete(self.dialog)
self.dialog = None
if hasattr(self, "form"):
self.form.close_all_files()
self.form.close()
sip.delete(self.form)
self.form = None
gc.collect()
def wait_before_new_file(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
def add_signal_to_form(self, filename: str):
self.wait_before_new_file()
self.form.add_signalfile(get_path_for_data_file(filename))
def get_path_for_filename(self, filename) -> str:
return get_path_for_data_file(filename)
def add_signal_to_generator(self, signal_index: int):
gframe = self.form.generator_tab_controller
item = gframe.tree_model.rootItem.children[0].children[signal_index]
index = gframe.tree_model.createIndex(signal_index, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(), Qt.LeftButton, pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1, gframe.table_model.createIndex(0, 0))
def add_all_signals_to_simulator(self):
assert isinstance(self.form, MainController)
sim_frame = self.form.simulator_tab_controller
sim_frame.ui.treeProtocols.selectAll()
self.assertGreater(len(sim_frame.ui.treeProtocols.selectedIndexes()), 0)
mimedata = sim_frame.tree_model.mimeData(sim_frame.ui.treeProtocols.selectedIndexes())
drop_event = QDropEvent(sim_frame.ui.gvSimulator.rect().center(), Qt.CopyAction | Qt.MoveAction,
mimedata, Qt.LeftButton, Qt.NoModifier)
drop_event.acceptProposedAction()
sim_frame.ui.gvSimulator.dropEvent(drop_event)
def get_free_port(self):
import socket
s = socket.socket()
s.bind(("", 0))
port = s.getsockname()[1]
s.close()
return port
class TestModulatorGUI(unittest.TestCase):
def setUp(self):
self.form = MainController()
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.gframe = self.form.generator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(2)
self.dialog, _ = self.gframe.prepare_modulation_dialog()
self.gframe.initialize_modulation_dialog("1111", self.dialog)
def test_add_remove_modulator(self):
self.assertEqual(len(self.dialog.modulators), 1)
self.dialog.ui.btnAddModulation.click()
self.assertEqual(len(self.dialog.modulators), 2)
self.dialog.ui.btnAddModulation.click()
self.assertEqual(len(self.dialog.modulators), 3)
app.processEvents()
self.dialog.ui.btnRemoveModulation.click()
self.assertEqual(len(self.dialog.modulators), 2)
self.dialog.ui.btnRemoveModulation.click()
self.assertEqual(len(self.dialog.modulators), 1)
self.assertFalse(self.dialog.ui.btnRemoveModulation.isEnabled())
def test_edit_carrier(self):
self.dialog.ui.doubleSpinBoxCarrierFreq.setValue(1e9)
self.dialog.ui.doubleSpinBoxCarrierFreq.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.carrier_freq_hz, 1e9)
self.dialog.ui.doubleSpinBoxCarrierPhase.setValue(100)
self.dialog.ui.doubleSpinBoxCarrierPhase.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.carrier_phase_deg, 100)
def test_edit_data(self):
bits = self.dialog.current_modulator.display_bits
self.dialog.ui.linEdDataBits.setText("10101010")
self.dialog.ui.linEdDataBits.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.display_bits,
"10101010")
self.dialog.ui.btnRestoreBits.click()
self.dialog.ui.linEdDataBits.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.display_bits, bits)
self.dialog.ui.spinBoxBitLength.setValue(1337)
self.dialog.ui.spinBoxBitLength.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.samples_per_bit, 1337)
self.dialog.ui.spinBoxSampleRate.setValue(5e6)
self.dialog.ui.spinBoxSampleRate.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.sample_rate, 5e6)
def test_zoom(self):
self.dialog.ui.gVModulated.zoom(1.1)
self.assertEqual(int(self.dialog.ui.gVModulated.view_rect().width()),
int(self.dialog.ui.gVCarrier.view_rect().width()))
self.assertEqual(int(self.dialog.ui.gVModulated.view_rect().width()),
int(self.dialog.ui.gVData.view_rect().width()))
self.dialog.ui.gVModulated.zoom(1.01)
self.assertEqual(int(self.dialog.ui.gVModulated.view_rect().width()),
int(self.dialog.ui.gVCarrier.view_rect().width()))
self.assertEqual(int(self.dialog.ui.gVModulated.view_rect().width()),
int(self.dialog.ui.gVData.view_rect().width()))
def test_edit_modulation(self):
self.dialog.ui.comboBoxModulationType.setCurrentText(
"Amplitude Shift Keying (ASK)")
self.assertEqual(self.dialog.ui.lParameterfor0.text(),
"Amplitude for 0:")
self.assertEqual(self.dialog.ui.lParameterfor1.text(),
"Amplitude for 1:")
self.dialog.ui.comboBoxModulationType.setCurrentText(
"Frequency Shift Keying (FSK)")
self.assertEqual(self.dialog.ui.lParameterfor0.text(),
"Frequency for 0:")
self.assertEqual(self.dialog.ui.lParameterfor1.text(),
"Frequency for 1:")
self.dialog.ui.comboBoxModulationType.setCurrentText(
"Gaussian Frequency Shift Keying (GFSK)")
self.assertEqual(self.dialog.ui.lParameterfor0.text(),
"Frequency for 0:")
self.assertEqual(self.dialog.ui.lParameterfor1.text(),
"Frequency for 1:")
self.dialog.ui.spinBoxGaussBT.setValue(0.5)
self.dialog.ui.spinBoxGaussBT.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.gauss_bt, 0.5)
self.dialog.ui.spinBoxGaussFilterWidth.setValue(5)
self.dialog.ui.spinBoxGaussFilterWidth.editingFinished.emit()
self.assertEqual(self.dialog.current_modulator.gauss_filter_width, 5)
self.dialog.ui.comboBoxModulationType.setCurrentText(
"Phase Shift Keying (PSK)")
self.assertEqual(self.dialog.ui.lParameterfor0.text(),
"Phase (degree) for 0:")
self.assertEqual(self.dialog.ui.lParameterfor1.text(),
"Phase (degree) for 1:")
self.dialog.ui.comboBoxModulationType.setCurrentText(
"Amplitude Shift Keying (ASK)")
self.assertEqual(self.dialog.ui.lParameterfor0.text(),
"Amplitude for 0:")
self.assertEqual(self.dialog.ui.lParameterfor1.text(),
"Amplitude for 1:")
self.assertEqual(int(self.dialog.ui.lSamplesInViewModulated.text()),
int(self.dialog.ui.gVModulated.view_rect().width()))
def test_signal_view(self):
tree_view = self.dialog.ui.treeViewSignals
tree_model = tree_view.model()
item = tree_model.rootItem.children[0].children[0]
index = tree_model.createIndex(0, 0, item)
rect = tree_view.visualRect(index)
QTest.mousePress(tree_view.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(tree_view.selectedIndexes()[0], index)
mime_data = tree_model.mimeData(tree_view.selectedIndexes())
drag_drop = QDropEvent(rect.center(), Qt.CopyAction | Qt.MoveAction,
mime_data, Qt.LeftButton, Qt.NoModifier)
drag_drop.acceptProposedAction()
self.dialog.ui.gVOriginalSignal.dropEvent(drag_drop)
self.assertEqual(self.dialog.ui.gVOriginalSignal.sceneRect().width(),
self.signal.num_samples)
self.dialog.ui.cbShowDataBitsOnly.click()
self.dialog.ui.chkBoxLockSIV.click()
self.assertEqual(
int(self.dialog.ui.gVOriginalSignal.view_rect().width()),
int(self.dialog.ui.gVModulated.view_rect().width()))
freq = self.dialog.ui.doubleSpinBoxCarrierFreq.value()
self.dialog.ui.btnAutoDetect.click()
self.assertNotEqual(freq,
self.dialog.ui.doubleSpinBoxCarrierFreq.value())
self.dialog.ui.comboBoxModulationType.setCurrentText(
"Frequency Shift Keying (FSK)")
self.dialog.ui.btnAutoDetect.click()
self.assertEqual(self.dialog.ui.lCurrentSearchResult.text(), "1")
self.dialog.ui.btnSearchNext.click()
self.assertEqual(self.dialog.ui.lCurrentSearchResult.text(), "2")
self.dialog.ui.btnSearchPrev.click()
self.assertEqual(self.dialog.ui.lCurrentSearchResult.text(), "1")
class TestSimulatorPerfomance(QtTestCase):
def setUp(self):
super().setUp()
self.num_zeros_for_pause = 1000
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.coco"))
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.1, 5, 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_bit = 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()
class TestGenerator(unittest.TestCase):
def setUp(self):
constants.SETTINGS.setValue("not_show_close_dialog", True) # prevent interactive close questions
self.form = MainController()
def test_generation(self):
"""
Complex test including much functionality
1) Load a Signal
2) Set Decoding in Compareframe
3) Move with encoding to Generator
4) Generate datafile
5) Read datafile and compare with original signal
"""
# Load a Signal
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
sframe = self.form.signal_tab_controller.signal_frames[0]
sframe.ui.cbModulationType.setCurrentIndex(0) # ASK
sframe.ui.spinBoxInfoLen.setValue(295)
sframe.ui.spinBoxCenterOffset.setValue(-0.1667)
sframe.refresh()
proto = "1011001001011011011011011011011011001000000"
self.assertTrue(sframe.ui.txtEdProto.toPlainText().startswith(proto))
# Set Decoding
self.form.ui.tabWidget.setCurrentIndex(1)
cfc = self.form.compare_frame_controller
cfc.ui.cbDecoding.setCurrentIndex(1) # NRZ-I
proto_inv = cfc.proto_analyzer.decoded_proto_bits_str[0]
self.assertTrue(self.__is_inv_proto(proto, proto_inv))
# Move with encoding to generator
gframe = self.form.generator_tab_controller
gframe.ui.cbViewType.setCurrentIndex(0)
item = gframe.tree_model.rootItem.children[0].children[0]
index = gframe.tree_model.createIndex(0, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(), Qt.LeftButton, pos = rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1, gframe.table_model.createIndex(0, 0))
self.assertEqual(proto_inv, gframe.table_model.display_data[0])
self.assertNotEqual(proto, gframe.table_model.display_data[0])
# Generate Datafile
modulator = gframe.modulators[0]
modulator.modulation_type = 0
modulator.samples_per_bit = 295
modulated_data = gframe.modulate_data()
filename = os.path.join(QDir.tempPath(), "generator_test.complex")
modulated_data.tofile(filename)
# Reload datafile and see if bits match
self.form.add_signalfile(filename)
sframe = self.form.signal_tab_controller.signal_frames[1]
self.assertEqual(sframe.ui.lineEditSignalName.text(), "generator_test")
sframe.ui.cbSignalView.setCurrentIndex(1) # ASK
sframe.ui.spinBoxInfoLen.setValue(295)
sframe.ui.spinBoxInfoLen.editingFinished.emit()
sframe.ui.spinBoxCenterOffset.setValue(0.1)
sframe.ui.spinBoxCenterOffset.editingFinished.emit()
sframe.ui.spinBoxTolerance.setValue(6)
sframe.ui.spinBoxTolerance.editingFinished.emit()
sframe.refresh()
gen_proto = sframe.ui.txtEdProto.toPlainText()
gen_proto = gen_proto[:gen_proto.index(" ")]
self.assertTrue(proto.startswith(gen_proto))
def test_close_signal(self):
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
sframe = self.form.signal_tab_controller.signal_frames[0]
sframe.ui.cbModulationType.setCurrentIndex(0) # ASK
sframe.ui.spinBoxInfoLen.setValue(295)
sframe.ui.spinBoxCenterOffset.setValue(-0.1667)
sframe.refresh()
# Move with encoding to generator
gframe = self.form.generator_tab_controller
gframe.ui.cbViewType.setCurrentIndex(0)
item = gframe.tree_model.rootItem.children[0].children[0]
index = gframe.tree_model.createIndex(0, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(), Qt.LeftButton, pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1, gframe.table_model.createIndex(0, 0))
self.assertEqual(gframe.table_model.row_count, self.form.compare_frame_controller.protocol_model.row_count)
self.form.ui.tabWidget.setCurrentIndex(0)
self.form.on_selected_tab_changed(0)
sframe.ui.btnCloseSignal.click()
self.form.ui.tabWidget.setCurrentIndex(1)
self.form.on_selected_tab_changed(1)
self.form.ui.tabWidget.setCurrentIndex(2)
self.form.on_selected_tab_changed(2)
self.assertEqual(1, 1)
def __is_inv_proto(self, proto1: str, proto2: str):
if len(proto1) != len(proto2):
return False
for c1, c2 in zip(proto1, proto2):
if not self.__is_inv_bits(c1, c2):
return False
return True
def __is_inv_bits(self, a: str, b: str):
# We only check bits here
if a not in ("0", "1") or b not in ("0", "1"):
return True
if a == "0" and b == "1":
return True
if a == "1" and b == "0":
return True
return False
class TestFuzzing(unittest.TestCase):
def setUp(self):
self.old_sym_len = constants.SETTINGS.value('rel_symbol_length',
type=int)
constants.SETTINGS.setValue('rel_symbol_length',
0) # Disable Symbols for this Test
self.form = MainController()
self.form.add_signalfile(
get_path_for_data_file("steckdose_anlernen.complex"))
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxNoiseTreshold.setValue(0.06)
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxNoiseTreshold.editingFinished.emit()
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxCenterOffset.setValue(-0.0127)
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxCenterOffset.editingFinished.emit()
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxInfoLen.setValue(100)
self.form.signal_tab_controller.signal_frames[
0].ui.spinBoxInfoLen.editingFinished.emit()
self.sframe = self.form.signal_tab_controller.signal_frames[0]
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
# Dewhitening mit SyncByte 0x9a7d9a7d, Data Whitening Poly 0x21, Compute and apply CRC16 via X0r,
# Rest auf False anlegen und setzen
self.form.ui.tabWidget.setCurrentIndex(1)
self.cframe.ui.cbProtoView.setCurrentIndex(1) # Hex
decoding = Encoder([
"Data Whitening", constants.DECODING_DATAWHITENING,
"0x9a7d9a7d;0x21;0x8"
])
self.cframe.decodings.append(decoding)
self.cframe.ui.cbDecoding.addItem(decoding.name)
self.cframe.set_decoding(decoding)
# CRC Check
self.assertEqual(self.cframe.protocol_model.display_data[0][-4:],
"0000")
# Serial Part 1: Bits 207-226 (Dezimal: 91412) (20 Bits)
self.cframe.add_protocol_label(start=206,
end=225,
messagenr=0,
proto_view=0,
edit_label_name=False)
# Zeros: Bits 227-244 (18 Bits)
self.cframe.add_protocol_label(start=226,
end=243,
messagenr=0,
proto_view=0,
edit_label_name=False)
# Serial Part 2: Bit 245 - 264 (Dezimal: 1034678) (20 Bits)
self.cframe.add_protocol_label(start=244,
end=263,
messagenr=0,
proto_view=0,
edit_label_name=False)
self.form.ui.tabWidget.setCurrentIndex(2)
item = self.gframe.tree_model.rootItem.children[0].children[0]
index = self.gframe.tree_model.createIndex(0, 0, item)
rect = self.gframe.ui.treeProtocols.visualRect(index)
self.assertEqual(len(self.gframe.ui.treeProtocols.selectedIndexes()),
0)
QTest.mousePress(self.gframe.ui.treeProtocols.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(self.gframe.ui.treeProtocols.selectedIndexes()[0],
index)
mimedata = self.gframe.tree_model.mimeData(
self.gframe.ui.treeProtocols.selectedIndexes())
self.gframe.table_model.dropMimeData(
mimedata, 1, -1, -1, self.gframe.table_model.createIndex(0, 0))
self.assertEqual(self.gframe.table_model.row_count, 1)
self.assertEqual(len(self.gframe.table_model.protocol.protocol_labels),
3)
def tearDown(self):
constants.SETTINGS.setValue('rel_symbol_length',
self.old_sym_len) # Restore Symbol Length
def test_fuzz_label_bit(self):
self.gframe.ui.cbViewType.setCurrentIndex(1) # hex view
fdc = FuzzingDialogController(
protocol=self.gframe.table_model.protocol,
label_index=0,
msg_index=0,
proto_view=0,
parent=self.gframe)
fdc.finished.connect(self.gframe.refresh_label_list)
fdc.finished.connect(self.gframe.refresh_table)
fdc.finished.connect(self.gframe.set_fuzzing_ui_status)
self.assertEqual(
fdc.message_data[fdc.current_label_start:fdc.current_label_end],
"00010110010100010100") # Serial Part 1
fdc.ui.comboBoxFuzzingLabel.setCurrentIndex(1)
self.assertEqual(
fdc.message_data[fdc.current_label_start:fdc.current_label_end],
"000000000000000000") # Zeros
fdc.ui.comboBoxFuzzingLabel.setCurrentIndex(2)
self.assertEqual(
fdc.message_data[fdc.current_label_start:fdc.current_label_end],
"11111100100110110110") # Serial Part 2
def test_fuzz_label_hex(self):
for message in self.gframe.table_model.protocol.messages:
message.align_labels = False
self.gframe.ui.cbViewType.setCurrentIndex(1) # hex view
fdc = FuzzingDialogController(self.gframe.table_model.protocol,
0,
1,
1,
parent=self.gframe)
fdc.finished.connect(self.gframe.refresh_label_list)
fdc.finished.connect(self.gframe.refresh_table)
fdc.finished.connect(self.gframe.set_fuzzing_ui_status)
self.assertEqual(
fdc.message_data[fdc.current_label_start:fdc.current_label_end],
"c5945") # Serial Part 1
fdc.ui.comboBoxFuzzingLabel.setCurrentIndex(1)
self.assertEqual(
fdc.message_data[fdc.current_label_start:fdc.current_label_end],
"00000") # Zeros
fdc.ui.comboBoxFuzzingLabel.setCurrentIndex(2)
self.assertEqual(
fdc.message_data[fdc.current_label_start:fdc.current_label_end],
"fc9b6") # Serial Part 2
class TestPlugins(unittest.TestCase):
def setUp(self):
self.old_sym_len = constants.SETTINGS.value('rel_symbol_length',
type=int)
constants.SETTINGS.setValue('rel_symbol_length',
0) # Disable Symbols for this Test
QTest.qWait(100)
self.form = MainController()
self.form.add_signalfile("./data/esaver.complex")
QTest.qWait(100)
self.sframe = self.form.signal_tab_controller.signal_frames[0]
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(1)
self.assertEqual(self.cframe.protocol_model.row_count, 3)
def tearDown(self):
constants.SETTINGS.setValue('rel_symbol_length',
self.old_sym_len) # Restore Symbol Length
def test_block_break_plugin(self):
bp = BlockBreakPlugin()
action = bp.get_action(self.cframe.ui.tblViewProtocol,
self.cframe.protocol_undo_stack, (1, 1, 4, 4),
self.cframe.proto_analyzer, 0)
self.assertEqual(self.cframe.protocol_model.row_count, 3)
action.trigger()
QTest.qWait(100)
self.assertEqual(self.cframe.protocol_model.row_count, 4)
self.cframe.protocol_undo_stack.undo()
QTest.qWait(100)
self.assertEqual(self.cframe.protocol_model.row_count, 3)
def test_zero_hide_plugin_gui(self):
self.assertEqual(
len(self.cframe.proto_analyzer.decoded_proto_bits_str[0]), 377)
zh = ZeroHidePlugin()
zh.following_zeros = 188
action = zh.get_action(self.cframe.ui.tblViewProtocol,
self.cframe.protocol_undo_stack, (),
self.cframe.proto_analyzer, 0)
action.trigger()
QTest.qWait(100)
self.assertEqual(
len(self.cframe.proto_analyzer.decoded_proto_bits_str[0]),
377 - 188)
self.cframe.protocol_undo_stack.undo()
QTest.qWait(100)
self.assertEqual(
len(self.cframe.proto_analyzer.decoded_proto_bits_str[0]), 377)
def test_zero_hide_plugin_function(self):
zh = ZeroHidePlugin()
zh.following_zeros = 3
self.form.add_signalfile("./data/ask.complex")
self.form.ui.tabWidget.setCurrentIndex(1)
QTest.qWait(100)
test_bits = "10110010010110110110110110110110110001000000"
self.assertEqual(self.cframe.proto_analyzer.decoded_proto_bits_str[3],
test_bits)
action = zh.get_action(self.cframe.ui.tblViewProtocol,
self.cframe.protocol_undo_stack, (),
self.cframe.proto_analyzer, 0)
action.trigger()
QTest.qWait(100)
self.assertEqual(self.cframe.proto_analyzer.decoded_proto_bits_str[3],
"10110010010110110110110110110110111")
class QtTestCase(unittest.TestCase):
CLOSE_TIMEOUT = 10
WAIT_TIMEOUT_BEFORE_NEW = 10
SHOW = os.path.exists(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "show_gui"))
@classmethod
def setUpClass(cls):
import multiprocessing as mp
try:
mp.set_start_method("spawn")
except RuntimeError:
pass
assert mp.get_start_method() == "spawn"
write_settings()
cls.app = QApplication([cls.__name__])
@classmethod
def tearDownClass(cls):
cls.app.quit()
cls.app = None
QTest.qWait(10)
time.sleep(0.1)
def setUp(self):
ProtocolSniffer.BUFFER_SIZE_MB = 0.5
self.form = MainController()
self.form.ui.actionAuto_detect_new_signals.setChecked(False)
if self.SHOW:
self.form.show()
def tearDown(self):
if hasattr(self, "dialog"):
self.dialog.close()
try:
sip.delete(self.dialog)
except TypeError:
pass
self.dialog = None
if hasattr(self, "form"):
self.form.close_all_files()
self.form.close()
try:
sip.delete(self.form)
except TypeError:
pass
self.form = None
gc.collect()
def wait_before_new_file(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
def add_signal_to_form(self, filename: str):
self.wait_before_new_file()
self.form.add_signalfile(get_path_for_data_file(filename))
def get_path_for_filename(self, filename) -> str:
return get_path_for_data_file(filename)
def add_signal_to_generator(self, signal_index: int):
gframe = self.form.generator_tab_controller
item = gframe.tree_model.rootItem.children[0].children[signal_index]
index = gframe.tree_model.createIndex(signal_index, 0, item)
rect = gframe.ui.treeProtocols.visualRect(index)
QTest.mousePress(gframe.ui.treeProtocols.viewport(),
Qt.LeftButton,
pos=rect.center())
self.assertEqual(gframe.ui.treeProtocols.selectedIndexes()[0], index)
mimedata = gframe.tree_model.mimeData(
gframe.ui.treeProtocols.selectedIndexes())
gframe.table_model.dropMimeData(mimedata, 1, -1, -1,
gframe.table_model.createIndex(0, 0))
def add_all_signals_to_simulator(self):
assert isinstance(self.form, MainController)
sim_frame = self.form.simulator_tab_controller
sim_frame.ui.treeProtocols.selectAll()
self.assertGreater(len(sim_frame.ui.treeProtocols.selectedIndexes()),
0)
mimedata = sim_frame.tree_model.mimeData(
sim_frame.ui.treeProtocols.selectedIndexes())
drop_event = QDropEvent(sim_frame.ui.gvSimulator.rect().center(),
Qt.CopyAction | Qt.MoveAction, mimedata,
Qt.LeftButton, Qt.NoModifier)
drop_event.acceptProposedAction()
sim_frame.ui.gvSimulator.dropEvent(drop_event)
class TestSimulator(QtTestCase):
def setUp(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.complex"))
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()
SettingsProxy.OVERWRITE_RECEIVE_BUFFER_SIZE = 100 * 10**6
self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(
raw_mode=True)
def test_performance(self):
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.001,
5,
1,
NetworkSDRInterfacePlugin.NETWORK_SDR_NAME,
BackendHandler(),
network_raw_mode=True,
real_time=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)
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,
100000,
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,
100000,
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 = 113600
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(1)
# spy = QSignalSpy(self.network_sdr_plugin_receiver.rcv_index_changed)
simulator.start()
modulator = Modulator("test_modulator")
modulator.samples_per_bit = 100
modulator.carrier_freq_hz = 55e3
modulator.modulate(msg_a.encoded_bits)
# yappi.start()
self.network_sdr_plugin_sender.send_raw_data(
modulator.modulated_samples, 1)
QTest.qWait(100)
receive_process.join(10)
print("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 __get_free_port(self):
import socket
s = socket.socket()
s.bind(("", 0))
port = s.getsockname()[1]
s.close()
return port
class TestSimulatorPerfomance(QtTestCase):
def setUp(self):
super().setUp()
self.num_zeros_for_pause = 1000
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()
class TestAnalysisTabGUI(unittest.TestCase):
def setUp(self):
constants.SETTINGS.setValue(
"not_show_close_dialog",
True) # prevent interactive close questions
self.form = MainController()
self.cfc = self.form.compare_frame_controller
self.form.add_signalfile(
get_path_for_data_file("two_participants.complex"))
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.signal.noise_threshold = 0.0175
self.signal.qad_center = 0
self.signal.bit_len = 100
self.signal.tolerance = 5
def test_analyze_button_fsk(self):
self.form.add_signalfile(get_path_for_data_file("fsk.complex"))
self.cfc.ui.btnAnalyze.click()
self.assertTrue(True)
def test_analyze_button_enocean(self):
self.form.add_signalfile(get_path_for_data_file("enocean.complex"))
w = self.form.signal_tab_controller.signal_frames[
1].ui.spinBoxCenterOffset
w.setValue(0)
QTest.keyClick(w, Qt.Key_Enter)
w = self.form.signal_tab_controller.signal_frames[
1].ui.spinBoxNoiseTreshold
w.setValue(0.0111)
QTest.keyClick(w, Qt.Key_Enter)
self.cfc.ui.btnAnalyze.click()
self.assertTrue(True)
def test_table_selection(self):
self.form.ui.tabWidget.setCurrentIndex(1)
self.cfc.ui.cbProtoView.setCurrentIndex(0)
self.cfc.ui.btnAnalyze.click()
self.cfc.ui.tblViewProtocol.selectRow(1)
app.processEvents()
self.assertEqual(self.cfc.ui.lBitsSelection.text(),
self.cfc.proto_analyzer.messages[1].plain_bits_str)
self.cfc.ui.tblViewProtocol.clearSelection()
app.processEvents()
self.assertEqual("", self.cfc.ui.lBitsSelection.text())
self.cfc.ui.tblViewProtocol.select(0, 0, 0, 3)
app.processEvents()
self.assertEqual("1010", self.cfc.ui.lBitsSelection.text())
self.cfc.ui.cbProtoView.setCurrentIndex(1)
min_row, max_row, start, end = self.cfc.ui.tblViewProtocol.selection_range(
)
self.assertEqual(min_row, 0)
self.assertEqual(max_row, 0)
self.assertEqual(start, 0)
self.assertEqual(end, 1)
def test_search(self):
search_str = "100110001"
self.cfc.ui.cbProtoView.setCurrentIndex(0)
self.cfc.ui.tblViewProtocol.clearSelection()
self.cfc.ui.lineEditSearch.setText(search_str)
self.cfc.ui.btnSearchSelectFilter.click()
selected_now = self.cfc.ui.tblViewProtocol.selectedIndexes()
self.assertEqual(len(self.cfc.ui.tblViewProtocol.selectedIndexes()),
len(search_str))
self.cfc.ui.btnNextSearch.click()
self.assertNotEqual(selected_now,
self.cfc.ui.tblViewProtocol.selectedIndexes())
self.cfc.ui.btnPrevSearch.click()
self.assertEqual(selected_now,
self.cfc.ui.tblViewProtocol.selectedIndexes())
self.cfc.select_action.trigger()
self.assertEqual(self.cfc.ui.btnSearchSelectFilter.text(),
"Select all")
self.cfc.ui.btnSearchSelectFilter.click()
self.assertGreater(len(self.cfc.ui.tblViewProtocol.selectedIndexes()),
len(selected_now))
self.cfc.filter_action.trigger()
self.assertEqual(self.cfc.ui.btnSearchSelectFilter.text(), "Filter")
self.cfc.ui.btnSearchSelectFilter.click()
hidden_rows = [
i for i in range(self.cfc.protocol_model.row_count)
if self.cfc.ui.tblViewProtocol.isRowHidden(i)
]
self.assertEqual(hidden_rows, [0, 5, 6, 10, 13, 14, 16, 17])
def test_show_diff(self):
hidden_columns_before = [
i for i in range(self.cfc.protocol_model.col_count)
if self.cfc.ui.tblViewProtocol.isColumnHidden(i)
]
self.assertEqual(len(hidden_columns_before), 0)
self.cfc.ui.chkBoxShowOnlyDiffs.click()
self.assertTrue(self.cfc.ui.cbShowDiffs.isChecked())
hidden_columns_now = [
i for i in range(self.cfc.protocol_model.col_count)
if self.cfc.ui.tblViewProtocol.isColumnHidden(i)
]
self.assertNotEqual(hidden_columns_before, hidden_columns_now)
self.cfc.ui.chkBoxOnlyShowLabelsInProtocol.click()
hidden_columns_now = [
i for i in range(self.cfc.protocol_model.col_count)
if self.cfc.ui.tblViewProtocol.isColumnHidden(i)
]
self.assertEqual(len(hidden_columns_now),
self.cfc.protocol_model.col_count)
def test_add_message_type(self):
self.assertEqual(len(self.cfc.proto_analyzer.message_types), 1)
self.cfc.ui.btnAddMessagetype.click()
self.assertEqual(len(self.cfc.proto_analyzer.message_types), 2)
def test_create_context_menu(self):
# Add protocol label should be disabled if table is empty
self.form.close_all()
self.assertEqual(self.cfc.protocol_model.rowCount(), 0)
self.cfc.ui.tblViewProtocol.context_menu_pos = QPoint(0, 0)
menu = self.cfc.ui.tblViewProtocol.create_context_menu()
create_label_action = next(a for a in menu.actions()
if a.text() == "Add protocol label")
self.assertFalse(create_label_action.isEnabled())
def test_show_in_interpretation(self):
self.form.ui.tabWidget.setCurrentIndex(1)
self.assertEqual(self.form.ui.tabWidget.currentIndex(), 1)
self.cfc.ui.cbProtoView.setCurrentIndex(0)
self.cfc.ui.tblViewProtocol.selectRow(1)
min_row, max_row, start, end = self.cfc.ui.tblViewProtocol.selection_range(
)
self.cfc.ui.tblViewProtocol.show_interpretation_clicked.emit(
min_row, max_row, start, end - 1)
self.assertEqual(self.form.ui.tabWidget.currentIndex(), 0)
