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)
def setUp(self):
self.form = MainController()
if self.SHOW:
self.form.show()
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 TestProtocolLabelDialog(unittest.TestCase):
def setUp(self):
constants.SETTINGS.setValue("align_labels", 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_protocol_file(get_path_for_data_file("protocol.proto"))
logger.debug("added signal")
tests.utils_testing.short_wait()
self.cframe = self.form.compare_frame_controller
self.cframe.add_protocol_label(
9, 19, 0, 0, edit_label_name=False) # equals 10-20 in view
self.cframe.add_protocol_label(
39, 54, 1, 0, edit_label_name=False) # equals 40-55 in view
self.assertEqual(len(self.cframe.proto_analyzer.protocol_labels), 2)
self.dialog = ProtocolLabelController(
preselected_index=1,
message=self.cframe.proto_analyzer.messages[0],
viewtype=0,
parent=self.cframe)
def tearDown(self):
self.dialog.close()
self.dialog.setParent(None)
self.dialog.deleteLater()
tests.utils_testing.short_wait()
self.form.close()
self.form.setParent(None)
self.form.deleteLater()
tests.utils_testing.short_wait()
def test_protocol_label_dialog(self):
self.assertIn(self.cframe.proto_analyzer.default_message_type.name,
self.dialog.windowTitle())
table_model = self.dialog.ui.tblViewProtoLabels.model()
self.assertEqual(table_model.rowCount(), 2)
label = table_model.message_type[0]
table_model.setData(table_model.index(0, 0), "testname")
self.assertEqual(label.name, "testname")
table_model.setData(table_model.index(0, 1), 15)
self.assertEqual(label.start, 15 - 1)
table_model.setData(table_model.index(0, 2), 30)
self.assertEqual(label.end, 30)
table_model.setData(table_model.index(0, 3), 4)
self.assertEqual(label.color_index, 4)
table_model.setData(table_model.index(0, 4), False)
self.assertEqual(label.apply_decoding, False)
def test_change_view_type(self):
table_model = self.dialog.ui.tblViewProtoLabels.model()
# Bit View
self.assertEqual(table_model.data(table_model.index(0, 1)), 10)
self.assertEqual(table_model.data(table_model.index(0, 2)), 20)
self.assertEqual(table_model.data(table_model.index(1, 1)), 40)
self.assertEqual(table_model.data(table_model.index(1, 2)), 55)
self.dialog.ui.cbProtoView.setCurrentIndex(1)
self.assertEqual(table_model.data(table_model.index(0, 1)), 4)
self.assertEqual(table_model.data(table_model.index(0, 2)), 6)
self.assertEqual(table_model.data(table_model.index(1, 1)), 12)
self.assertEqual(table_model.data(table_model.index(1, 2)), 15)
label = table_model.message_type[0]
table_model.setData(table_model.index(0, 1), 2)
table_model.setData(table_model.index(0, 2), 5)
self.assertEqual(label.start, 4)
self.assertEqual(label.end, 17)
def setUp(self):
self.form = MainController()
self.dialog = OptionsController(
self.form.plugin_manager.installed_plugins, parent=self.form)
def main():
if sys.version_info < (3, 4):
print("You need at least Python 3.4 for this application!")
sys.exit(1)
if sys.platform == "win32":
urh_dir = os.path.dirname(os.path.realpath(__file__)) if not os.path.islink(__file__) \
else os.path.dirname(os.path.realpath(os.readlink(__file__)))
assert os.path.isdir(urh_dir)
dll_dir = os.path.realpath(
os.path.join(urh_dir, "dev", "native", "lib", "win"))
print("Using DLLs from:", dll_dir)
os.environ['PATH'] = dll_dir + ';' + os.environ['PATH']
t = time.time()
if GENERATE_UI and not hasattr(sys, 'frozen'):
try:
urh_dir = os.path.abspath(
os.path.join(os.path.dirname(sys.argv[0]), "..", ".."))
sys.path.append(urh_dir)
sys.path.append(os.path.join(urh_dir, "src"))
import generate_ui
generate_ui.gen()
print("Time for generating UI: %.2f seconds" % (time.time() - t))
except (ImportError, FileNotFoundError):
print(
"Will not regenerate UI, because script cant be found. This is okay in release."
)
urh_exe = sys.executable if hasattr(sys, 'frozen') else sys.argv[0]
urh_exe = os.readlink(urh_exe) if os.path.islink(urh_exe) else urh_exe
urh_dir = os.path.join(os.path.dirname(urh_exe), "..", "..")
prefix = os.path.abspath(os.path.normpath(urh_dir))
src_dir = os.path.join(prefix, "src")
if os.path.exists(src_dir) and not prefix.startswith("/usr") \
and not re.match(r"(?i)c:\\program", prefix):
# Started locally, not installed
print("Using modules from {0}".format(src_dir))
sys.path.insert(0, src_dir)
try:
import urh.cythonext.signalFunctions
import urh.cythonext.path_creator
import urh.cythonext.util
except ImportError:
print("Could not find C++ extensions, trying to build them.")
old_dir = os.curdir
os.chdir(os.path.join(src_dir, "urh", "cythonext"))
from urh.cythonext import build
build.main()
os.chdir(old_dir)
from urh.controller.MainController import MainController
from urh import constants
if constants.SETTINGS.value("use_fallback_theme", False, bool):
os.environ['QT_QPA_PLATFORMTHEME'] = 'fusion'
app = QApplication(sys.argv)
app.setWindowIcon(QIcon(":/icons/data/icons/appicon.png"))
# noinspection PyUnresolvedReferences
import urh.ui.xtra_icons_rc # Use oxy theme always
QIcon.setThemeName("oxy")
constants.SETTINGS.setValue("default_theme", app.style().objectName())
if constants.SETTINGS.value("use_fallback_theme", False, bool):
app.setStyle(QStyleFactory.create("Fusion"))
main_window = MainController()
if sys.platform == "darwin":
menu_bar = main_window.menuBar()
menu_bar.setNativeMenuBar(False)
import multiprocessing as mp
mp.set_start_method(
"spawn") # prevent errors with forking in native RTL-SDR backend
main_window.showMaximized()
# main_window.setFixedSize(1920, 1080 - 30) # Youtube
# use system colors for painting
widget = QWidget()
bgcolor = widget.palette().color(QPalette.Background)
fgcolor = widget.palette().color(QPalette.Foreground)
selection_color = widget.palette().color(QPalette.Highlight)
constants.BGCOLOR = bgcolor
constants.LINECOLOR = fgcolor
constants.SELECTION_COLOR = selection_color
constants.SEND_INDICATOR_COLOR = selection_color
if "autoclose" in sys.argv[1:]:
# Autoclose after 1 second, this is useful for automated testing
timer = QTimer()
timer.timeout.connect(app.quit)
timer.start(1000)
os._exit(app.exec_(
)) # sys.exit() is not enough on Windows and will result in crash on exit
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
logger.debug("Init form")
self.form = MainController()
logger.debug("Intiliazed form")
app.processEvents()
logger.debug("Add signal")
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
logger.debug("Added signal")
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 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(1000)
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(1000)
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(1000)
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(1000)
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)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
sock.connect(("127.0.0.1", port))
return sock
def close_socket(sock):
sock.shutdown(socket.SHUT_RDWR)
sock.close()
if __name__ == '__main__':
app = QApplication(["test"])
main = MainController()
port = util.get_free_port()
dialog = SpectrumDialogController(ProjectManager(main))
dialog.showMaximized()
dialog.ui.cbDevice.setCurrentText("Network SDR")
dialog.device.set_server_port(port)
dialog.ui.btnStart.click()
p = Process(target=send_data, args=(port, ))
p.daemon = True
p.start()
num_samples = 32768
frequency = 0.1
divisor = 200
pos = 0
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 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 TestAnalysisTabGUI(unittest.TestCase):
def setUp(self):
self.form = MainController()
app.processEvents()
QTest.qWait(25)
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)
app.processEvents()
QTest.qWait(10)
self.form.ui.tabWidget.setCurrentIndex(1)
app.processEvents()
QTest.qWait(10)
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)
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 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
def setUp(self):
ProtocolSniffer.BUFFER_SIZE_MB = 0.5
self.form = MainController()
if self.SHOW:
self.form.show()
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
def setUp(self):
ProtocolSniffer.BUFFER_SIZE_MB = 0.5
self.form = MainController()
if self.SHOW:
self.form.show()
class TestModulatorGUI(unittest.TestCase):
def setUp(self):
logger.debug("Init Form")
self.form = MainController()
logger.debug("Add Signal")
app.processEvents()
QTest.qWait(10)
self.form.add_signalfile(get_path_for_data_file("esaver.complex"))
logger.debug("Added Signal")
app.processEvents()
self.signal = self.form.signal_tab_controller.signal_frames[0].signal
self.gframe = self.form.generator_tab_controller
self.form.ui.tabWidget.setCurrentIndex(2)
app.processEvents()
QTest.qWait(10)
logger.debug("Create modulation dialog")
self.dialog, _ = self.gframe.prepare_modulation_dialog()
self.gframe.initialize_modulation_dialog("1111", self.dialog)
def tearDown(self):
self.dialog.close()
self.dialog.setParent(None)
app.processEvents()
QTest.qWait(10)
self.form.close()
self.form.setParent(None)
app.processEvents()
QTest.qWait(50)
app.processEvents()
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):
#self.dialog.show() # if on KDE
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())
tree_view.selectAll()
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")
def on_btn_refresh_device_identifier_clicked(self):
if self.device is None:
return
self.ui.comboBoxDeviceIdentifier.clear()
self.ui.comboBoxDeviceIdentifier.addItems(
self.device.get_device_list())
@pyqtSlot(bool)
def on_check_box_dc_correction_clicked(self, checked: bool):
self.device.apply_dc_correction = bool(checked)
@pyqtSlot()
def on_combo_box_device_identifier_current_index_changed(self):
if self.device is not None:
self.device.device_serial = self.ui.comboBoxDeviceIdentifier.currentText(
)
self.device.device_number = self.ui.comboBoxDeviceIdentifier.currentIndex(
)
if __name__ == '__main__':
from PyQt5.QtWidgets import QApplication
from urh.controller.MainController import MainController
app = QApplication([])
mc = MainController()
widget = DeviceSettingsWidget(mc.project_manager, is_tx=False)
widget.show()
app.exec_()
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 tearDown(self):
if hasattr(self, "dialog"):
self.dialog.close()
if hasattr(self, "form"):
self.form.close_all()
self.form.close()
sip.delete(self.form)
self.form = None
QTest.qSleep(1)
QTest.qWait(self.CLOSE_TIMEOUT)
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 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()
app.processEvents()
QTest.qWait(300)
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, 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)
app.processEvents()
QTest.qWait(100)
self.form.ui.tabWidget.setCurrentIndex(1)
app.processEvents()
QTest.qWait(100)
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 setUp(self):
self.form = MainController()
if self.SHOW:
self.form.show()
class TestProjectManager(unittest.TestCase):
def setUp(self):
logger.debug("Init form")
tests.utils_testing.short_wait()
self.form = MainController()
logger.debug("Initialized form")
tests.utils_testing.short_wait()
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
def tearDown(self):
self.form.close()
self.form.setParent(None)
self.form.deleteLater()
tests.utils_testing.short_wait()
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()
tests.utils_testing.short_wait()
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
tests.utils_testing.short_wait()
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
tests.utils_testing.short_wait()
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()
tests.utils_testing.short_wait()
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."
dialog = ProjectDialogController(
project_manager=self.form.project_manager, parent=self.form)
dialog.ui.spinBoxFreq.setValue(frequency)
self.assertEqual(dialog.freq, frequency)
dialog.ui.spinBoxSampleRate.setValue(sample_rate)
self.assertEqual(dialog.sample_rate, sample_rate)
dialog.ui.spinBoxBandwidth.setValue(bandwidth)
self.assertEqual(dialog.bandwidth, bandwidth)
dialog.ui.spinBoxGain.setValue(gain)
self.assertEqual(dialog.gain, gain)
dialog.ui.txtEdDescription.setPlainText(descr)
self.assertEqual(dialog.description, descr)
dialog.ui.lineEditBroadcastAddress.setText("abcd")
dialog.ui.lineEditBroadcastAddress.textEdited.emit("abcd")
self.assertEqual(dialog.broadcast_address_hex, "abcd")
if len(dialog.participants) == 0:
dialog.ui.btnAddParticipant.click()
self.assertEqual(len(dialog.participants), 1)
model = 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 = 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(dialog.participants)
dialog.ui.btnAddParticipant.click()
dialog.ui.btnAddParticipant.click()
dialog.ui.btnAddParticipant.click()
self.assertEqual(len(dialog.participants), num_participants + 3)
dialog.ui.btnRemoveParticipant.click()
dialog.ui.btnRemoveParticipant.click()
dialog.ui.btnRemoveParticipant.click()
self.assertEqual(len(dialog.participants), num_participants)
test_path = os.path.join(QDir.tempPath(), "urh_test")
dialog.ui.lineEdit_Path.setText(test_path)
dialog.ui.lineEdit_Path.textEdited.emit(test_path)
self.assertEqual(dialog.path, test_path)
dialog.ui.btnOK.click()
self.assertTrue(os.path.isdir(test_path))
self.form.project_manager.from_dialog(dialog)
dialog = ProjectDialogController(
project_manager=self.form.project_manager,
parent=self.form,
new_project=False)
self.assertEqual(dialog.ui.spinBoxFreq.value(), frequency)
self.assertEqual(dialog.ui.spinBoxSampleRate.value(), sample_rate)
self.assertEqual(dialog.ui.spinBoxBandwidth.value(), bandwidth)
self.assertEqual(dialog.ui.spinBoxGain.value(), gain)
self.assertEqual(dialog.ui.txtEdDescription.toPlainText(), descr)
self.assertFalse(dialog.ui.lineEdit_Path.isEnabled())
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.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
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 = util.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 = util.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)
def setUp(self):
constants.SETTINGS.setValue(
"not_show_close_dialog",
True) # prevent interactive close questions
self.form = MainController()
def main():
fix_windows_stdout_stderr()
if sys.version_info < (3, 4):
print("You need at least Python 3.4 for this application!")
sys.exit(1)
urh_exe = sys.executable if hasattr(sys, 'frozen') else sys.argv[0]
urh_exe = os.readlink(urh_exe) if os.path.islink(urh_exe) else urh_exe
urh_dir = os.path.join(os.path.dirname(os.path.realpath(urh_exe)), "..", "..")
prefix = os.path.abspath(os.path.normpath(urh_dir))
src_dir = os.path.join(prefix, "src")
if os.path.exists(src_dir) and not prefix.startswith("/usr") and not re.match(r"(?i)c:\\program", prefix):
# Started locally, not installed -> add directory to path
sys.path.insert(0, src_dir)
if len(sys.argv) > 1 and sys.argv[1] == "--version":
import urh.version
print(urh.version.VERSION)
sys.exit(0)
if GENERATE_UI and not hasattr(sys, 'frozen'):
try:
sys.path.insert(0, os.path.join(prefix))
from data import generate_ui
generate_ui.gen()
except (ImportError, FileNotFoundError):
print("Will not regenerate UI, because script can't be found. This is okay in release.")
from urh.util import util
util.set_shared_library_path()
try:
import urh.cythonext.signalFunctions
import urh.cythonext.path_creator
import urh.cythonext.util
except ImportError:
if hasattr(sys, "frozen"):
print("C++ Extensions not found. Exiting...")
sys.exit(1)
print("Could not find C++ extensions, trying to build them.")
old_dir = os.path.realpath(os.curdir)
os.chdir(os.path.join(src_dir, "urh", "cythonext"))
from urh.cythonext import build
build.main()
os.chdir(old_dir)
from urh.controller.MainController import MainController
from urh import constants
if constants.SETTINGS.value("theme_index", 0, int) > 0:
os.environ['QT_QPA_PLATFORMTHEME'] = 'fusion'
app = QApplication(["URH"] + sys.argv[1:])
app.setWindowIcon(QIcon(":/icons/icons/appicon.png"))
util.set_icon_theme()
constants.SETTINGS.setValue("default_theme", app.style().objectName())
if constants.SETTINGS.value("theme_index", 0, int) > 0:
app.setStyle(QStyleFactory.create("Fusion"))
if constants.SETTINGS.value("theme_index", 0, int) == 2:
palette = QPalette()
background_color = QColor(56, 60, 74)
text_color = QColor(211, 218, 227).lighter()
palette.setColor(QPalette.Window, background_color)
palette.setColor(QPalette.WindowText, text_color)
palette.setColor(QPalette.Base, background_color)
palette.setColor(QPalette.AlternateBase, background_color)
palette.setColor(QPalette.ToolTipBase, background_color)
palette.setColor(QPalette.ToolTipText, text_color)
palette.setColor(QPalette.Text, text_color)
palette.setColor(QPalette.Button, background_color)
palette.setColor(QPalette.ButtonText, text_color)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Disabled, QPalette.Text, Qt.darkGray)
palette.setColor(QPalette.Disabled, QPalette.ButtonText, Qt.darkGray)
palette.setColor(QPalette.Highlight, QColor(200, 50, 0))
palette.setColor(QPalette.HighlightedText, text_color)
app.setPalette(palette)
# use system colors for painting
widget = QWidget()
bg_color = widget.palette().color(QPalette.Background)
fg_color = widget.palette().color(QPalette.Foreground)
selection_color = widget.palette().color(QPalette.Highlight)
constants.BGCOLOR = bg_color
constants.LINECOLOR = fg_color
constants.SELECTION_COLOR = selection_color
constants.SEND_INDICATOR_COLOR = selection_color
main_window = MainController()
import multiprocessing as mp
# allow usage of prange (OpenMP) in Processes
mp.set_start_method("spawn")
if sys.platform == "darwin":
menu_bar = main_window.menuBar()
menu_bar.setNativeMenuBar(False)
elif sys.platform == "win32":
# Ensure we get the app icon in windows taskbar
import ctypes
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("jopohl.urh")
import multiprocessing as mp
mp.freeze_support()
main_window.showMaximized()
# main_window.setFixedSize(1920, 1080 - 30) # Youtube
if "autoclose" in sys.argv[1:]:
# Autoclose after 1 second, this is useful for automated testing
timer = QTimer()
timer.timeout.connect(app.quit)
timer.start(1000)
return_code = app.exec_()
app.closeAllWindows()
os._exit(return_code) # sys.exit() is not enough on Windows and will result in crash on exit
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(10)
self.form = MainController()
self.form.add_signalfile("./data/steckdose_anlernen.complex")
QTest.qWait(10)
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()
QTest.qWait(10)
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
QTest.qWait(10)
decoding = encoding([
"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
QTest.qWait(10)
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(206,
225,
0,
0,
False,
edit_label_name=False)
self.assertEqual(
int(self.cframe.groups[0].labels[0].reference_bits, 2), 91412)
# Zeros: Bits 227-244 (18 Bits)
self.cframe.add_protocol_label(226,
243,
0,
0,
False,
edit_label_name=False)
self.assertEqual(
int(self.cframe.groups[0].labels[1].reference_bits, 2), 0)
# Serial Part 2: Bit 245 - 264 (Dezimal: 1034678) (20 Bits)
self.cframe.add_protocol_label(244,
263,
0,
0,
False,
edit_label_name=False)
self.assertEqual(
int(self.cframe.groups[0].labels[2].reference_bits, 2), 1034678)
QTest.qWait(10)
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))
QTest.qWait(10)
self.assertEqual(self.gframe.table_model.row_count, 1)
self.assertEqual(len(self.gframe.table_model.protocol.protocol_labels),
3)
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 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
def main():
if sys.version_info < (3, 4):
print("You need at least Python 3.4 for this application!")
sys.exit(1)
t = time.time()
if GENERATE_UI and not hasattr(sys, 'frozen'):
try:
urh_dir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), "..", ".."))
sys.path.append(urh_dir)
sys.path.append(os.path.join(urh_dir, "src"))
import generate_ui
generate_ui.gen()
print("Time for generating UI: %.2f seconds" % (time.time() - t))
except (ImportError, FileNotFoundError):
print("Will not regenerate UI, because script can't be found. This is okay in release.")
urh_exe = sys.executable if hasattr(sys, 'frozen') else sys.argv[0]
urh_exe = os.readlink(urh_exe) if os.path.islink(urh_exe) else urh_exe
urh_dir = os.path.join(os.path.dirname(os.path.realpath(urh_exe)), "..", "..")
prefix = os.path.abspath(os.path.normpath(urh_dir))
src_dir = os.path.join(prefix, "src")
if os.path.exists(src_dir) and not prefix.startswith("/usr") and not re.match(r"(?i)c:\\program", prefix):
# Started locally, not installed
print("Adding {0} to pythonpath. This is only important when running URH from source.".format(src_dir))
sys.path.insert(0, src_dir)
from urh.util import util
util.set_windows_lib_path()
try:
import urh.cythonext.signalFunctions
import urh.cythonext.path_creator
import urh.cythonext.util
except ImportError:
print("Could not find C++ extensions, trying to build them.")
old_dir = os.curdir
os.chdir(os.path.join(src_dir, "urh", "cythonext"))
from urh.cythonext import build
build.main()
os.chdir(old_dir)
from urh.controller.MainController import MainController
from urh import constants
if constants.SETTINGS.value("theme_index", 0, int) > 0:
os.environ['QT_QPA_PLATFORMTHEME'] = 'fusion'
app = QApplication(["URH"] + sys.argv[1:])
app.setWindowIcon(QIcon(":/icons/data/icons/appicon.png"))
if sys.platform != "linux":
# noinspection PyUnresolvedReferences
import urh.ui.xtra_icons_rc
QIcon.setThemeName("oxy")
constants.SETTINGS.setValue("default_theme", app.style().objectName())
if constants.SETTINGS.value("theme_index", 0, int) > 0:
app.setStyle(QStyleFactory.create("Fusion"))
if constants.SETTINGS.value("theme_index", 0, int) == 2:
palette = QPalette()
background_color = QColor(56, 60, 74)
text_color = QColor(211, 218, 227).lighter()
palette.setColor(QPalette.Window, background_color)
palette.setColor(QPalette.WindowText, text_color)
palette.setColor(QPalette.Base, background_color)
palette.setColor(QPalette.AlternateBase, background_color)
palette.setColor(QPalette.ToolTipBase, background_color)
palette.setColor(QPalette.ToolTipText, text_color)
palette.setColor(QPalette.Text, text_color)
palette.setColor(QPalette.Button, background_color)
palette.setColor(QPalette.ButtonText, text_color)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Disabled, QPalette.Text, Qt.darkGray)
palette.setColor(QPalette.Disabled, QPalette.ButtonText, Qt.darkGray)
palette.setColor(QPalette.Highlight, QColor(200, 50, 0))
palette.setColor(QPalette.HighlightedText, text_color)
app.setPalette(palette)
main_window = MainController()
if sys.platform == "darwin":
menu_bar = main_window.menuBar()
menu_bar.setNativeMenuBar(False)
import multiprocessing as mp
mp.set_start_method("spawn") # prevent errors with forking in native RTL-SDR backend
elif sys.platform == "win32":
# Ensure we get the app icon in windows taskbar
import ctypes
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("jopohl.urh")
main_window.showMaximized()
# main_window.setFixedSize(1920, 1080 - 30) # Youtube
# use system colors for painting
widget = QWidget()
bgcolor = widget.palette().color(QPalette.Background)
fgcolor = widget.palette().color(QPalette.Foreground)
selection_color = widget.palette().color(QPalette.Highlight)
constants.BGCOLOR = bgcolor
constants.LINECOLOR = fgcolor
constants.SELECTION_COLOR = selection_color
constants.SEND_INDICATOR_COLOR = selection_color
if "autoclose" in sys.argv[1:]:
# Autoclose after 1 second, this is useful for automated testing
timer = QTimer()
timer.timeout.connect(app.quit)
timer.start(1000)
return_code = app.exec_()
app.closeAllWindows()
os._exit(return_code) # sys.exit() is not enough on Windows and will result in crash on exit
def main():
fix_windows_stdout_stderr()
if sys.version_info < (3, 4):
print("You need at least Python 3.4 for this application!")
sys.exit(1)
urh_exe = sys.executable if hasattr(sys, 'frozen') else sys.argv[0]
urh_exe = os.readlink(urh_exe) if os.path.islink(urh_exe) else urh_exe
urh_dir = os.path.join(os.path.dirname(os.path.realpath(urh_exe)), "..", "..")
prefix = os.path.abspath(os.path.normpath(urh_dir))
src_dir = os.path.join(prefix, "src")
if os.path.exists(src_dir) and not prefix.startswith("/usr") and not re.match(r"(?i)c:\\program", prefix):
# Started locally, not installed -> add directory to path
sys.path.insert(0, src_dir)
if len(sys.argv) > 1 and sys.argv[1] == "--version":
import urh.version
print(urh.version.VERSION)
sys.exit(0)
if GENERATE_UI and not hasattr(sys, 'frozen'):
try:
sys.path.insert(0, os.path.join(prefix))
from data import generate_ui
generate_ui.gen()
except (ImportError, FileNotFoundError):
# The generate UI script cannot be found so we are most likely in release mode, no problem here.
pass
from urh.util import util
util.set_shared_library_path()
try:
import urh.cythonext.signal_functions
import urh.cythonext.path_creator
import urh.cythonext.util
except ImportError:
if hasattr(sys, "frozen"):
print("C++ Extensions not found. Exiting...")
sys.exit(1)
print("Could not find C++ extensions, trying to build them.")
old_dir = os.path.realpath(os.curdir)
os.chdir(os.path.join(src_dir, "urh", "cythonext"))
from urh.cythonext import build
build.main()
os.chdir(old_dir)
from urh.controller.MainController import MainController
from urh import constants
if constants.SETTINGS.value("theme_index", 0, int) > 0:
os.environ['QT_QPA_PLATFORMTHEME'] = 'fusion'
app = QApplication(["URH"] + sys.argv[1:])
app.setWindowIcon(QIcon(":/icons/icons/appicon.png"))
util.set_icon_theme()
font_size = constants.SETTINGS.value("font_size", 0, int)
if font_size > 0:
font = app.font()
font.setPointSize(font_size)
app.setFont(font)
constants.SETTINGS.setValue("default_theme", app.style().objectName())
if constants.SETTINGS.value("theme_index", 0, int) > 0:
app.setStyle(QStyleFactory.create("Fusion"))
if constants.SETTINGS.value("theme_index", 0, int) == 2:
palette = QPalette()
background_color = QColor(56, 60, 74)
text_color = QColor(211, 218, 227).lighter()
palette.setColor(QPalette.Window, background_color)
palette.setColor(QPalette.WindowText, text_color)
palette.setColor(QPalette.Base, background_color)
palette.setColor(QPalette.AlternateBase, background_color)
palette.setColor(QPalette.ToolTipBase, background_color)
palette.setColor(QPalette.ToolTipText, text_color)
palette.setColor(QPalette.Text, text_color)
palette.setColor(QPalette.Button, background_color)
palette.setColor(QPalette.ButtonText, text_color)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Disabled, QPalette.Text, Qt.darkGray)
palette.setColor(QPalette.Disabled, QPalette.ButtonText, Qt.darkGray)
palette.setColor(QPalette.Highlight, QColor(200, 50, 0))
palette.setColor(QPalette.HighlightedText, text_color)
app.setPalette(palette)
# use system colors for painting
widget = QWidget()
bg_color = widget.palette().color(QPalette.Background)
fg_color = widget.palette().color(QPalette.Foreground)
selection_color = widget.palette().color(QPalette.Highlight)
constants.BGCOLOR = bg_color
constants.LINECOLOR = fg_color
constants.SELECTION_COLOR = selection_color
constants.SEND_INDICATOR_COLOR = selection_color
main_window = MainController()
# allow usage of prange (OpenMP) in Processes
multiprocessing.set_start_method("spawn")
if sys.platform == "darwin":
menu_bar = main_window.menuBar()
menu_bar.setNativeMenuBar(False)
elif sys.platform == "win32":
# Ensure we get the app icon in windows taskbar
import ctypes
ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("jopohl.urh")
main_window.showMaximized()
# main_window.setFixedSize(1920, 1080 - 30) # Youtube
if "autoclose" in sys.argv[1:]:
# Autoclose after 1 second, this is useful for automated testing
timer = QTimer()
timer.timeout.connect(app.quit)
timer.start(1000)
return_code = app.exec_()
app.closeAllWindows()
os._exit(return_code) # sys.exit() is not enough on Windows and will result in crash on exit
