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 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_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 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 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()