Index: third_party/twisted_8_1/twisted/test/test_tcp_internals.py |
diff --git a/third_party/twisted_8_1/twisted/test/test_tcp_internals.py b/third_party/twisted_8_1/twisted/test/test_tcp_internals.py |
deleted file mode 100644 |
index e4bf5bd3ddc43906e4f9307de87e92504905a495..0000000000000000000000000000000000000000 |
--- a/third_party/twisted_8_1/twisted/test/test_tcp_internals.py |
+++ /dev/null |
@@ -1,240 +0,0 @@ |
-# Copyright (c) 2006 Twisted Matrix Laboratories. |
-# See LICENSE for details. |
- |
-""" |
-Whitebox tests for TCP APIs. |
-""" |
- |
-import errno, socket, os |
- |
-try: |
- import resource |
-except ImportError: |
- resource = None |
- |
-from twisted.trial.unittest import TestCase |
- |
-from twisted.python import log |
-from twisted.internet.tcp import ECONNABORTED, ENOMEM, ENFILE, EMFILE, ENOBUFS, EINPROGRESS, Port |
-from twisted.internet.protocol import ServerFactory |
-from twisted.python.runtime import platform |
-from twisted.internet.defer import maybeDeferred, gatherResults |
-from twisted.internet import reactor, interfaces |
- |
- |
-class PlatformAssumptionsTestCase(TestCase): |
- """ |
- Test assumptions about platform behaviors. |
- """ |
- socketLimit = 8192 |
- |
- def setUp(self): |
- self.openSockets = [] |
- if resource is not None: |
- self.originalFileLimit = resource.getrlimit(resource.RLIMIT_NOFILE) |
- resource.setrlimit(resource.RLIMIT_NOFILE, (128, self.originalFileLimit[1])) |
- self.socketLimit = 256 |
- |
- |
- def tearDown(self): |
- while self.openSockets: |
- self.openSockets.pop().close() |
- if resource is not None: |
- # OS X implicitly lowers the hard limit in the setrlimit call |
- # above. Retrieve the new hard limit to pass in to this |
- # setrlimit call, so that it doesn't give us a permission denied |
- # error. |
- currentHardLimit = resource.getrlimit(resource.RLIMIT_NOFILE)[1] |
- newSoftLimit = min(self.originalFileLimit[0], currentHardLimit) |
- resource.setrlimit(resource.RLIMIT_NOFILE, (newSoftLimit, currentHardLimit)) |
- |
- |
- def socket(self): |
- """ |
- Create and return a new socket object, also tracking it so it can be |
- closed in the test tear down. |
- """ |
- s = socket.socket() |
- self.openSockets.append(s) |
- return s |
- |
- |
- def test_acceptOutOfFiles(self): |
- """ |
- Test that the platform accept(2) call fails with either L{EMFILE} or |
- L{ENOBUFS} when there are too many file descriptors open. |
- """ |
- # Make a server to which to connect |
- port = self.socket() |
- port.bind(('127.0.0.1', 0)) |
- serverPortNumber = port.getsockname()[1] |
- port.listen(5) |
- |
- # Use up all the file descriptors |
- for i in xrange(self.socketLimit): |
- try: |
- self.socket() |
- except socket.error, e: |
- if e.args[0] in (EMFILE, ENOBUFS): |
- self.openSockets.pop().close() |
- break |
- else: |
- raise |
- else: |
- self.fail("Could provoke neither EMFILE nor ENOBUFS from platform.") |
- |
- # Make a client to use to connect to the server |
- client = self.socket() |
- client.setblocking(False) |
- |
- # Non-blocking connect is supposed to fail, but this is not true |
- # everywhere (e.g. freeBSD) |
- self.assertIn(client.connect_ex(('127.0.0.1', serverPortNumber)), |
- (0, EINPROGRESS)) |
- |
- # Make sure that the accept call fails in the way we expect. |
- exc = self.assertRaises(socket.error, port.accept) |
- self.assertIn(exc.args[0], (EMFILE, ENOBUFS)) |
- if platform.getType() == "win32": |
- test_acceptOutOfFiles.skip = ( |
- "Windows requires an unacceptably large amount of resources to " |
- "provoke this behavior in the naive manner.") |
- |
- |
- |
-class SelectReactorTestCase(TestCase): |
- """ |
- Tests for select-specific failure conditions. |
- """ |
- |
- def setUp(self): |
- self.ports = [] |
- self.messages = [] |
- log.addObserver(self.messages.append) |
- |
- |
- def tearDown(self): |
- log.removeObserver(self.messages.append) |
- return gatherResults([ |
- maybeDeferred(p.stopListening) |
- for p in self.ports]) |
- |
- |
- def port(self, portNumber, factory, interface): |
- """ |
- Create, start, and return a new L{Port}, also tracking it so it can |
- be stopped in the test tear down. |
- """ |
- p = Port(portNumber, factory, interface=interface) |
- p.startListening() |
- self.ports.append(p) |
- return p |
- |
- |
- def _acceptFailureTest(self, socketErrorNumber): |
- """ |
- Test behavior in the face of an exception from C{accept(2)}. |
- |
- On any exception which indicates the platform is unable or unwilling |
- to allocate further resources to us, the existing port should remain |
- listening, a message should be logged, and the exception should not |
- propagate outward from doRead. |
- |
- @param socketErrorNumber: The errno to simulate from accept. |
- """ |
- class FakeSocket(object): |
- """ |
- Pretend to be a socket in an overloaded system. |
- """ |
- def accept(self): |
- raise socket.error( |
- socketErrorNumber, os.strerror(socketErrorNumber)) |
- |
- factory = ServerFactory() |
- port = self.port(0, factory, interface='127.0.0.1') |
- originalSocket = port.socket |
- try: |
- port.socket = FakeSocket() |
- |
- port.doRead() |
- |
- expectedFormat = "Could not accept new connection (%s)" |
- expectedErrorCode = errno.errorcode[socketErrorNumber] |
- expectedMessage = expectedFormat % (expectedErrorCode,) |
- for msg in self.messages: |
- if msg.get('message') == (expectedMessage,): |
- break |
- else: |
- self.fail("Log event for failed accept not found in " |
- "%r" % (self.messages,)) |
- finally: |
- port.socket = originalSocket |
- |
- |
- def test_tooManyFilesFromAccept(self): |
- """ |
- C{accept(2)} can fail with C{EMFILE} when there are too many open file |
- descriptors in the process. Test that this doesn't negatively impact |
- any other existing connections. |
- |
- C{EMFILE} mainly occurs on Linux when the open file rlimit is |
- encountered. |
- """ |
- return self._acceptFailureTest(EMFILE) |
- |
- |
- def test_noBufferSpaceFromAccept(self): |
- """ |
- Similar to L{test_tooManyFilesFromAccept}, but test the case where |
- C{accept(2)} fails with C{ENOBUFS}. |
- |
- This mainly occurs on Windows and FreeBSD, but may be possible on |
- Linux and other platforms as well. |
- """ |
- return self._acceptFailureTest(ENOBUFS) |
- |
- |
- def test_connectionAbortedFromAccept(self): |
- """ |
- Similar to L{test_tooManyFilesFromAccept}, but test the case where |
- C{accept(2)} fails with C{ECONNABORTED}. |
- |
- It is not clear whether this is actually possible for TCP |
- connections on modern versions of Linux. |
- """ |
- return self._acceptFailureTest(ECONNABORTED) |
- |
- |
- def test_noFilesFromAccept(self): |
- """ |
- Similar to L{test_tooManyFilesFromAccept}, but test the case where |
- C{accept(2)} fails with C{ENFILE}. |
- |
- This can occur on Linux when the system has exhausted (!) its supply |
- of inodes. |
- """ |
- return self._acceptFailureTest(ENFILE) |
- if platform.getType() == 'win32': |
- test_noFilesFromAccept.skip = "Windows accept(2) cannot generate ENFILE" |
- |
- |
- def test_noMemoryFromAccept(self): |
- """ |
- Similar to L{test_tooManyFilesFromAccept}, but test the case where |
- C{accept(2)} fails with C{ENOMEM}. |
- |
- On Linux at least, this can sensibly occur, even in a Python program |
- (which eats memory like no ones business), when memory has become |
- fragmented or low memory has been filled (d_alloc calls |
- kmem_cache_alloc calls kmalloc - kmalloc only allocates out of low |
- memory). |
- """ |
- return self._acceptFailureTest(ENOMEM) |
- if platform.getType() == 'win32': |
- test_noMemoryFromAccept.skip = "Windows accept(2) cannot generate ENOMEM" |
- |
-if not interfaces.IReactorFDSet.providedBy(reactor): |
- skipMsg = 'This test only applies to reactors that implement IReactorFDset' |
- PlatformAssumptionsTestCase.skip = skipMsg |
- SelectReactorTestCase.skip = skipMsg |
- |