コード例 #1
0
    def run(self, result=None):
        orig_result = result
        if result is None:
            result = self.defaultTestResult()
            startTestRun = getattr(result, 'startTestRun', None)
            if startTestRun is not None:
                startTestRun()

        self._resultForDoCleanups = result
        result.startTest(self)
        if getattr(self.__class__, "__unittest_skip__", False):
            # If the whole class was skipped.
            try:
                result.addSkip(self, self.__class__.__unittest_skip_why__)
            finally:
                result.stopTest(self)
            return
        testMethod = getattr(self, self._testMethodName)
        try:
            success = False
            try:
                self.setUp()
            except SkipTest, e:
                result.addSkip(self, str(e))
            except Exception:
                result.addError(self, sys.exc_info())
            else:
                try:
                    testMethod()
                except self.failureException:
                    result.addFailure(self, sys.exc_info())
                except _ExpectedFailure, e:
                    result.addExpectedFailure(self, e.exc_info)
                except _UnexpectedSuccess:
                    result.addUnexpectedSuccess(self)
コード例 #2
0
ファイル: case.py プロジェクト: Aaron1011/oh-mainline
    def run(self, result=None):
        orig_result = result
        if result is None:
            result = self.defaultTestResult()
            startTestRun = getattr(result, 'startTestRun', None)
            if startTestRun is not None:
                startTestRun()

        self._resultForDoCleanups = result
        result.startTest(self)
        if getattr(self.__class__, "__unittest_skip__", False):
            # If the whole class was skipped.
            try:
                result.addSkip(self, self.__class__.__unittest_skip_why__)
            finally:
                result.stopTest(self)
            return
        testMethod = getattr(self, self._testMethodName)
        try:
            success = False
            try:
                self.setUp()
            except SkipTest, e:
                result.addSkip(self, str(e))
            except Exception:
                result.addError(self, sys.exc_info())
            else:
                try:
                    testMethod()
                except self.failureException:
                    result.addFailure(self, sys.exc_info())
                except _ExpectedFailure, e:
                    result.addExpectedFailure(self, e.exc_info)
                except _UnexpectedSuccess:
                    result.addUnexpectedSuccess(self)
コード例 #3
0
ファイル: case.py プロジェクト: Aaron1011/oh-mainline
                    result.addError(self, sys.exc_info())
                else:
                    success = True

                try:
                    self.tearDown()
                except Exception:
                    result.addError(self, sys.exc_info())
                    success = False

            cleanUpSuccess = self.doCleanups()
            success = success and cleanUpSuccess
            if success:
                result.addSuccess(self)
        finally:
            result.stopTest(self)
            if orig_result is None:
                stopTestRun = getattr(result, 'stopTestRun', None)
                if stopTestRun is not None:
                    stopTestRun()

    def doCleanups(self):
        """Execute all cleanup functions. Normally called for you after
        tearDown."""
        result = self._resultForDoCleanups
        ok = True
        while self._cleanups:
            function, args, kwargs = self._cleanups.pop(-1)
            try:
                function(*args, **kwargs)
            except Exception:
コード例 #4
0
                    result.addError(self, sys.exc_info())
                else:
                    success = True

                try:
                    self.tearDown()
                except Exception:
                    result.addError(self, sys.exc_info())
                    success = False

            cleanUpSuccess = self.doCleanups()
            success = success and cleanUpSuccess
            if success:
                result.addSuccess(self)
        finally:
            result.stopTest(self)
            if orig_result is None:
                stopTestRun = getattr(result, 'stopTestRun', None)
                if stopTestRun is not None:
                    stopTestRun()

    def doCleanups(self):
        """Execute all cleanup functions. Normally called for you after
        tearDown."""
        result = self._resultForDoCleanups
        ok = True
        while self._cleanups:
            function, args, kwargs = self._cleanups.pop(-1)
            try:
                function(*args, **kwargs)
            except Exception:
コード例 #5
0
ファイル: testcase2.py プロジェクト: atfip/ATFiP
    def run(self, result=None):

        print_debug_info(" run() somebady call me.")

        orig_result = result
        if result is None:
            result = self.defaultTestResult()
            startTestRun = getattr(result, 'startTestRun', None)
            if startTestRun is not None:
                startTestRun()

        print_debug_info("before _resultForDoCleanups")

        self._resultForDoCleanups = result
        
        print_debug_info("before result.startTest")

        result.startTest(self)

        print_debug_info("get test method...")

        testMethod = getattr(self, self._testMethodName)
        if (getattr(self.__class__, "__unittest_skip__", False) or
            getattr(testMethod, "__unittest_skip__", False)):
            # If the class or method was skipped.
            try:
                skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
                            or getattr(testMethod, '__unittest_skip_why__', ''))
                self._addSkip(result, skip_why)
            finally:
                result.stopTest(self)
            return

        print_debug_info("ready for create recorder.")
        # "create Castro recorder"
        self.recorder = create_recorder(self._testMethodName)                


        try:
            success = False
            try:
                self.setUp()
            except SkipTest as e:
                self._addSkip(result, str(e))
            except KeyboardInterrupt:
                raise
            except:
                result.addError(self, sys.exc_info())
            else:
                try:
                    # start recording test process
                    start_record(self.recorder)
                    # exec the test case method
                    testMethod()
                    # stop record and save the video file
                    stop_record(self.recorder)
                except KeyboardInterrupt:
                    raise
                except self.failureException:
                    result.addFailure(self, sys.exc_info())
                except _ExpectedFailure as e:
                    addExpectedFailure = getattr(result, 'addExpectedFailure', None)
                    if addExpectedFailure is not None:
                        addExpectedFailure(self, e.exc_info)
                    else:
                        warnings.warn("TestResult has no addExpectedFailure method, reporting as passes",
                                      RuntimeWarning)
                        result.addSuccess(self)
                except _UnexpectedSuccess:
                    addUnexpectedSuccess = getattr(result, 'addUnexpectedSuccess', None)
                    if addUnexpectedSuccess is not None:
                        addUnexpectedSuccess(self)
                    else:
                        warnings.warn("TestResult has no addUnexpectedSuccess method, reporting as failures",
                                      RuntimeWarning)
                        result.addFailure(self, sys.exc_info())
                except SkipTest as e:
                    self._addSkip(result, str(e))
                except:
                    result.addError(self, sys.exc_info())
                else:
                    success = True

                try:
                    self.tearDown()
                except KeyboardInterrupt:
                    raise
                except:
                    result.addError(self, sys.exc_info())
                    success = False

            cleanUpSuccess = self.doCleanups()
            success = success and cleanUpSuccess
            if success:
                result.addSuccess(self)
        finally:
            result.stopTest(self)
            if orig_result is None:
                stopTestRun = getattr(result, 'stopTestRun', None)
                if stopTestRun is not None:
                    stopTestRun()
            # self.recorder.cleanup()
            # print "recorder cleaned."
            # del self.recorder
コード例 #6
0
ファイル: retrycase.py プロジェクト: brain-zhang/learn123
    def run(self, result=None):
        while self.retry_count > 0:
            self.retry_count = self.retry_count - 1
            orig_result = result
            if result is None:
                result = self.defaultTestResult()
                startTestRun = getattr(result, 'startTestRun', None)
                if startTestRun is not None:
                    startTestRun()

            self._resultForDoCleanups = result
            result.startTest(self)

            testMethod = getattr(self, self._testMethodName)
            if (getattr(self.__class__, "__unittest_skip__", False)
                    or getattr(testMethod, "__unittest_skip__", False)):
                # If the class or method was skipped.
                try:
                    skip_why = (
                        getattr(self.__class__, '__unittest_skip_why__', '')
                        or getattr(testMethod, '__unittest_skip_why__', ''))
                    self._addSkip(result, skip_why)
                finally:
                    result.stopTest(self)
                return
            try:
                success = False
                try:
                    self.setUp()
                except SkipTest as e:
                    self._addSkip(result, str(e))
                except KeyboardInterrupt:
                    raise
                except:
                    if self.retry_count == 0:
                        result.addError(self, sys.exc_info())
                else:
                    try:
                        testMethod()
                    except KeyboardInterrupt:
                        raise
                    except self.failureException:
                        if self.retry_count == 0:
                            result.addFailure(self, sys.exc_info())
                    except _ExpectedFailure as e:
                        addExpectedFailure = getattr(result,
                                                     'addExpectedFailure',
                                                     None)
                        if addExpectedFailure is not None:
                            addExpectedFailure(self, e.exc_info)
                        else:
                            warnings.warn(
                                "TestResult has no addExpectedFailure method, reporting as passes",
                                RuntimeWarning)
                            result.addSuccess(self)
                    except _UnexpectedSuccess:
                        addUnexpectedSuccess = getattr(result,
                                                       'addUnexpectedSuccess',
                                                       None)
                        if addUnexpectedSuccess is not None:
                            addUnexpectedSuccess(self)
                        else:
                            warnings.warn(
                                "TestResult has no addUnexpectedSuccess method, reporting as failures",
                                RuntimeWarning)
                            if self.retry_count == 0:
                                result.addFailure(self, sys.exc_info())
                    except SkipTest as e:
                        self._addSkip(result, str(e))
                    except:
                        if self.retry_count == 0:
                            result.addError(self, sys.exc_info())
                    else:
                        success = True

                    try:
                        self.tearDown()
                    except KeyboardInterrupt:
                        raise
                    except:
                        if self.retry_count == 0:
                            result.addError(self, sys.exc_info())
                        success = False

                cleanUpSuccess = self.doCleanups()
                success = success and cleanUpSuccess
                if success:
                    result.addSuccess(self)
                    return
            finally:
                result.stopTest(self)
                if orig_result is None:
                    stopTestRun = getattr(result, 'stopTestRun', None)
                    if stopTestRun is not None:
                        stopTestRun()
コード例 #7
0
ファイル: retrycase.py プロジェクト: memoryboxes/learn123
    def run(self, result=None):
        while self.retry_count > 0:
            self.retry_count = self.retry_count - 1
            orig_result = result
            if result is None:
                result = self.defaultTestResult()
                startTestRun = getattr(result, 'startTestRun', None)
                if startTestRun is not None:
                    startTestRun()

            self._resultForDoCleanups = result
            result.startTest(self)

            testMethod = getattr(self, self._testMethodName)
            if (getattr(self.__class__, "__unittest_skip__", False) or
                getattr(testMethod, "__unittest_skip__", False)):
                # If the class or method was skipped.
                try:
                    skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
                                or getattr(testMethod, '__unittest_skip_why__', ''))
                    self._addSkip(result, skip_why)
                finally:
                    result.stopTest(self)
                return
            try:
                success = False
                try:
                    self.setUp()
                except SkipTest as e:
                    self._addSkip(result, str(e))
                except KeyboardInterrupt:
                    raise
                except:
                    if self.retry_count == 0:
                        result.addError(self, sys.exc_info())
                else:
                    try:
                        testMethod()
                    except KeyboardInterrupt:
                        raise
                    except self.failureException:
                        if self.retry_count == 0:
                            result.addFailure(self, sys.exc_info())
                    except _ExpectedFailure as e:
                        addExpectedFailure = getattr(result, 'addExpectedFailure', None)
                        if addExpectedFailure is not None:
                            addExpectedFailure(self, e.exc_info)
                        else:
                            warnings.warn("TestResult has no addExpectedFailure method, reporting as passes",
                                          RuntimeWarning)
                            result.addSuccess(self)
                    except _UnexpectedSuccess:
                        addUnexpectedSuccess = getattr(result, 'addUnexpectedSuccess', None)
                        if addUnexpectedSuccess is not None:
                            addUnexpectedSuccess(self)
                        else:
                            warnings.warn("TestResult has no addUnexpectedSuccess method, reporting as failures",
                                          RuntimeWarning)
                            if self.retry_count == 0:
                                result.addFailure(self, sys.exc_info())
                    except SkipTest as e:
                        self._addSkip(result, str(e))
                    except:
                        if self.retry_count == 0:
                            result.addError(self, sys.exc_info())
                    else:
                        success = True

                    try:
                        self.tearDown()
                    except KeyboardInterrupt:
                        raise
                    except:
                        if self.retry_count == 0:
                            result.addError(self, sys.exc_info())
                        success = False

                cleanUpSuccess = self.doCleanups()
                success = success and cleanUpSuccess
                if success:
                    result.addSuccess(self)
                    return
            finally:
                result.stopTest(self)
                if orig_result is None:
                    stopTestRun = getattr(result, 'stopTestRun', None)
                    if stopTestRun is not None:
                        stopTestRun()