def _flushErrors(self, *types):
     # This bit about log flushing seems to be necessary with twisted < 2.5.
     try:
         self.flushLoggedErrors(*types)
     except AttributeError:
         from twisted.python import log as tlog
         tlog.flushErrors(*types)

 def openFailed(self, reason):
     """
     good .... good
     """
     log.msg('unknown open failed')
     log.flushErrors()
     self.conn.addResult()

    def testRefusedAnonymousClientConnection(self):
        onServerLost = defer.Deferred()
        onClientLost = defer.Deferred()
        self.loopback(sslverify.OpenSSLCertificateOptions(privateKey=self.sKey, certificate=self.sCert, verify=True, caCerts=[self.sCert], requireCertificate=True),
                      sslverify.OpenSSLCertificateOptions(requireCertificate=False),
                      onServerLost=onServerLost,
                      onClientLost=onClientLost)

        d = defer.DeferredList([onClientLost, onServerLost], consumeErrors=True)


        def afterLost(((cSuccess, cResult), (sSuccess, sResult))):

            self.failIf(cSuccess)
            self.failIf(sSuccess)

            # XXX Twisted doesn't report SSL errors as SSL errors, but in the
            # future it will.

            # cResult.trap(SSL.Error)
            # sResult.trap(SSL.Error)

            # Twisted trunk will do the correct thing here, and not log any
            # errors.  Twisted 2.1 will do the wrong thing.  We're flushing
            # errors until the buildbot is updated to a reasonable facsimilie
            # of 2.2.
            log.flushErrors(SSL.Error)

 def testLink(self):
     linkRes = self._getCmdResult('ln testLink testfile1')
     self.failIf(linkRes)
     lslRes = self._getCmdResult('ls -l testLink')
     log.flushErrors()
     self.failUnless(lslRes.startswith('l'), 'link failed')
     self.failIf(self._getCmdResult('rm testLink'))

 def _ebConnect(self, f):
     # probably because the server wasn't listening in time
     # but who knows, just try again
     log.msg('ERROR CONNECTING TO %s' % self.port)
     log.err(f)
     log.flushErrors()
     reactor.callLater(1, self._connect)

 def testPBFailures(self):
     auth = authorizer.DefaultAuthorizer()
     appl = app.Application("pbfailure", authorizer=auth)
     SimpleService("pbfailure",auth,appl,self).getPerspectiveNamed("guest").makeIdentity("guest")
     p = reactor.listenTCP(0, pb.BrokerFactory(pb.AuthRoot(auth)), interface="127.0.0.1")
     self.n = p.getHost()[2]
     appl.run(save=0)
     log.flushErrors(PoopError, FailError, DieError)

 def testErrors(self):
     for e, ig in [("hello world","hello world"),
                   (KeyError(), KeyError),
                   (failure.Failure(RuntimeError()), RuntimeError)]:
         log.err(e)
         i = self.catcher.pop()
         self.assertEquals(i['isError'], 1)
         log.flushErrors(ig)

 def testChAttrs(self):
    lsRes = self._getCmdResult('ls -l testfile1')
    self.failUnless(lsRes.startswith('-rw-r--r--'), lsRes)
    self.failIf(self._getCmdResult('chmod 0 testfile1'))
    lsRes = self._getCmdResult('ls -l testfile1')
    self.failUnless(lsRes.startswith('----------'), lsRes)
    self.failIf(self._getCmdResult('chmod 644 testfile1'))
    log.flushErrors()

 def testDeferredStopService(self):
     ms = app.MultiService("MultiService")
     self.s1 = StoppingService("testService", 0)
     self.s2 = StoppingService("testService2", 1)
     ms.addService(self.s1)
     ms.addService(self.s2)
     ms.stopService().addCallback(self.woohoo)
     log.flushErrors (StopError)

 def testStopServiceNone(self):
     """MultiService.stopService returns Deferred when service returns None.
     """
     ms = app.MultiService("MultiService")
     self.s1 = StoppingServiceII("testService")
     ms.addService(self.s1)
     d = ms.stopService()
     d.addCallback(self.cb_nonetest)
     log.flushErrors (StopError)

 def tearDown(self):
     try:
         self.flushLoggedErrors(errors.NotAuthenticatedError)
     except AttributeError:
         tlog.flushErrors(errors.NotAuthenticatedError)
     log._getTheFluLogObserver().clearIgnores()
     d = self.feedServer.shutdown()
     d.addCallback(lambda _: self._bouncer.stop())
     d.addCallback(lambda _: self.assertAdditionalFDsOpen(0, 'tearDown'))
     return d

 def do_logErrCheck(cls):
     if log._keptErrors:
         L = []
         for err in log._keptErrors:
             if isinstance(err, failure.Failure):
                 L.append(err)
             else:
                 L.append(repr(err))
         log.flushErrors()
         raise LoggedErrors(L)

 def testErrors(self):
     for code, methodName in [(666, "fail"), (666, "deferFail"),
                              (12, "fault"), (23, "noSuchMethod"),
                              (17, "deferFault")]:
         l = []
         d = self.proxy().callRemote(methodName).addErrback(l.append)
         while not l:
             reactor.iterate()
         l[0].trap(xmlrpc.Fault)
         self.assertEquals(l[0].value.faultCode, code)
     log.flushErrors(RuntimeError, ValueError)

 def testRegeneratingIt(self):
     for mod in self.removedModules:
         self.failIf(mod.__name__ in sys.modules, 'Started with %r loaded: %r' % (mod.__name__, sys.path))
     _regeneratePluginCache(['axiom', 'xmantissa'])
     log.flushErrors(ImportError) # This is necessary since there are Axiom
                                  # plugins that depend on Mantissa, so when
                                  # Axiom is installed, Mantissa-dependent
                                  # powerups are, but Mantissa isn't some
                                  # harmless tracebacks are printed.
     for mod in self.removedModules:
         self.failIf(mod.__name__ in sys.modules, 'Loaded %r: %r' % (mod.__name__, sys.path))

 def testBadLogin(self):
     factory = pb.PBClientFactory()
     for username, password in [("nosuchuser", "pass"), ("user", "wrongpass")]:
         d = factory.login(credentials.UsernamePassword(username, password), "BRAINS!")
         c = reactor.connectTCP("127.0.0.1", self.portno, factory)
         p = unittest.deferredError(d)
         self.failUnless(p.check("twisted.cred.error.UnauthorizedLogin"))
         c.disconnect()
         reactor.iterate()
         reactor.iterate()
         reactor.iterate()
     from twisted.cred.error import UnauthorizedLogin
     log.flushErrors(UnauthorizedLogin)

 def cbCompleted(ign):
     """
     Flush the exceptions which the reactor should have logged and make
     sure they're actually there.
     """
     errs = log.flushErrors(BadClientError)
     self.assertEquals(len(errs), 2, "Incorrectly found %d errors, expected 2" % (len(errs),))

 def testBadLogin(self):
     d = defer.succeed(None)
     for username, password in [("nosuchuser", "pass"),
                                ("user", "wrongpass")]:
         d.addCallback(self._testBadLogin_once, username, password)
     d.addBoth(lambda res: log.flushErrors(UnauthorizedLogin))
     return d

 def testBrokenTimer(self):
     t = internet.TimerService(1, lambda: 1 / 0)
     t.startService()
     util.spinWhile(lambda :t._loop.running, timeout=30)
     t.stopService()
     self.assertEquals([ZeroDivisionError],
                       [o.value.__class__ for o in log.flushErrors(ZeroDivisionError)])

    def testErrors(self):
        p = TestErrorIdentServer()
        p.makeConnection(StringTransport())
        L = []
        p.sendLine = L.append

        p.exceptionType = ident.IdentError
        p.lineReceived('123, 345')
        self.assertEquals(L[0], '123, 345 : ERROR : UNKNOWN-ERROR')
        
        p.exceptionType = ident.NoUser
        p.lineReceived('432, 210')
        self.assertEquals(L[1], '432, 210 : ERROR : NO-USER')
        
        p.exceptionType = ident.InvalidPort
        p.lineReceived('987, 654')
        self.assertEquals(L[2], '987, 654 : ERROR : INVALID-PORT')
        
        p.exceptionType = ident.HiddenUser
        p.lineReceived('756, 827')
        self.assertEquals(L[3], '756, 827 : ERROR : HIDDEN-USER')
        
        p.exceptionType = NewException
        p.lineReceived('987, 789')
        self.assertEquals(L[4], '987, 789 : ERROR : UNKNOWN-ERROR')
        errs = log.flushErrors(NewException)
        self.assertEquals(len(errs), 1)

    def testFailedRETR(self):
        try:
            f = protocol.Factory()
            f.noisy = 0
            port = reactor.listenTCP(0, f, interface="127.0.0.1")
            portNum = port.getHost().port
            # This test data derived from a bug report by ranty on #twisted
            responses = ['220 ready, dude (vsFTPd 1.0.0: beat me, break me)',
                         # USER anonymous
                         '331 Please specify the password.',
                         # PASS [email protected]
                         '230 Login successful. Have fun.',
                         # TYPE I
                         '200 Binary it is, then.',
                         # PASV
                         '227 Entering Passive Mode (127,0,0,1,%d,%d)' %
                         (portNum >> 8, portNum & 0xff),
                         # RETR /file/that/doesnt/exist
                         '550 Failed to open file.']
            f.buildProtocol = lambda addr: PrintLines(responses)

            client = ftp.FTPClient(passive=1)
            cc = protocol.ClientCreator(reactor, ftp.FTPClient, passive=1)
            client = wait(cc.connectTCP('127.0.0.1', portNum))
            p = protocol.Protocol()
            d = client.retrieveFile('/file/that/doesnt/exist', p)

            # This callback should not be called
            d.addCallback(lambda r, self=self:
                            self.fail('Callback incorrectly called: %r' % r))
            def p(failure):
                # Yow!  Nested DeferredLists!
                failure.trap(defer.FirstError)
                failure.value.subFailure.trap(defer.FirstError)
                subsubFailure = failure.value.subFailure.value.subFailure
                subsubFailure.trap(ftp.CommandFailed)
                # If we got through all that, we got the right failure.

            d.addErrback(p)

            wait(d)
            log.flushErrors(ftp.FTPError)
        finally:
            d = port.stopListening()
            if d is not None:
                wait(d)