def wait_for_variable(self, var, timeout=10, cmp_var=None):
for _ in range(0, timeout * 1000, 100):
QTest.qWait(100)
if self.get_attr_recursive(var) is not cmp_var:
return
raise TimeoutException("Variable %s within 10 seconds" % var)
def test_spectrum(self):
port = self.__get_free_port()
spectrum_dialog = self.__get_spectrum_dialog()
spectrum_dialog.device.set_server_port(port)
spectrum_dialog.ui.btnStart.click()
self.assertEqual(len(spectrum_dialog.scene_manager.peak), 0)
data = np.array([complex(1, 1), complex(2, 2), complex(3, 3)], dtype=np.complex64)
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect(("127.0.0.1", port))
sock.sendall(data.tostring())
sock.shutdown(socket.SHUT_RDWR)
sock.close()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertGreater(len(spectrum_dialog.scene_manager.peak), 0)
spectrum_dialog.ui.btnStop.click()
self.__close_dialog(spectrum_dialog)
def wait_for_settings(self, timeout=10):
for _ in range(0, timeout * 1000, 100):
QTest.qWait(100)
if window.tribler_settings is not None:
return
raise TimeoutException("Did not receive settings within 10 seconds")
def test_receive(self):
port = self.__get_free_port()
receive_dialog = self.__get_recv_dialog()
receive_dialog.device.set_server_port(port)
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.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.connect(("127.0.0.1", port))
sock.sendall(data.tostring())
sock.shutdown(socket.SHUT_RDWR)
sock.close()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertEqual(receive_dialog.device.current_index, 3)
self.assertTrue(np.array_equal(receive_dialog.device.data[:3], data))
receive_dialog.ui.btnStop.click()
receive_dialog.ui.btnClear.click()
self.assertEqual(receive_dialog.device.current_index, 0)
self.__close_dialog(receive_dialog)
def test_send(self):
port = self.__get_free_port()
receive_dialog = self.__get_recv_dialog()
receive_dialog.device.set_server_port(port)
receive_dialog.ui.btnStart.click()
send_dialog = self.__get_send_dialog()
send_dialog.device.set_client_port(port)
send_dialog.ui.spinBoxNRepeat.setValue(2)
send_dialog.ui.btnStart.click()
QApplication.instance().processEvents()
QTest.qWait(self.SEND_RECV_TIMEOUT)
self.assertEqual(receive_dialog.device.current_index, 2 * self.signal.num_samples)
self.assertTrue(np.array_equal(receive_dialog.device.data[:receive_dialog.device.current_index // 2],
self.signal.data))
self.assertEqual(send_dialog.send_indicator.rect().width(), self.signal.num_samples)
self.assertFalse(send_dialog.ui.btnClear.isEnabled())
send_dialog.on_clear_clicked()
self.assertEqual(send_dialog.send_indicator.rect().width(), 0)
send_dialog.ui.btnStop.click()
self.assertFalse(send_dialog.ui.btnStop.isEnabled())
receive_dialog.ui.btnStop.click()
self.assertFalse(receive_dialog.ui.btnStop.isEnabled())
self.__close_dialog(receive_dialog)
self.__close_dialog(send_dialog)
def test_1(self):
# replace 'foo' with 'UUH' in opened and not opened file
openedFile = self.createFile('openedFile.txt', 'the text contains foo bar\nand\nfew\nmore lines')
openedFile.qutepart.cursorPosition = (3, 2)
notOpenedFilePath = os.path.join(self.TEST_FILE_DIR, 'not_openedFile.txt')
with open(notOpenedFilePath, 'w') as file_:
file_.write('this file also contains foo bar')
self.keyClick(Qt.Key_R, Qt.ShiftModifier | Qt.ControlModifier)
self.keyClicks('foo')
self.keyClick(Qt.Key_Tab)
self.keyClicks('UUHHH')
self.keyClick(Qt.Key_Enter)
QTest.qWait(500) # searching
self.keyClick(Qt.Key_A, Qt.AltModifier)
QTest.qWait(500) # replacing
with open(notOpenedFilePath) as file_:
self.assertEqual(file_.read(), 'this file also contains UUHHH bar')
self.assertEqual(openedFile.qutepart.text, 'the text contains UUHHH bar\nand\nfew\nmore lines')
self.assertEqual(openedFile.qutepart.cursorPosition, (3, 2))
self.assertTrue(openedFile.qutepart.document().isModified())
with open(openedFile.filePath()) as file_:
self.assertEqual(file_.read(), 'the text contains foo bar\nand\nfew\nmore lines')
openedFile.saveFile()
with open(openedFile.filePath()) as file_:
self.assertEqual(file_.read(), 'the text contains UUHHH bar\nand\nfew\nmore lines\n')
def test_market_transactions_page(self):
QTest.mouseClick(window.token_balance_widget, Qt.LeftButton)
QTest.mouseClick(window.trade_button, Qt.LeftButton)
self.wait_for_signal(window.market_page.received_wallets)
QTest.mouseClick(window.market_transactions_button, Qt.LeftButton)
self.wait_for_list_populated(window.market_transactions_list)
self.screenshot(window, name="market_page_transactions")
# Click on one of the transactions to get more information
first_widget = window.market_transactions_list.topLevelItem(0)
rect = window.market_transactions_list.visualItemRect(first_widget)
QTest.mouseClick(window.market_transactions_list.viewport(), Qt.LeftButton, Qt.NoModifier, rect.center())
QTest.qWait(100)
self.screenshot(window, name="market_page_transactions_payments")
# Pretend we receive a payment
transaction = first_widget.transaction
payment = {
"trader_id": transaction['trader_id'],
"transaction_number": transaction['transaction_number'],
"transferred": {
"amount": transaction['assets']['second']['amount'],
"type": transaction['assets']['second']['type']
},
"payment_id": 'test',
"address_from": 'a',
"address_to": 'b',
"timestamp": transaction['timestamp'] + 10,
"success": True
}
window.core_manager.events_manager.market_payment_received.emit(payment)
self.screenshot(window, name="market_page_transactions_newpayment")
window.hide_status_bar()
def test_subscriptions(self):
QTest.mouseClick(window.left_menu_button_subscriptions, Qt.LeftButton)
self.screenshot(window, name="subscriptions_loading")
self.wait_for_list_populated(window.subscribed_channels_list)
self.screenshot(window, name="subscriptions")
# Sort
window.subscribed_channels_list.sortByColumn(1, 1)
self.wait_for_list_populated(window.subscribed_channels_list)
self.screenshot(window, name="subscriptions_sorted")
max_items = min(window.subscribed_channels_list.model().total_items, 50)
self.assertLessEqual(window.subscribed_channels_list.verticalHeader().count(), max_items)
# Filter
old_num_items = window.subscribed_channels_list.verticalHeader().count()
QTest.keyClick(window.subscribed_channels_filter_input, '1')
self.wait_for_list_populated(window.subscribed_channels_list)
self.screenshot(window, name="subscriptions_filtered")
self.assertLessEqual(window.subscribed_channels_list.verticalHeader().count(), old_num_items)
window.subscribed_channels_filter_input.setText('')
self.wait_for_list_populated(window.subscribed_channels_list)
# Unsubscribe and subscribe again
index = self.get_index_of_row(window.subscribed_channels_list, 0)
window.subscribed_channels_list.on_subscribe_control_clicked(index)
QTest.qWait(200)
self.screenshot(window, name="unsubscribed")
window.subscribed_channels_list.on_subscribe_control_clicked(index)
QTest.qWait(200)
def _waitFiles(self):
for _ in range(20):
QTest.qWait(5000 / 20)
if core.project().files() is not None:
break
else:
self.fail("Project not scanned")
def test_logWindowSplitter3a(self):
"""Feature 1,2,3. A combination of the above test cases.
"""
document1 = self.createFile('file1.rst', '.. file1::')
document2 = self.createFile('file2.rst', '')
document3 = self.createFile('file3.rst', '.. file3::')
self._assertHtmlReady(lambda: None)
self._assertHtmlReady(lambda: core.workspace().setCurrentDocument(document1))
# Wait for events to process. See qWait comment above.
QTest.qWait(100)
# Change splitter setting of document 1.
newSplitterSize = [125, 124]
self._widget().splitter.setSizes(newSplitterSize)
self._widget().splitter.splitterMoved.emit(newSplitterSize[0], 1)
# Assert log window and preview window are visible and are of almost
# equal size.
self.assertNotIn(0, self._widget().splitter.sizes())
self.assertAlmostEqual(self._widget().splitter.sizes()[0], self._widget().splitter.sizes()[1], delta=10)
# Switch to an error-free document, assert log window hidden.
self._assertHtmlReady(lambda: core.workspace().setCurrentDocument(document2))
# Wait for events to process. See qWait comment above.
QTest.qWait(100)
self.assertFalse(self._widget().splitter.sizes()[1])
# Switch to file3 which will cause build error, check splitter size.
self._assertHtmlReady(lambda: core.workspace().setCurrentDocument(document3))
self.assertNotIn(0, self._widget().splitter.sizes())
self.assertAlmostEqual(self._widget().splitter.sizes()[0], self._widget().splitter.sizes()[1], delta=10)
def _waitForText(self, text, replName):
for i in range(50):
if text in self._browserText(replName):
break
else:
QTest.qWait(100)
else:
self.fail("Text doesn't contain '{}'".format(text))
def wait_for_home_page_table_populated(self, timeout=10):
for _ in range(0, timeout * 1000, 100):
QTest.qWait(100)
if isinstance(window.home_page_table_view.cellWidget(0, 0), HomeRecommendedItem):
return
# List was not populated in time, fail the test
raise TimeoutException("The list was not populated within 10 seconds")
def _sleepAndCheck(self, sleep,
doc1_modified, doc1_removed,
doc2_modified, doc2_removed):
QTest.qWait(sleep * 1000)
self.assertEqual(self._doc1._externallyModified, doc1_modified)
self.assertEqual(self._doc1._externallyRemoved, doc1_removed)
self.assertEqual(self._doc2._externallyModified, doc2_modified)
self.assertEqual(self._doc2._externallyRemoved, doc2_removed)
def _waitCompletion(self, dialog):
model = dialog._table.model()
for _ in range(20):
if model.rowCount() > 1:
break
QTest.qWait(1000 / 20)
else:
self.fail("No completion")
def __build_protocol(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
result = ProtocolAnalyzer(signal=None)
for _ in range(self.NUM_MESSAGES):
b = Message([True] * self.BITS_PER_MESSAGE, pause=1000, message_type=result.default_message_type)
result.messages.append(b)
return result
def test_protocol_sniffer(self):
bit_len = 100
center = 0.0942
noise = 0.1
tolerance = 2
modulation_type = 1
sample_rate = 1e6
device_name = NetworkSDRInterfacePlugin.NETWORK_SDR_NAME
sniffer = ProtocolSniffer(bit_len=bit_len, center=center, noise=noise, tolerance=tolerance,
modulation_type=modulation_type, device=device_name, backend_handler=BackendHandler(),
network_raw_mode=True)
port = self.get_free_port()
sniffer.rcv_device.set_server_port(port)
self.network_sdr_plugin_sender = NetworkSDRInterfacePlugin(raw_mode=True)
self.network_sdr_plugin_sender.client_port = port
sniffer.sniff()
QTest.qWait(10)
data = ["101010", "000111", "1111000"]
pause = 10 * bit_len
modulator = Modulator("test")
modulator.samples_per_bit = bit_len
modulator.sample_rate = sample_rate
modulator.modulation_type = modulation_type
modulator.param_for_one = 20e3
modulator.param_for_zero = 10e3
packages = []
for d in data:
packages.append(modulator.modulate(list(map(int, d)), pause))
# verify modulation was correct
pa = ProtocolAnalyzer(None)
signal = Signal("", "", sample_rate=sample_rate)
signal._fulldata = np.concatenate(packages)
signal.modulation_type = modulation_type
signal.bit_len = bit_len
signal.tolerance = tolerance
signal.noise_threshold = noise
signal.qad_center = center
pa.signal = signal
pa.get_protocol_from_signal()
self.assertEqual(pa.plain_bits_str, data)
# send data
send_data = np.concatenate(packages)
self.network_sdr_plugin_sender.send_raw_data(send_data, 1)
time.sleep(1)
# Send enough pauses to end sniffing
self.network_sdr_plugin_sender.send_raw_data(np.zeros(10 * bit_len, dtype=np.complex64), 1)
time.sleep(1)
sniffer.stop()
self.assertEqual(sniffer.plain_bits_str, data)
def tearDown(self):
window.downloads_page.can_update_items = False
if window:
window.close_tribler()
for _ in range(0, MAX_TIMEOUT, 100):
QTest.qWait(100)
if window.core_manager.check_stopped() is None:
return
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 test_download_details(self):
self.go_to_and_wait_for_downloads()
QTest.mouseClick(window.downloads_list.topLevelItem(0).progress_slider, Qt.LeftButton)
QTest.qWait(500) # Wait until the details pane shows
window.download_details_widget.setCurrentIndex(0)
self.screenshot(window, name="download_detail")
window.download_details_widget.setCurrentIndex(1)
self.screenshot(window, name="download_files")
window.download_details_widget.setCurrentIndex(2)
self.screenshot(window, name="download_trackers")
def __build_protocol(self):
QApplication.instance().processEvents()
QTest.qWait(self.WAIT_TIMEOUT_BEFORE_NEW)
result = ProtocolAnalyzer(signal=None)
for _ in range(self.NUM_MESSAGES):
b = Message([True] * self.BITS_PER_MESSAGE,
pause=1000,
message_type=result.default_message_type)
result.messages.append(b)
return result
def test_open_message_type_dialog(self):
assert isinstance(self.cfc, CompareFrameController)
self.cfc.ui.btnMessagetypeSettings.click()
dialog = next((w for w in qApp.topLevelWidgets() if isinstance(w, MessageTypeDialog)), None)
self.assertIsNotNone(dialog)
self.assertEqual(dialog.windowTitle(), self.cfc.active_message_type.name)
dialog.close()
sip.delete(dialog)
QTest.qSleep(1)
QTest.qWait(10)
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 setUp(self):
self.signal_received = None
QTest.qWait(100)
self.screenshots_taken = 0
window.downloads_page.can_update_items = True
if not window.tribler_started:
self.screenshot(window, name="tribler_loading")
self.wait_for_signal(window.core_manager.events_manager.tribler_started, no_args=True)
def test_download_details(self):
self.go_to_and_wait_for_downloads()
QTest.mouseClick(window.downloads_list.topLevelItem(0).progress_slider, Qt.LeftButton)
QTest.qWait(500) # Wait until the details pane shows
window.download_details_widget.setCurrentIndex(0)
self.screenshot(window, name="download_detail")
window.download_details_widget.setCurrentIndex(1)
self.screenshot(window, name="download_files")
window.download_details_widget.setCurrentIndex(2)
self.screenshot(window, name="download_trackers")
def test_connectDevice2():
test.setServer('localhost')
suc = test.connectServer()
assert suc
suc = test.watchDevice('CCD Simulator')
assert suc
QTest.qWait(500)
suc = test.connectDevice('CCD Simulator')
assert suc
test.disconnectServer()
def setUp(self):
self.signal_received = None
QTest.qWait(100)
self.screenshots_taken = 0
window.downloads_page.can_update_items = True
if not window.tribler_started:
self.screenshot(window, name="tribler_loading")
self.wait_for_signal(window.core_manager.events_manager.tribler_started, no_args=True)
def paste_isolated(self):
self.paste(self.bkg)
QTest.qWait(1000)
for i in range(len(self.objects)):
ind = self.order[i]
self.paste(self.bkg)
self.paste(self.objects[ind], ind + 1)
self.showCanvas()
QTest.qWait(1000)
self.paste_all()
def test_close_all(self):
self.form.close_all()
QTest.qWait(1)
self.form.add_signalfile(get_path_for_data_file("ask.complex"))
self.form.add_signalfile(get_path_for_data_file("fsk.complex"))
self.assertEqual(self.form.signal_tab_controller.num_signals, 2)
self.form.close_all()
QTest.qWait(1)
self.assertEqual(self.form.signal_tab_controller.num_signals, 0)
self.assertEqual(self.form.project_manager.project_file, None)
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_case3(self):
try:
for i in range(9):
QTest.mouseClick(gv.window.toggleButton, Qt.LeftButton)
QTest.qWait(100)
spy = QSignalSpy(gv.window.notify)
t = spy.wait(timeout=10000)
print(f"Spy signal: {t}")
except Exception as e:
self.fail(e)
def wait_for_qtext_edit_populated(self, qtext_edit, timeout=10):
for _ in range(0, timeout * 1000, 100):
QTest.qWait(100)
if not isinstance(qtext_edit, QTextEdit):
return
if qtext_edit.toPlainText():
return
# QTextEdit was not populated in time, fail the test
raise TimeoutException("QTextEdit was not populated within 10 seconds")
def wait_for_qtext_edit_populated(self, qtext_edit, timeout=10):
for _ in range(0, timeout * 1000, 100):
QTest.qWait(100)
if not isinstance(qtext_edit, QTextEdit):
return
if qtext_edit.toPlainText():
return
# QTextEdit was not populated in time, fail the test
raise TimeoutException("QTextEdit was not populated within 10 seconds")
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
]
QTest.qWait(250)
def wait_new_acquired_file(blows_done):
""" Called by startAcquisition.
Wait for the arrival of files during the measure session, plot each one when available.
:parameter: blows_done: v.BlowsDone value; counter of actual blows done, starting from 1
:return: False if error
"""
is_good = False
this_line = ""
line_refer = ""
while not is_good:
try:
myfile = None
QTest.qWait(500) # (ms) While waiting events will be processed
myfile = open(c.blows_list_txt
) # File containig the list of saved Acq. files
if myfile is not None:
myfile.close()
except:
if myfile is None: continue
# #
try:
with open(c.blows_list_txt) as f:
lines = f.readlines()
this_line = lines[
blows_done] # Indexing start from 0, but v.BlowsDone from 1
this_line = this_line[0:-1] # Remove line-feed char at end
except:
continue
# #
""" Compare this_line with the line_refer.
Format of rows of c.blows_list_txt, with lf character ending each line.
...........
/y1_09/ y2_09
/y1_10/ y2_10
............
"""
line_refer = "/y1_" + str('{:02d}'.format(blows_done + 1)) + " " + \
"/y2_" + str('{:02d}'.format(blows_done + 1))
if this_line != line_refer:
continue # Wait for the arrival
else:
is_good = True # Good: a new Acquisition file available
v.BlowsDone += 1 # v.BlowsDone start from 1 not from 0
break
# # # END while not is_good:
v.BlowsDone = int(
min(v.BlowsDone,
v.AveragesRequired)) # Limiter required when is in the Test mode
#### TODO REMOVE COMMENT
# self.Info_Edit.append(str(v.cntr) + ") Blow n. " + str(v.BlowsDone))
####
print("v.BlowsDone: {}, this_line: {}, line_refer: {}".format(
v.BlowsDone, this_line, line_refer))
return is_good
def keyinFiducials(self):
# Add Fiducial Points
self.window.keyin_fiducial_action.trigger()
widget = self.getDockedWidget(self.window.docks,
InsertPointDialog.dock_flag)
QTest.keyClick(widget.z_axis.form_lineedit, Qt.Key_A,
Qt.ControlModifier)
QTest.keyClick(widget.z_axis.form_lineedit, Qt.Key_Delete)
self.assertFalse(widget.execute_button.isEnabled())
QTest.keyClicks(widget.z_axis.form_lineedit, "100")
self.assertTrue(widget.execute_button.isEnabled())
QTest.mouseClick(widget.execute_button, Qt.LeftButton)
QTest.keyClick(widget.x_axis.form_lineedit, Qt.Key_A,
Qt.ControlModifier)
QTest.keyClicks(widget.x_axis.form_lineedit, "50")
QTest.mouseClick(widget.execute_button, Qt.LeftButton)
self.triggerUndo()
self.assertEqual(self.model.fiducials.size, 1)
self.triggerRedo()
self.assertEqual(self.model.fiducials.size, 2)
# Test Point Manager
widget = self.getDockedWidget(self.window.docks,
PointManager.dock_flag)
self.assertTrue(widget.isVisible())
self.assertEqual(widget.point_type, PointType.Fiducial)
x_pos = widget.table_view.columnViewportPosition(0) + 5
y_pos = widget.table_view.rowViewportPosition(1) + 10
pos = QPoint(x_pos, y_pos)
QTest.mouseClick(widget.table_view.viewport(), Qt.LeftButton, pos=pos)
QTest.mouseClick(widget.move_up_button, Qt.LeftButton)
QTest.qWait(WAIT_TIME // 20)
QTest.mouseClick(widget.move_down_button, Qt.LeftButton)
QTest.qWait(WAIT_TIME // 20)
QTest.mouseDClick(widget.table_view.viewport(), Qt.LeftButton, pos=pos)
QTest.keyClicks(widget.table_view.viewport().focusWidget(), "100")
QTest.keyClick(widget.table_view.viewport().focusWidget(),
Qt.Key_Enter)
QTest.qWait(WAIT_TIME // 20)
np.testing.assert_array_almost_equal(self.model.fiducials[1].points,
[100.0, 0.0, 100.0],
decimal=3)
self.triggerUndo()
np.testing.assert_array_almost_equal(self.model.fiducials[1].points,
[50.0, 0.0, 100.0],
decimal=3)
QTest.qWait(WAIT_TIME // 20)
QTest.mouseClick(widget.delete_button, Qt.LeftButton)
QTest.qWait(WAIT_TIME // 20)
self.assertEqual(self.model.fiducials.size, 1)
self.triggerUndo()
self.assertEqual(self.model.fiducials.size, 2)
def test_open_recent(self):
self.form.add_signalfile(
tests.utils_testing.get_path_for_data_file("esaver.complex"))
app.processEvents()
self.assertEqual(len(self.form.signal_tab_controller.signal_frames), 1)
self.form.close_all()
app.processEvents()
QTest.qWait(10)
self.assertEqual(len(self.form.signal_tab_controller.signal_frames), 0)
self.form.recentFileActionList[0].trigger()
self.assertEqual(len(self.form.signal_tab_controller.signal_frames), 1)
def chartData(self, type='daily', code=None, date=None, next='0'):
self._SetInputValue('종목코드', code)
self._SetInputValue('수정주가부분', '1')
if type == 'daily':
QTest.qWait(5000)
if date is not None:
self._SetInputValue('기준일자', date)
self._CommRqData('일봉차트', 'opt10081', next, self.screenChart)
elif type == 'min':
self._SetInputValue('틱범위', '1')
self._CommRqData('분봉차트', 'opt10080', next, self.screenChart)
def step_impl(context):
"""
:type context: behave.runner.Context
"""
tracklist_model = context.main_window.tracklist_model
tracklist_model.beginRemoveRows(QModelIndex(), 0, DEFAULT_NUM_TRACKS-1)
query = QSqlQuery()
result = query.exec_("DELETE FROM tracks")
tracklist_model.endRemoveRows()
tracklist_model.select()
QTest.qWait(500)
def test_get_bit_sample_pos(self):
signal = Signal("./data/ASK_mod.complex", "Bit sample pos test")
QTest.qWait(10)
signal.modulation_type = 0
signal.bit_len = 100
proto_analyzer = ProtocolAnalyzer(signal)
proto_analyzer.get_protocol_from_signal()
self.assertEqual(proto_analyzer.num_blocks, 1)
for i, pos in enumerate(proto_analyzer.bit_sample_pos[0]):
self.assertLess(pos, signal.num_samples, msg = i)
def test_open_operations(self):
self._close_welcome()
self._load_data_set()
self._open_operations()
self.assertIsNotNone(self.main_window.filters)
self.assertTrue(self.main_window.filters.isVisible())
QTest.qWait(SHOW_DELAY)
self.main_window.filters.close()
QTest.qWait(SHOW_DELAY)
def wait_for(f, *fargs, wait_time=3, **fkwargs):
timeout = time.time() + wait_time
result = None
while True:
result = f(*fargs, **fkwargs)
if result or time.time() > timeout:
break
QTest.qWait(10)
return result
def _click_stack_selector(cls, keep_new: bool):
cls._wait_for_widget_visible(StackChoiceView)
QTest.qWait(SHOW_DELAY)
for widget in cls.app.topLevelWidgets():
if isinstance(widget, StackChoiceView):
if keep_new:
QTest.mouseClick(widget.newDataButton,
Qt.MouseButton.LeftButton)
else:
QTest.mouseClick(widget.originalDataButton,
Qt.MouseButton.LeftButton)
def test_disconnectServer4(qtbot):
test.setServer('localhost')
test.connectServer()
test.watchDevice('CCD Simulator')
QTest.qWait(500)
test.connectDevice('CCD Simulator')
with qtbot.waitSignal(test.signals.serverDisconnected):
with qtbot.waitSignal(test.signals.removeDevice) as b:
test.socket.close()
assert ['CCD Simulator'] == b.args
assert 0 == len(test.devices)
def reception(self):
self.changeLabel.emit("")
self.datapath = self.selfpath + "/reception/"
os.makedirs(self.datapath, exist_ok=True)
self.name = ""
self.count = 0
self.takePicture()
while not os.path.isfile(self.datapath + "0.jpg"):
QTest.qWait(10)
name = self.lthread.predict(self.datapath + "0.jpg")
self.changeLabel.emit(name)
def get_etf_stock_info(self):
self.logging.logger.info("get_etf_stock_info")
for sCode in self.cal_target_etf_stock_dict.keys():
QTest.qWait(4000)
self.dynamicCall("SetInputValue(QString, QString)",
self.customType.STOCK_CODE, sCode)
self.dynamicCall("CommRqData(QString, QString, int, QString)",
self.customType.OPT10001, "opt10001", 0,
self.screen_etf_stock)
self.etf_info_event_loop.exec_()
def update_pypad(self):
self.update_label.setText("Updating...")
self.status.removeWidget(self.button)
self.status.addWidget(self.update_progress)
"""
So "updating" means I should first have an executeable or something of that sorts
"""
for i in range(101):
self.update_progress.setValue(i)
QTest.qWait(random.randint(50, 75))
def process_example_data(self):
# Add the job to the list
self.ex.ui.pushButtonGo.click()
# Click the start button to run the job
self.ex.ui.pushButtonStart.click()
# Wait for process to finish
while self.ex.workthread is not None:
QTest.qWait(250)
def setUp(self):
logger.debug("Init form")
self.form = MainController()
logger.debug("Initialized form")
app.processEvents()
QTest.qWait(25)
self.form.project_manager.set_project_folder(get_path_for_data_file(""), ask_for_new_project=False)
self.cframe = self.form.compare_frame_controller
self.gframe = self.form.generator_tab_controller
self.dialog = ProjectDialogController(project_manager=self.form.project_manager, parent=self.form)
def waitUntilPassed(self, timeout, func):
"""Try to execute a function until it doesn't fail"""
for _ in range(20):
QTest.qWait(timeout / 20.)
try:
func()
except:
continue
else:
break
else:
func()
def wait_for_list_populated(self, llist, num_items=1, timeout=10):
for _ in range(0, timeout * 1000, 100):
QTest.qWait(100)
if isinstance(llist, QListWidget) and llist.count() >= num_items:
if not isinstance(llist.itemWidget(llist.item(0)), LoadingListItem):
return
elif isinstance(llist, QTreeWidget) and llist.topLevelItemCount() > num_items:
if not isinstance(llist.topLevelItem(0), LoadingListItem):
return
# List was not populated in time, fail the test
raise TimeoutException("The list was not populated within 10 seconds")
def test_dev_null(self):
core.workspace().openFile(self.EXISTING_FILE)
NEW_PATH = '/dev/null'
_startEditCurrentFilePath()
self.keyClicks(NEW_PATH)
self.keyClick(Qt.Key_Return)
QTest.qWait(100) # Test fails without a sleep. Threads inside Qt???
self.assertFalse(os.path.isfile(self.EXISTING_FILE))
self.assertIsNone(core.workspace().currentDocument())
def __demodulate(self, connection):
QTest.qWait(100)
data = connection.recv(65536)
while len(data) % 8 != 0:
data += connection.recv(65536)
arr = np.array(np.frombuffer(data, dtype=np.complex64))
signal = Signal("", "")
signal._fulldata = arr
pa = ProtocolAnalyzer(signal)
pa.get_protocol_from_signal()
return pa.plain_bits_str
def wait_for_list_populated(self, llist, num_items=1, timeout=10):
for _ in range(0, timeout * 1000, 100):
QTest.qWait(100)
if isinstance(llist, QListWidget) and llist.count() >= num_items:
if not isinstance(llist.itemWidget(llist.item(0)), LoadingListItem):
return
elif isinstance(llist, QTreeWidget) and llist.topLevelItemCount() >= num_items:
if not isinstance(llist.topLevelItem(0), LoadingListItem):
return
# List was not populated in time, fail the test
raise TimeoutException("The list was not populated within 10 seconds")
def test_close_all(self):
self.form.close_project()
QApplication.instance().processEvents()
QTest.qWait(self.CLOSE_TIMEOUT)
self.assertEqual(self.form.signal_tab_controller.num_frames, 0)
self.add_signal_to_form("ask.complex")
self.add_signal_to_form("fsk.complex")
self.assertEqual(self.form.signal_tab_controller.num_frames, 2)
self.form.close_project()
QApplication.instance().processEvents()
QTest.qWait(self.CLOSE_TIMEOUT)
self.assertEqual(self.form.signal_tab_controller.num_frames, 0)
self.assertEqual(self.form.project_manager.project_file, None)
def test_success(self):
core.workspace().openFile(self.EXISTING_FILE)
NEW_PATH = self.TEST_FILE_DIR + '/newname'
_startEditCurrentFilePath()
self.keyClicks(NEW_PATH)
self.keyClick(Qt.Key_Return)
QTest.qWait(100) # Test fails without a sleep. Threads inside Qt???
self.assertTrue(os.path.isfile(NEW_PATH))
with open(NEW_PATH) as f:
text = f.read()
self.assertEqual(text, self.EXISTING_FILE_TEXT)
def test_selection_sync(self):
self.add_signal_to_form("esaver.complex")
frame = self.form.signal_tab_controller.signal_frames[0]
frame.ui.cbProtoView.setCurrentIndex(0) # set to bit view
frame.ui.gvSignal.selection_area.end = 128440
frame.ui.gvSignal.selection_area.start = 89383
frame.ui.gvSignal.sel_area_start_end_changed.emit(89383, 128440)
QApplication.instance().processEvents()
QTest.qWait(100)
self.assertEqual(frame.proto_analyzer.messages[0].plain_bits_str, frame.ui.txtEdProto.selected_text.strip())
frame.ui.txtEdProto.show_proto_clicked.emit()
QApplication.instance().processEvents()
self.assertAlmostEqual((128440 - 89383) / 1000000,
(frame.ui.gvSignal.view_rect().width()) / 1000000, places=1)
def test_video_playback(self):
"""
Test video playback of a Tribler instance.
"""
self.wait_for_variable("tribler_settings")
QTest.mouseClick(window.left_menu_button_video_player, Qt.LeftButton)
window.left_menu_playlist.set_files([{"name": "test.wmv", "index": 1}])
window.video_player_page.active_infohash = 'a' * 20
window.video_player_page.active_index = 0
window.video_player_page.play_active_item()
QTest.qWait(3000)
self.screenshot(window, name="video_playback")
window.video_player_page.reset_player()
def test_send_dialog_scene_zoom(self):
send_dialog = self.__get_send_dialog()
QApplication.instance().processEvents()
self.assertEqual(send_dialog.graphics_view.sceneRect().width(), self.signal.num_samples)
view_width = send_dialog.graphics_view.view_rect().width()
send_dialog.graphics_view.zoom(1.1)
QApplication.instance().processEvents()
QTest.qWait(50)
self.assertLess(send_dialog.graphics_view.view_rect().width(), view_width)
send_dialog.graphics_view.zoom(0.8)
QApplication.instance().processEvents()
QTest.qWait(50)
self.assertLessEqual(send_dialog.graphics_view.view_rect().width(), view_width)
self.__close_dialog(send_dialog)
def retryUntilPassed(self, timeoutMs, function):
""" Try to execute a function until it doesn't generate any exception
but not more than for timeoutSec
Raise exception, if timeout passed
"""
for _ in range(20):
QTest.qWait(timeoutMs / 20.)
try:
function()
except:
continue
else:
return
else:
function()
