def stopTest(self, test):
        stopTime = time.time()
        deltaTime = stopTime - self._startTime
        TestResult.stopTest(self, test)
        self.stream.write(' time="%.3f"' % deltaTime)
        self.stream.write('>')
        if self._lastWas != 'success':
            if self._lastWas == 'error':
                self.stream.write(self._errorsAndFailures)
            elif self._lastWas == 'failure':
                self.stream.write(self._errorsAndFailures)
            else:
                assert(False)

        seen = {}

        for assertion in test._extraAssertions:
            if not seen.has_key(assertion):
                self._addAssertion(assertion[:110]) # :110 avoids tl;dr TODO use a lexical truncator
                seen[assertion] = True

        self.stream.write('</testcase>')
        self._errorsAndFailures = ""

        if test._extraXML != '':
            self.stream.write(test._extraXML)

 def addSkip(self, test, reason):
     TestResult.addSkip(self, test, reason)
     if self.verbose:
         self.stream.write("SKIPPED: %s [%s]%s" % (test, reason,
                                                   os.linesep))
         self.stream.flush()
     self.countcall()

    def addError(self, test, err):
        testname = test.id().split(".")[-1]
        tb = err[2]
        stack = traceback.extract_tb(tb)
        for frame in stack:
            fname = frame[2]
            if fname == testname:
                if self._logging:
                    self._writeToStream("\tResult: ")
                self._writeToStream("Test ERROR", eColors.Yellow)
                break
            if fname == "setUp":
                if self._logging:
                    self._writeToStream("\tResult: ")
                self._writeToStream("SetUp ERROR", eColors.Yellow)
                break
            if fname == "tearDown":
                #If test succeded but tear down failed the result should
                #still be that the test failed. So it's my resposibility
                #to display thet only the 'test' part of the test passed. (Confused yet?)
                faults = chain(self.failures, self.errors)
                testFaults = ifilter(lambda item: item[0] == test, faults)
                hasFailed = (sum(1 for u in testFaults) > 0)
                if not hasFailed:
                    if self._logging:
                        self._writeToStream("\tResult: ")
                    self._writeToStream("PASSED", eColors.Green)

                self._writeToStream(", ")
                self._writeToStream("Tear Down ERROR", eColors.Yellow)
                break

        TestResult.addError(self, test, err)

 def stopTest(self, test):
     """Called when the given test has been run. If the stop flag was
     raised beforehand, will broadcast to raise flags for global stop."""
     stop_flags = np.empty(self.comm.size, dtype=bool)
     self.comm.all_gather(np.array([self.shouldStop]), stop_flags)
     self.shouldStop = stop_flags.any()
     TestResult.stopTest(self, test)

 def __init__(self):
     TestResult.__init__(self)
     self.start_at = time.time()
     self.testSuccess = []
     self.all_tests = {}
     self.results_log = {}
     self.note_log = []

    def addFailure(self, test, err):
        location = self.init_suite(test)
        self.current_failed = True
        TestResult.addFailure(self, test, err)

        error_value = smart_str(err[1])
        if not len(error_value):
            # means it's test function and we have to extract value from traceback
            error_value = self.find_error_value(err[2])

        self_find_first = self.find_first(error_value)
        self_find_second = self.find_second(error_value)
        quotes = ["'", '"']
        if (
            self_find_first[0] == self_find_first[-1]
            and self_find_first[0] in quotes
            and self_find_second[0] == self_find_second[-1]
            and self_find_second[0] in quotes
        ):
            # let's unescape strings to show sexy multiline diff in PyCharm.
            # By default all caret return chars are escaped by testing framework
            first = self._unescape(self_find_first)
            second = self._unescape(self_find_second)
        else:
            first = second = ""
        err = self._exc_info_to_string(err, test)

        self.messages.testStarted(self.getTestName(test), location=location)
        duration = self.__getDuration(test)
        self.messages.testFailed(
            self.getTestName(test), message="Failure", details=err, expected=first, actual=second, duration=duration
        )

  def addError(self, test, err):
    TestResult.addError(self, test, err)

    err = self._exc_info_to_string(err, test)

    self.messages.testError(self.getTestName(test),
                            message='Error', details=err)

 def addError(self, test, err):
     TestResult.addError(self, test, err)
     
     err = self.formatErr(err)
     
     self.messages.testFailed(self.getTestName(test),
         message='Error', details=err)

    def addFailure(self, test, err, *k):
        TestResult.addFailure(self, test, err)

        err = self.formatErr(err)
        
        self.messages.testFailed(self.getTestName(test),
            message='Failure', details=err)

 def addFailure(self, test, err):
     TestResult.addFailure(self, test, err)
     if self.showAll:
         self.stream.writeln("FAIL")
     elif self.dots:
         self.printError('FAIL', err, test)
         self.stream.flush()

 def addSkip(self, test, reason):
     """Called when a test is skipped."""
     TestResult.addSkip(self, test, reason)
     if self.verbose:
         self.stream.write('skipped (%s)\n' % reason)
     else:
         self.stream.write('s')
         self.stream.flush()

 def addError(self, test, err):
     """Called when an error has occurred."""
     TestResult.addError(self, test, err)
     if self.verbose:
         self.stream.write('ERROR\n')
     else:
         self.stream.write('E')
         self.stream.flush()

 def addSuccess(self, test):
     "Called when a test has completed successfully"
     TestResult.addSuccess(self, test)
     if self.verbose:
         self.stream.write('ok\n')
     else:
         self.stream.write('.')
         self.stream.flush()

 def __init__(self, stream=sys.stdout, *args, **kwargs):
   TestResult.__init__(self)
   for arg, value in kwargs.items():
     setattr(self, arg, value)
   self.output = stream
   self.messages = TeamcityServiceMessages(self.output, prepend_linebreak=True)
   self.messages.testMatrixEntered()
   self.current_suite = None

    def __init__(self, stream=sys.stdout):
        TestResult.__init__(self)

        self.output = stream
        self.test_started_datetime = None
        self.test_name = None

        self.createMessages()

 def startTest(self, test):
     "Called before execute each test method."
     self.start_time = time.time()
     TestResult.startTest(self, test)
     
     if self.showAll:
         self.stream.write('  ' + self.getDescription(test))
         self.stream.write(" ... ")

 def addFailure(self, test, err):
     TestResult.addFailure(self, test, err)
     exctype, value, dummy_tb = err
     error_xml = self.xml.createElement('failure')
     error_xml.setAttribute('type', '%s' % exctype)
     message_xml = self.xml.createTextNode('%s' % value)
     error_xml.appendChild(message_xml)
     self._testcase_xml.appendChild(error_xml)

 def __init__(self, parent):
     """
     Constructor
     
     @param parent The parent widget.
     """
     TestResult.__init__(self)
     self.parent = parent

 def __init__(self, comm=None):
     if comm is None:
         comm = world
     self.comm = comm
     self.outcomes = []
     self.last_errors = np.empty(self.comm.size, dtype=bool)
     self.last_failed = np.empty(self.comm.size, dtype=bool)
     TestResult.__init__(self)

 def startTest(self, test):
     """
     Method called at the start of a test.
     
     @param test Reference to the test object
     """
     TestResult.startTest(self, test)
     self.parent.write('%s%s\n' % (ResponseUTStartTest,
         unicode((unicode(test), test.shortDescription()))))