def testCloseWriteCloser(self): client = self.client f = self.f t = client.transport t.write("hello") spinUntil(lambda :len(t._tempDataBuffer) == 0) t.loseWriteConnection() spinUntil(lambda :t._writeDisconnected) self.assertEquals(client.closed, False) self.assertEquals(client.writeHalfClosed, True) self.assertEquals(client.readHalfClosed, False) spinUntil(lambda :f.protocol.readHalfClosed, timeout=1.0) w = client.transport.write w(" world") w("lalala fooled you") spinWhile(lambda :len(client.transport._tempDataBuffer) > 0) self.assertEquals(f.protocol.data, "hello") self.assertEquals(f.protocol.closed, False) self.assertEquals(f.protocol.readHalfClosed, True)
def testUNIX(self): if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" s = service.MultiService() c = compat.IOldApplication(s) factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() if os.path.exists('.hello.skt'): os.remove('hello.skt') c.listenUNIX('./hello.skt', factory) class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write('lalala\r\n') def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None c.connectUNIX('./hello.skt', factory) s.privilegedStartService() s.startService() util.spinWhile(lambda: factory.line is None) util.wait(defer.maybeDeferred(s.stopService)) self.assertEqual(factory.line, 'lalala') # Cleanup the reactor util.wait(TestEcho.d)
def waitOnShutDown(self): if not self.done: try: self.transport.signalProcess('KILL') util.spinWhile(lambda: not self.done) except error.ProcessExitedAlready: pass
def testCloseWriteCloser(self): client = self.client f = self.f t = client.transport t.write("hello") spinUntil(lambda: len(t._tempDataBuffer) == 0) t.loseWriteConnection() spinUntil(lambda: t._writeDisconnected) self.assertEquals(client.closed, False) self.assertEquals(client.writeHalfClosed, True) self.assertEquals(client.readHalfClosed, False) spinUntil(lambda: f.protocol.readHalfClosed, timeout=1.0) w = client.transport.write w(" world") w("lalala fooled you") spinWhile(lambda: len(client.transport._tempDataBuffer) > 0) self.assertEquals(f.protocol.data, "hello") self.assertEquals(f.protocol.closed, False) self.assertEquals(f.protocol.readHalfClosed, True)
def testUNIX(self): if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" s = service.MultiService() s.startService() factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() t = internet.UNIXServer("echo.skt", factory) t.setServiceParent(s) class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write("lalala\r\n") def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None internet.UNIXClient("echo.skt", factory).setServiceParent(s) util.spinWhile(lambda: factory.line is None) self.assertEqual(factory.line, "lalala") util.wait(defer.maybeDeferred(s.stopService)) util.wait(TestEcho.d) TestEcho.d = defer.Deferred() factory.line = None s.startService() util.spinWhile(lambda: factory.line is None) self.assertEqual(factory.line, "lalala") util.wait(defer.maybeDeferred(s.stopService)) util.wait(TestEcho.d)
def testProperlyCloseFiles(self): self.connector() f = lambda: (self.totalConnections < self.numberRounds) spinWhile(f, timeout=self.timeLimit) self.failUnlessEqual(self.totalConnections, self.numberRounds)
def testUNIX(self): if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" s = service.MultiService() c = compat.IOldApplication(s) factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() if os.path.exists(".hello.skt"): os.remove("hello.skt") c.listenUNIX("./hello.skt", factory) class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write("lalala\r\n") def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None c.connectUNIX("./hello.skt", factory) s.privilegedStartService() s.startService() util.spinWhile(lambda: factory.line is None) util.wait(defer.maybeDeferred(s.stopService)) self.assertEqual(factory.line, "lalala") util.wait(TestEcho.d)
def testTCP(self): s = service.MultiService() c = compat.IOldApplication(s) factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() c.listenTCP(0, factory) s.privilegedStartService() s.startService() num = list(s)[0]._port.getHost().port class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write('lalala\r\n') def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None c.connectTCP('127.0.0.1', num, factory) util.spinWhile(lambda: factory.line is None) util.wait(defer.maybeDeferred(s.stopService)) self.assertEqual(factory.line, 'lalala') # Cleanup the reactor util.wait(TestEcho.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 testTCP(self): s = service.MultiService() s.startService() factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() t = internet.TCPServer(0, factory) t.setServiceParent(s) num = t._port.getHost().port class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write('lalala\r\n') def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None internet.TCPClient('127.0.0.1', num, factory).setServiceParent(s) util.spinWhile(lambda :factory.line is None) self.assertEqual(factory.line, 'lalala') # Cleanup the reactor util.wait(defer.maybeDeferred(s.stopService)) util.wait(TestEcho.d)
def testTCP(self): s = service.MultiService() c = compat.IOldApplication(s) factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() c.listenTCP(0, factory) s.privilegedStartService() s.startService() num = list(s)[0]._port.getHost().port class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write("lalala\r\n") def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None c.connectTCP("127.0.0.1", num, factory) util.spinWhile(lambda: factory.line is None) util.wait(defer.maybeDeferred(s.stopService)) self.assertEqual(factory.line, "lalala") util.wait(TestEcho.d)
def testPrivileged(self): factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() t = internet.TCPServer(0, factory) t.privileged = 1 t.privilegedStartService() num = t._port.getHost().port class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write('lalala\r\n') def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None c = internet.TCPClient('127.0.0.1', num, factory) c.startService() util.spinWhile(lambda: factory.line is None) self.assertEqual(factory.line, 'lalala') # Cleanup the reactor util.wait(defer.maybeDeferred(c.stopService)) util.wait(defer.maybeDeferred(t.stopService)) util.wait(TestEcho.d)
def testPrivileged(self): factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() t = internet.TCPServer(0, factory) t.privileged = 1 t.privilegedStartService() num = t._port.getHost().port class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write("lalala\r\n") def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None c = internet.TCPClient("127.0.0.1", num, factory) c.startService() util.spinWhile(lambda: factory.line is None) self.assertEqual(factory.line, "lalala") util.wait(defer.maybeDeferred(c.stopService)) util.wait(defer.maybeDeferred(t.stopService)) util.wait(TestEcho.d)
def testProperlyCloseFiles(self): self.connector() f = lambda :(self.totalConnections < self.numberRounds) spinWhile(f, timeout=self.timeLimit) self.failUnlessEqual(self.totalConnections, self.numberRounds)
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 getFreePort(self): """Get an empty port.""" p = reactor.listenTCP(0, protocol.ServerFactory()) spinUntil(lambda: p.connected) port = p.getHost().port p.stopListening() spinWhile(lambda: p.connected) return port
def getFreePort(self): """Get an empty port.""" p = reactor.listenTCP(0, protocol.ServerFactory()) spinUntil(lambda :p.connected) port = p.getHost().port p.stopListening() spinWhile(lambda :p.connected) return port
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 testSignal(self): exe = sys.executable scriptPath = util.sibpath(__file__, "process_signal.py") signals = ("HUP", "INT", "KILL") for sig in signals: p = SignalProtocol(sig, self) reactor.spawnProcess(p, exe, [exe, "-u", scriptPath, sig], env=None, usePTY=self.usePTY) spinWhile(lambda: p.going) self.failIf(p.failure, p.failure)
def tearDown(self): self.assertEquals(self.client.closed, 0) self.client.transport.loseConnection() self.p.stopListening() spinWhile(lambda :self.p.connected) self.assertEquals(self.client.closed, 1) self.assertEquals(self.f.protocol.closed, 0) self.f.protocol.transport.loseConnection() spinWhile(lambda :self.f.protocol.transport.connected) self.assertEquals(self.f.protocol.closed, 1)
def testSignal(self): exe = sys.executable scriptPath = util.sibpath(__file__, "process_signal.py") signals = ('HUP', 'INT', 'KILL') for sig in signals: p = SignalProtocol(sig, self) reactor.spawnProcess(p, exe, [exe, "-u", scriptPath, sig], env=None, usePTY=self.usePTY) spinWhile(lambda: p.going) self.failIf(p.failure, p.failure)
def testClosePortInProtocolFactory(self): f = ClosingFactory() port = reactor.listenTCP(0, f, interface="127.0.0.1") self.n = port.getHost().port self.ports.append(port) f.port = port clientF = MyClientFactory() reactor.connectTCP("127.0.0.1", self.n, clientF) spinWhile(lambda :(not clientF.protocol or not clientF.protocol.closed)) self.assert_(clientF.protocol.made) self.assert_(port.disconnected) clientF.lostReason.trap(error.ConnectionDone)
def testConnectionGettingRefused(self): factory = protocol.ServerFactory() factory.protocol = wire.Echo t = internet.TCPServer(0, factory) t.startService() num = t._port.getHost().port t.stopService() l = [] factory = protocol.ClientFactory() factory.clientConnectionFailed = lambda *args: l.append(None) c = internet.TCPClient("127.0.0.1", num, factory) c.startService() util.spinWhile(lambda: not l) self.assertEqual(l, [None])
def tearDown(self): self.assertEquals(self.client.closed, 0) self.client.transport.loseConnection() self.p.stopListening() spinWhile(lambda :self.p.connected) self.assertEquals(self.client.closed, 1) # because we did half-close, the server also needs to # closed explicitly. self.assertEquals(self.f.protocol.closed, 0) self.f.protocol.transport.loseConnection() spinWhile(lambda :self.f.protocol.transport.connected) self.assertEquals(self.f.protocol.closed, 1)
def testConnectionGettingRefused(self): factory = protocol.ServerFactory() factory.protocol = wire.Echo t = internet.TCPServer(0, factory) t.startService() num = t._port.getHost().port t.stopService() l = [] factory = protocol.ClientFactory() factory.clientConnectionFailed = lambda *args: l.append(None) c = internet.TCPClient('127.0.0.1', num, factory) c.startService() util.spinWhile(lambda: not l) self.assertEqual(l, [None])
def tearDown(self): self.assertEquals(self.client.closed, 0) self.client.transport.loseConnection() self.p.stopListening() spinWhile(lambda: self.p.connected) self.assertEquals(self.client.closed, 1) # because we did half-close, the server also needs to # closed explicitly. self.assertEquals(self.f.protocol.closed, 0) self.f.protocol.transport.loseConnection() spinWhile(lambda: self.f.protocol.transport.connected) self.assertEquals(self.f.protocol.closed, 1)
def testStoppingServer(self): if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" factory = protocol.ServerFactory() factory.protocol = wire.Echo t = internet.UNIXServer('echo.skt', factory) t.startService() t.stopService() self.failIf(t.running) factory = protocol.ClientFactory() l = [] factory.clientConnectionFailed = lambda *args: l.append(None) reactor.connectUNIX('echo.skt', factory) util.spinWhile(lambda: not l) self.assertEqual(l, [None])
def testClosePortInProtocolFactory(self): f = ClosingFactory() port = reactor.listenTCP(0, f, interface="127.0.0.1") self.n = port.getHost().port self.ports.append(port) f.port = port clientF = MyClientFactory() reactor.connectTCP("127.0.0.1", self.n, clientF) spinWhile(lambda: (not clientF.protocol or not clientF.protocol.closed)) self.assert_(clientF.protocol.made) self.assert_(port.disconnected) clientF.lostReason.trap(error.ConnectionDone)
def testUDP(self): if not interfaces.IReactorUDP(reactor, None): raise unittest.SkipTest, "This reactor does not support UDP sockets" p = protocol.DatagramProtocol() t = internet.TCPServer(0, p) t.startService() num = t._port.getHost().port l = [] defer.maybeDeferred(t.stopService).addCallback(l.append) util.spinWhile(lambda: not l) t = internet.TCPServer(num, p) t.startService() l = [] defer.maybeDeferred(t.stopService).addCallback(l.append) util.spinWhile(lambda: not l)
def testStoppingServer(self): if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" factory = protocol.ServerFactory() factory.protocol = wire.Echo t = internet.UNIXServer("echo.skt", factory) t.startService() t.stopService() self.failIf(t.running) factory = protocol.ClientFactory() l = [] factory.clientConnectionFailed = lambda *args: l.append(None) reactor.connectUNIX("echo.skt", factory) util.spinWhile(lambda: not l) self.assertEqual(l, [None])
def loopbackUNIX(server, client, noisy=True): """Run session between server and client protocol instances over UNIX socket.""" path = tempfile.mktemp() from twisted.internet import reactor f = protocol.Factory() f.noisy = noisy f.buildProtocol = lambda addr, p=server: p serverPort = reactor.listenUNIX(path, f) reactor.iterate() clientF = LoopbackClientFactory(client) clientF.noisy = noisy reactor.connectUNIX(path, clientF) spinUntil(lambda :clientF.disconnected) # A spinWhile(lambda :server.transport.connected) # B serverPort.stopListening() spinWhile(lambda :serverPort.connected) # C
def loopbackUNIX(server, client, noisy=True): """Run session between server and client protocol instances over UNIX socket.""" path = tempfile.mktemp() from twisted.internet import reactor f = protocol.Factory() f.noisy = noisy f.buildProtocol = lambda addr, p=server: p serverPort = reactor.listenUNIX(path, f) reactor.iterate() clientF = LoopbackClientFactory(client) clientF.noisy = noisy reactor.connectUNIX(path, clientF) spinUntil(lambda: clientF.disconnected) # A spinWhile(lambda: server.transport.connected) # B serverPort.stopListening() spinWhile(lambda: serverPort.connected) # C
def testExchange(self): clientaddr = self.mktemp() serveraddr = self.mktemp() sp = ServerProto() cp = ClientProto() s = reactor.listenUNIXDatagram(serveraddr, sp) c = reactor.connectUNIXDatagram(serveraddr, cp, bindAddress = clientaddr) spinUntil(lambda:sp.started and cp.started) cp.transport.write("hi") spinUntil(lambda:sp.gotwhat == "hi" and cp.gotback == "hi back") s.stopListening() c.stopListening() os.unlink(clientaddr) os.unlink(serveraddr) spinWhile(lambda:s.connected and c.connected) self.failUnlessEqual("hi", sp.gotwhat) self.failUnlessEqual(clientaddr, sp.gotfrom) self.failUnlessEqual("hi back", cp.gotback)
def loopbackTCP(server, client, port=0, noisy=True): """Run session between server and client protocol instances over TCP.""" from twisted.internet import reactor f = protocol.Factory() f.noisy = noisy f.buildProtocol = lambda addr, p=server: p serverPort = reactor.listenTCP(port, f, interface='127.0.0.1') reactor.iterate() clientF = LoopbackClientFactory(client) clientF.noisy = noisy reactor.connectTCP('127.0.0.1', serverPort.getHost().port, clientF) # this needs to wait until: # A: the client has disconnected # B: the server has noticed, and its own socket has disconnected # C: the listening socket has been shut down spinUntil(lambda: clientF.disconnected) # A spinWhile(lambda: server.transport.connected) # B serverPort.stopListening() spinWhile(lambda: serverPort.connected) # C
def loopbackTCP(server, client, port=0, noisy=True): """Run session between server and client protocol instances over TCP.""" from twisted.internet import reactor f = protocol.Factory() f.noisy = noisy f.buildProtocol = lambda addr, p=server: p serverPort = reactor.listenTCP(port, f, interface='127.0.0.1') reactor.iterate() clientF = LoopbackClientFactory(client) clientF.noisy = noisy reactor.connectTCP('127.0.0.1', serverPort.getHost().port, clientF) # this needs to wait until: # A: the client has disconnected # B: the server has noticed, and its own socket has disconnected # C: the listening socket has been shut down spinUntil(lambda :clientF.disconnected) # A spinWhile(lambda :server.transport.connected) # B serverPort.stopListening() spinWhile(lambda :serverPort.connected) # C
def testServerStartStop(self): f = StartStopFactory() # listen on port p1 = reactor.listenTCP(0, f, interface='127.0.0.1') self.n1 = p1.getHost().port self.ports.append(p1) spinUntil(lambda: (p1.connected == 1)) self.assertEquals((f.started, f.stopped), (1, 0)) # listen on two more ports p2 = reactor.listenTCP(0, f, interface='127.0.0.1') self.n2 = p2.getHost().port self.ports.append(p2) p3 = reactor.listenTCP(0, f, interface='127.0.0.1') self.n3 = p3.getHost().port self.ports.append(p3) spinUntil(lambda: (p2.connected == 1 and p3.connected == 1)) self.assertEquals((f.started, f.stopped), (1, 0)) # close two ports p1.stopListening() p2.stopListening() spinWhile(lambda: (p1.connected == 1 or p2.connected == 1)) self.assertEquals((f.started, f.stopped), (1, 0)) # close last port p3.stopListening() spinWhile(lambda: (p3.connected == 1)) self.assertEquals((f.started, f.stopped), (1, 1)) return self.cleanPorts(*self.ports)
def testUNIX(self): # FIXME: This test is far too dense. It needs comments. # -- spiv, 2004-11-07 if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" s = service.MultiService() s.startService() factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() t = internet.UNIXServer('echo.skt', factory) t.setServiceParent(s) class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write('lalala\r\n') def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None internet.UNIXClient('echo.skt', factory).setServiceParent(s) util.spinWhile(lambda: factory.line is None) self.assertEqual(factory.line, 'lalala') util.wait(defer.maybeDeferred(s.stopService)) util.wait(TestEcho.d) TestEcho.d = defer.Deferred() factory.line = None s.startService() util.spinWhile(lambda: factory.line is None) self.assertEqual(factory.line, 'lalala') # Cleanup the reactor util.wait(defer.maybeDeferred(s.stopService)) util.wait(TestEcho.d)
def testServerStartStop(self): f = StartStopFactory() # listen on port p1 = reactor.listenTCP(0, f, interface='127.0.0.1') self.n1 = p1.getHost().port self.ports.append(p1) spinUntil(lambda :(p1.connected == 1)) self.assertEquals((f.started, f.stopped), (1,0)) # listen on two more ports p2 = reactor.listenTCP(0, f, interface='127.0.0.1') self.n2 = p2.getHost().port self.ports.append(p2) p3 = reactor.listenTCP(0, f, interface='127.0.0.1') self.n3 = p3.getHost().port self.ports.append(p3) spinUntil(lambda :(p2.connected == 1 and p3.connected == 1)) self.assertEquals((f.started, f.stopped), (1, 0)) # close two ports p1.stopListening() p2.stopListening() spinWhile(lambda :(p1.connected == 1 or p2.connected == 1)) self.assertEquals((f.started, f.stopped), (1, 0)) # close last port p3.stopListening() spinWhile(lambda :(p3.connected == 1)) self.assertEquals((f.started, f.stopped), (1, 1)) return self.cleanPorts(*self.ports)
def testUNIX(self): # FIXME: This test is far too dense. It needs comments. # -- spiv, 2004-11-07 if not interfaces.IReactorUNIX(reactor, None): raise unittest.SkipTest, "This reactor does not support UNIX domain sockets" s = service.MultiService() s.startService() factory = protocol.ServerFactory() factory.protocol = TestEcho TestEcho.d = defer.Deferred() t = internet.UNIXServer('echo.skt', factory) t.setServiceParent(s) class Foo(basic.LineReceiver): def connectionMade(self): self.transport.write('lalala\r\n') def lineReceived(self, line): self.factory.line = line self.transport.loseConnection() factory = protocol.ClientFactory() factory.protocol = Foo factory.line = None internet.UNIXClient('echo.skt', factory).setServiceParent(s) util.spinWhile(lambda :factory.line is None) self.assertEqual(factory.line, 'lalala') util.wait(defer.maybeDeferred(s.stopService)) util.wait(TestEcho.d) TestEcho.d = defer.Deferred() factory.line = None s.startService() util.spinWhile(lambda :factory.line is None) self.assertEqual(factory.line, 'lalala') # Cleanup the reactor util.wait(defer.maybeDeferred(s.stopService)) util.wait(TestEcho.d)
def testTimer(self): l = [] t = internet.TimerService(1, l.append, "hello") t.startService() util.spinWhile(lambda: not l, timeout=30) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() t.startService() util.spinWhile(lambda: not l, timeout=30) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() t = internet.TimerService(0.01, l.append, "hello") t.startService() util.spinWhile(lambda: len(l) < 10, timeout=30) t.stopService() self.assertEqual(l, ["hello"] * 10)
def testTimer(self): l = [] t = internet.TimerService(1, l.append, "hello") t.startService() util.spinWhile(lambda: not l, timeout=30) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() # restart the same TimerService t.startService() util.spinWhile(lambda: not l, timeout=30) t.stopService() self.failIf(t.running) self.assertEqual(l, ["hello"]) l.pop() t = internet.TimerService(0.01, l.append, "hello") t.startService() util.spinWhile(lambda: len(l) < 10, timeout=30) t.stopService() self.assertEqual(l, ["hello"] * 10)
def cleanPorts(self, *ports): for p in ports: if p.connected: p.loseConnection() util.spinWhile(lambda :p.connected)
def wait(self, sec_delay): wake_up = time.time() + sec_delay def _waiting(): return time.time() < wake_up util.spinWhile(_waiting, sec_delay+1)
def wait(self, sec_delay): self.wake_up = time.time()+sec_delay util.spinWhile(self._waiting, sec_delay+1)