def addError(self, test, err):
     """Overrides normal addError to add support for
     errorClasses. If the exception is a registered class, the
     error will be added to the list for that class, not errors.
     """
     self._handleElapsedTime(test)
     stream = getattr(self, 'stream', None)
     ec, ev, tb = err
     try:
         exc_info = self._exc_info_to_string(err, test)
     except TypeError:
         # 2.3 compat
         exc_info = self._exc_info_to_string(err)
     for cls, (storage, label, isfail) in self.errorClasses.items():
         if result.isclass(ec) and issubclass(ec, cls):
             if isfail:
                 test.passed = False
             storage.append((test, exc_info))
             # Might get patched into a streamless result
             if stream is not None:
                 if self.showAll:
                     message = [label]
                     detail = result._exception_detail(err[1])
                     if detail:
                         message.append(detail)
                     stream.writeln(": ".join(message))
                 elif self.dots:
                     stream.write(label[:1])
             return
     self.errors.append((test, exc_info))
     test.passed = False
     if stream is not None:
         self._writeResult(test, 'ERROR', 'red', 'E', False)

    def addError(self, test, error): # pylint: disable-msg=W0221
        """Overrides normal addError to add support for
        errorClasses. If the exception is a registered class, the
        error will be added to the list for that class, not errors.
        """
        
        fixTestCase(test)
        #manually call startTest if it's not already called
        if not getattr(test, '_subunit_started', False):
            self.startTest(test)

        ecls, evt, tbk = error # pylint: disable-msg=W0612

        # pylint: disable-msg=W0612
        for cls, (storage, label, isfail) in self.errorClasses.items():
            if isclass(ecls) and issubclass(ecls, cls):
                if not isfail:
                    reason = _exception_detail(evt)
                    if reason and self.useDetails:
                        details = {"reason":TextContent(reason)}
                        reason = None
                    else:
                        details = None

                    self._addNonFailOutcome(label.lower(), test, 
                        reason=reason, details=details)
                    return
        self._wassuccess = False
        error, details = self._getArgs(test, error)
        test.passed = False
        TestProtocolClient.addError(self, test, error, details=details)

 def addError(self, test, err):
     stream = getattr(self, 'stream', None)
     ec, ev, tb = err
     try:
         exc_info = self._exc_info_to_string(err, test)
     except TypeError:
         # 2.3 compat
         exc_info = self._exc_info_to_string(err)
     for cls, (storage, label, isfail) in self.errorClasses.items():
         if result.isclass(ec) and issubclass(ec, cls):
             if isfail:
                 test.passed = False
             storage.append((test, exc_info))
             # Might get patched into a streamless result
             if stream is not None:
                 if self.showAll:
                     message = [label]
                     detail = result._exception_detail(err[1])
                     if detail:
                         message.append(detail)
                     stream.writeln(": ".join(message))
                 elif self.dots:
                     stream.write(label[:1])
             return
     self.errors.append((test, exc_info))
     test.passed = False
     if stream is not None:
         self._writeResult(test, 'ERROR', TermColor.red, 'E', False)

 def addError(self, test, err):
     """Overrides normal addError to add support for errorClasses.
     If the exception is a registered class, the error will be added
     to the list for that class, not errors.
     """
     stream = getattr(self, 'stream', None)
     ec, ev, tb = err
     try:
         exc_info = self._exc_info_to_string(err, test)
     except TypeError:
         # This is for compatibility with Python 2.3.
         exc_info = self._exc_info_to_string(err)
     for cls, (storage, label, isfail) in self.errorClasses.items():
         if result.isclass(ec) and issubclass(ec, cls):
             if isfail:
                 test.passwd = False
             storage.append((test, exc_info))
             # Might get patched into a streamless result_backup
             if stream is not None:
                 if self.showAll:
                     message = [label]
                     detail = result._exception_detail(err[1])
                     if detail:
                         message.append(detail)
                     stream.writeln(": ".join(message))
                 elif self.dots:
                     stream.write(label[:1])
             return
     self.errors.append((test, exc_info))
     test.passed = False
     if stream is not None:
         if self.showAll:
             self.colorizer.write("ERROR", 'red')
             self.stream.writeln()
         elif self.dots:
             stream.write('E')