def test_UDP(self): """ Test L{internet.UDPServer} with a random port: starting the service should give it valid port, and stopService should free it so that we can start a server on the same port again. """ if not interfaces.IReactorUDP(reactor, None): raise unittest.SkipTest("This reactor does not support UDP sockets") p = protocol.DatagramProtocol() t = internet.UDPServer(0, p) t.startService() num = t._port.getHost().port self.assertNotEquals(num, 0) def onStop(ignored): t = internet.UDPServer(num, p) t.startService() return t.stopService() return defer.maybeDeferred(t.stopService).addCallback(onStop)
maybeDeferred(secondPort.stopListening) ]) result.addCallback(lambda ign: passthrough) return result joined.addBoth(cleanup) return joined if runtime.platform.isWindows(): test_multiListen.skip = ( "on non-linux platforms it appears multiple " "processes can listen, but not multiple sockets " "in same process?") if not interfaces.IReactorUDP(reactor, None): UDPTestCase.skip = "This reactor does not support UDP" ReactorShutdownInteraction.skip = "This reactor does not support UDP" if not interfaces.IReactorMulticast(reactor, None): MulticastTestCase.skip = "This reactor does not support multicast" def checkForLinux22(): import os if os.path.exists("/proc/version"): s = open("/proc/version").read() if s.startswith("Linux version"): s = s.split()[2] if s.split(".")[:2] == ["2", "2"]: f = MulticastTestCase.testInterface.im_func f.todo = "figure out why this fails in linux 2.2"
def setDeferred(self, d): """ Set the Deferred which will be called back when datagramReceived is called. """ self.d = d def datagramReceived(self, bytes, addr): if self.d is not None: d, self.d = self.d, None d.callback(bytes) raise BadClientError("Application code is very buggy!") @skipIf(not interfaces.IReactorUDP(reactor, None), "This reactor does not support UDP") class UDPTests(TestCase): def test_oldAddress(self): """ The C{type} of the host address of a listening L{DatagramProtocol}'s transport is C{"UDP"}. """ server = Server() d = server.startedDeferred = defer.Deferred() p = reactor.listenUDP(0, server, interface="127.0.0.1") def cbStarted(ignored): addr = p.getHost() self.assertEqual(addr.type, 'UDP') return p.stopListening()
def setDeferred(self, d): """ Set the Deferred which will be called back when datagramReceived is called. """ self.d = d def datagramReceived(self, bytes, addr): if self.d is not None: d, self.d = self.d, None d.callback(bytes) raise BadClientError("Application code is very buggy!") @skipIf(not interfaces.IReactorUDP(reactor, None), "This reactor does not support UDP") class UDPTests(TestCase): def test_oldAddress(self): """ The C{type} of the host address of a listening L{DatagramProtocol}'s transport is C{"UDP"}. """ server = Server() d = server.startedDeferred = defer.Deferred() p = reactor.listenUDP(0, server, interface="127.0.0.1") def cbStarted(ignored): addr = p.getHost() self.assertEqual(addr.type, "UDP") return p.stopListening()