def testShutdownException(self):
     client = self.client
     f = self.f
     f.protocol.transport.loseConnection()
     client.transport.write("X")
     client.transport.loseWriteConnection()
     spinUntil(lambda :f.protocol.closed, True)

 def testKillPty(self):
     if self.verbose:
         print "starting processes"
     self.createProcesses(usePTY=1)
     reactor.callLater(1, self.kill, 0)
     reactor.callLater(2, self.kill, 1)
     spinUntil(self.check, 5)

    def testStdio(self):
        """twisted.internet.stdio test."""
        exe = sys.executable
        scriptPath = util.sibpath(__file__, "process_twisted.py")
        p = Accumulator()
        # As trial chdirs to _trial_temp after startup, this makes any
        # possible relative entries in PYTHONPATH invalid. Attempt to
        # fix that up.  Otherwise process_twisted.py will use the
        # installed Twisted, which isn't really guaranteed to exist at
        # this stage.
        def fixup(l):
            for path in l:
                if os.path.isabs(path):
                    yield path
                else:
                    yield os.path.join(os.path.pardir, path)

        env = {"PYTHONPATH": os.pathsep.join(fixup(sys.path))}
        reactor.spawnProcess(p, exe, [exe, "-u", scriptPath], env=env, path=None, usePTY=self.usePTY)
        p.transport.write("hello, world")
        p.transport.write("abc")
        p.transport.write("123")
        p.transport.closeStdin()
        spinUntil(lambda: p.closed, 10)
        self.assertEquals(
            p.outF.getvalue(),
            "hello, worldabc123",
            "Error message from process_twisted follows:" "\n\n%s\n\n" % p.errF.getvalue(),
        )

 def testClose(self):
     if self.verbose:
         print "starting processes"
     self.createProcesses()
     reactor.callLater(1, self.close, 0)
     reactor.callLater(2, self.close, 1)
     spinUntil(self.check, 5)

    def testClientBind(self):
        f = MyServerFactory()
        p = reactor.listenTCP(0, f, interface="127.0.0.1")
        self.ports.append(p)
        
        factory = MyClientFactory()
        reactor.connectTCP("127.0.0.1", p.getHost().port, factory,
                           bindAddress=("127.0.0.1", 0))

        spinUntil(lambda :factory.protocol is not None)
        
        self.assertEquals(factory.protocol.made, 1)

        port = factory.protocol.transport.getHost().port
        f2 = MyClientFactory()
        reactor.connectTCP("127.0.0.1", p.getHost().port, f2,
                           bindAddress=("127.0.0.1", port))


        spinUntil(lambda :f2.failed)
        
        self.assertEquals(f2.failed, 1)
        f2.reason.trap(error.ConnectBindError)
        self.assert_(f2.reason.check(error.ConnectBindError))
        self.assertEquals(f2.stopped, 1)
        
        p.stopListening()
        factory.protocol.transport.loseConnection()

        spinWhile(lambda :p.connected)

        self.assertEquals(factory.stopped, 1)
        self.cleanPorts(*self.ports)

 def testLinger(self):
     # See what happens when all the pipes close before the process
     # actually stops. This test *requires* SIGCHLD catching to work,
     # as there is no other way to find out the process is done.
     exe = sys.executable
     scriptPath = util.sibpath(__file__, "process_linger.py")
     p = Accumulator()
     reactor.spawnProcess(p, exe, [exe, "-u", scriptPath], env=None, path=None, childFDs={1: "r", 2: 2})
     spinUntil(lambda: p.closed, 7)
     self.failUnlessEqual(p.outF.getvalue(), "here is some text\ngoodbye\n")

    def testStdinReader(self):
        pyExe = sys.executable
        scriptPath = util.sibpath(__file__, "process_stdinreader.py")
        p = Accumulator()
        reactor.spawnProcess(p, pyExe, [pyExe, "-u", scriptPath], env=None, path=None)
        p.transport.write("hello, world")
        p.transport.closeStdin()

        spinUntil(lambda: p.closed)
        self.assertEquals(p.errF.getvalue(), "err\nerr\n")
        self.assertEquals(p.outF.getvalue(), "out\nhello, world\nout\n")

    def testOpeningTTY(self):
        exe = sys.executable
        scriptPath = util.sibpath(__file__, "process_tty.py")
        p = Accumulator()

        reactor.spawnProcess(p, exe, [exe, "-u", scriptPath], env=None, path=None, usePTY=self.usePTY)
        p.transport.write("hello world!\n")
        spinUntil(lambda: p.closed, 10)
        self.assertEquals(
            p.outF.getvalue(),
            "hello world!\r\nhello world!\r\n",
            "Error message from process_tty follows:\n\n%s\n\n" % p.outF.getvalue(),
        )

    def testNormalTermination(self):
        if os.path.exists("/bin/true"):
            cmd = "/bin/true"
        elif os.path.exists("/usr/bin/true"):
            cmd = "/usr/bin/true"
        else:
            raise RuntimeError("true not found in /bin or /usr/bin")

        p = TrivialProcessProtocol()
        reactor.spawnProcess(p, cmd, ["true"], env=None, usePTY=self.usePTY)

        spinUntil(lambda: p.finished)
        p.reason.trap(error.ProcessDone)
        self.assertEquals(p.reason.value.exitCode, 0)
        self.assertEquals(p.reason.value.signal, None)