eric: comparison PyUnit/UnittestDialog.py

-:c147620313c5
+:d29a7b8fab0f
 if prog in self.fileHistory:
 self.fileHistory.remove(prog)
 self.fileHistory.insert(0, prog)
 self.testsuitePicker.clear()
 self.testsuitePicker.addItems(self.fileHistory)
 def insertTestName(self, testName):
 """
 Public slot to insert a test name into the testComboBox object.
 @param testName name of the test to be inserted (string)
 if testName in self.testNameHistory:
 self.testNameHistory.remove(testName)
 self.testNameHistory.insert(0, testName)
 self.testComboBox.clear()
 self.testComboBox.addItems(self.testNameHistory)
 @pyqtSlot()
 def on_testsuitePicker_aboutToShowPathPickerDialog(self):
 """
 Private slot called before the test suite selection dialog is shown.
 """
 .format(py2Extensions, py3Extensions)
 else:
 fileFilter = self.tr("Python Files (*.py);;All Files (*)")
 self.testsuitePicker.setFilters(fileFilter)
+defaultDirectory = Preferences.getMultiProject("Workspace")
+if not defaultDirectory:
+defaultDirectory = os.path.expanduser("~")
+if self.__dbs:
+project = e5App().getObject("Project")
+if self.__forProject and project.isOpen():
+defaultDirectory = project.getProjectPath()
 @pyqtSlot(str)
 def on_testsuitePicker_pathSelected(self, suite):
 """
 Private slot called after a test suite has been selected.
 @param suite file name of the test suite
 @type str
 """
 self.insertProg(suite)
 def on_buttonBox_clicked(self, button):
 """
 Private slot called by a button of the button box clicked.
 @param button button that was clicked (QAbstractButton)
 self.on_startButton_clicked()
 elif button == self.stopButton:
 self.on_stopButton_clicked()
 elif button == self.startFailedButton:
 self.on_startButton_clicked(failedOnly=True)
 @pyqtSlot()
 def on_startButton_clicked(self, failedOnly=False):
 """
 Private slot to start the test.
 if cover:
 cover.stop()
 cover.save()
 self.__setStoppedMode()
 sys.path = self.savedSysPath
 def __UTPrepared(self, nrTests, exc_type, exc_value):
 """
 Private slot to handle the utPrepared signal.
 If the unittest suite was loaded successfully, we ask the
 return
 self.totalTests = nrTests
 self.__setRunningMode()
 self.__dbs.remoteUTRun()
 @pyqtSlot()
 def on_stopButton_clicked(self):
 """
 Private slot to stop the test.
 """
 if self.__dbs:
 self.__dbs.remoteUTStop()
 elif self.testResult:
 self.testResult.stop()
 def on_errorsListWidget_currentTextChanged(self, text):
 """
 Private slot to handle the highlighted signal.
 @param text current text (string)
 text, Qt.MatchFlags(Qt.MatchExactly))
 if len(foundItems) > 0:
 itm = foundItems[0]
 self.testsListWidget.setCurrentItem(itm)
 self.testsListWidget.scrollToItem(itm)
 def __setRunningMode(self):
 """
 Private method to set the GUI in running mode.
 """
 self.running = True
 self.errorCount = 0
 self.skippedCount = 0
 self.expectedFailureCount = 0
 self.unexpectedSuccessCount = 0
 self.remainingCount = self.totalTests
 # reset the GUI
 self.progressCounterRunCount.setText(str(self.runCount))
 self.progressCounterRemCount.setText(str(self.remainingCount))
 self.progressCounterFailureCount.setText(str(self.failCount))
 self.progressCounterErrorCount.setText(str(self.errorCount))
 self.sbLabel.setText(self.tr("Running"))
 self.progressLed.on()
 QApplication.processEvents()
 self.startTime = time.time()
 def __setStoppedMode(self):
 """
 Private method to set the GUI in stopped mode.
 """
 self.stopTime = time.time()
 self.tr("Ran {0} tests in {1:.3f}s")
 .format(self.runCount, self.timeTaken))
 self.progressLed.off()
 self.unittestStopped.emit()
 def testFailed(self, test, exc, testId):
 """
 Public method called if a test fails.
 @param test name of the test (string)
 self.progressCounterFailureCount.setText(str(self.failCount))
 itm = QListWidgetItem(self.tr("Failure: {0}").format(test))
 itm.setData(Qt.UserRole, (test, exc))
 self.errorsListWidget.insertItem(0, itm)
 self.__failedTests.append(testId)
 def testErrored(self, test, exc, testId):
 """
 Public method called if a test errors.
 @param test name of the test (string)
 self.progressCounterErrorCount.setText(str(self.errorCount))
 itm = QListWidgetItem(self.tr("Error: {0}").format(test))
 itm.setData(Qt.UserRole, (test, exc))
 self.errorsListWidget.insertItem(0, itm)
 self.__failedTests.append(testId)
 def testSkipped(self, test, reason, testId):
 """
 Public method called if a test was skipped.
 @param test name of the test (string)
 self.skippedCount += 1
 self.progressCounterSkippedCount.setText(str(self.skippedCount))
 itm = QListWidgetItem(self.tr("    Skipped: {0}").format(reason))
 itm.setForeground(Qt.blue)
 self.testsListWidget.insertItem(1, itm)
 def testFailedExpected(self, test, exc, testId):
 """
 Public method called if a test fails expectedly.
 @param test name of the test (string)
 self.progressCounterExpectedFailureCount.setText(
 str(self.expectedFailureCount))
 itm = QListWidgetItem(self.tr("    Expected Failure"))
 itm.setForeground(Qt.blue)
 self.testsListWidget.insertItem(1, itm)
 def testSucceededUnexpected(self, test, testId):
 """
 Public method called if a test succeeds unexpectedly.
 @param test name of the test (string)
 self.progressCounterUnexpectedSuccessCount.setText(
 str(self.unexpectedSuccessCount))
 itm = QListWidgetItem(self.tr("    Unexpected Success"))
 itm.setForeground(Qt.red)
 self.testsListWidget.insertItem(1, itm)
 def testStarted(self, test, doc):
 """
 Public method called if a test is about to be run.
 @param test name of the started test (string)
 if doc:
 self.testsListWidget.insertItem(0, "    {0}".format(doc))
 self.testsListWidget.insertItem(0, test)
 if self.__dbs is None:
 QApplication.processEvents()
 def testFinished(self):
 """
 Public method called if a test has finished.
 <b>Note</b>: It is also called if it has already failed or errored.
 if self.errorCount:
 self.__setProgressColor("red")
 elif self.failCount:
 self.__setProgressColor("orange")
 self.progressProgressBar.setValue(self.runCount)
 def on_errorsListWidget_itemDoubleClicked(self, lbitem):
 """
 Private slot called by doubleclicking an errorlist entry.
 It will popup a dialog showing the stacktrace.
 @param lbitem the listbox item that was double clicked
 """
 self.errListIndex = self.errorsListWidget.row(lbitem)
 text = lbitem.text()
 self.on_errorsListWidget_currentTextChanged(text)
 # get the error info
 test, tracebackText = lbitem.data(Qt.UserRole)
 # now build the dialog
 from .Ui_UnittestStacktraceDialog import Ui_UnittestStacktraceDialog
 self.dlg = QDialog(self)
 ui = Ui_UnittestStacktraceDialog()
 ui.setupUi(self.dlg)
 ui.traceback.setPlainText(tracebackText)
 # and now fire it up
 self.dlg.show()
 self.dlg.exec_()
 def __showSource(self):
 """
 Private slot to show the source of a traceback in an eric6 editor.
 """
 # get the error info
 @param parent The parent widget.
 """
 super(QtTestResult, self).__init__()
 self.parent = parent
 def addFailure(self, test, err):
 """
 Public method called if a test failed.
 @param test reference to the test object
 @param err error traceback
 """
 super(QtTestResult, self).addFailure(test, err)
 tracebackLines = self._exc_info_to_string(err, test)
 self.parent.testFailed(str(test), tracebackLines, test.id())
 def addError(self, test, err):
 """
 Public method called if a test errored.
 @param test reference to the test object
 @param err error traceback
 """
 super(QtTestResult, self).addError(test, err)
 tracebackLines = self._exc_info_to_string(err, test)
 self.parent.testErrored(str(test), tracebackLines, test.id())
 def addSkip(self, test, reason):
 """
 Public method called if a test was skipped.
 @param test reference to the test object
 @param reason reason for skipping the test (string)
 """
 super(QtTestResult, self).addSkip(test, reason)
 self.parent.testSkipped(str(test), reason, test.id())
 def addExpectedFailure(self, test, err):
 """
 Public method called if a test failed expected.
 @param test reference to the test object
 @param err error traceback
 """
 super(QtTestResult, self).addExpectedFailure(test, err)
 tracebackLines = self._exc_info_to_string(err, test)
 self.parent.testFailedExpected(str(test), tracebackLines, test.id())
 def addUnexpectedSuccess(self, test):
 """
 Public method called if a test succeeded expectedly.
 @param test reference to the test object
 """
 super(QtTestResult, self).addUnexpectedSuccess(test)
 self.parent.testSucceededUnexpected(str(test), test.id())
 def startTest(self, test):
 """
 Public method called at the start of a test.
 @param test Reference to the test object

Mercurial Repositories > eric / file comparison

comparison: PyUnit/UnittestDialog.py

PyUnit/UnittestDialog.py