Left: | ||
Right: |
LEFT | RIGHT |
---|---|
1 #!/usr/bin/env python3 | 1 #!/usr/bin/env python3 |
2 | 2 |
3 import unittest | 3 import unittest |
4 from test import support | 4 from test import support |
5 | 5 |
6 import errno | 6 import errno |
7 import io | 7 import io |
8 import socket | 8 import socket |
9 import select | 9 import select |
10 import tempfile | 10 import tempfile |
11 import _testcapi | 11 import _testcapi |
12 import time | 12 import time |
13 import traceback | 13 import traceback |
14 import queue | 14 import queue |
15 import sys | 15 import sys |
16 import os | 16 import os |
17 import array | 17 import array |
18 import platform | |
19 import contextlib | |
18 from weakref import proxy | 20 from weakref import proxy |
19 import signal | 21 import signal |
22 import math | |
23 try: | |
24 import fcntl | |
25 except ImportError: | |
26 fcntl = False | |
27 | |
28 def try_address(host, port=0, family=socket.AF_INET): | |
29 """Try to bind a socket on the given host:port and return True | |
30 if that has been possible.""" | |
31 try: | |
32 sock = socket.socket(family, socket.SOCK_STREAM) | |
33 sock.bind((host, port)) | |
34 except (socket.error, socket.gaierror): | |
35 return False | |
36 else: | |
37 sock.close() | |
38 return True | |
39 | |
40 def linux_version(): | |
41 try: | |
42 # platform.release() is something like '2.6.33.7-desktop-2mnb' | |
43 version_string = platform.release().split('-')[0] | |
44 return tuple(map(int, version_string.split('.'))) | |
45 except ValueError: | |
46 return 0, 0, 0 | |
20 | 47 |
21 HOST = support.HOST | 48 HOST = support.HOST |
22 MSG = b'Michael Gilfix was here\n' | 49 MSG = 'Michael Gilfix was here\u1234\r\n'.encode('utf8') ## test unicode string and carriage return |
50 SUPPORTS_IPV6 = socket.has_ipv6 and try_address('::1', family=socket.AF_INET6) | |
23 | 51 |
24 try: | 52 try: |
25 import _thread as thread | 53 import _thread as thread |
26 import threading | 54 import threading |
27 except ImportError: | 55 except ImportError: |
28 thread = None | 56 thread = None |
29 threading = None | 57 threading = None |
30 | 58 |
31 # Size in bytes of the int type | 59 # Size in bytes of the int type |
32 SIZEOF_INT = array.array("i").itemsize | 60 SIZEOF_INT = array.array("i").itemsize |
(...skipping 108 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
141 self.__setUp() | 169 self.__setUp() |
142 if not self.server_ready.is_set(): | 170 if not self.server_ready.is_set(): |
143 self.server_ready.set() | 171 self.server_ready.set() |
144 self.client_ready.wait() | 172 self.client_ready.wait() |
145 | 173 |
146 def _tearDown(self): | 174 def _tearDown(self): |
147 self.__tearDown() | 175 self.__tearDown() |
148 self.done.wait() | 176 self.done.wait() |
149 | 177 |
150 if self.queue.qsize(): | 178 if self.queue.qsize(): |
151 msg = self.queue.get() | 179 exc = self.queue.get() |
152 self.fail(msg) | 180 raise exc |
153 | 181 |
154 def clientRun(self, test_func): | 182 def clientRun(self, test_func): |
155 self.server_ready.wait() | 183 self.server_ready.wait() |
156 self.client_ready.set() | 184 self.client_ready.set() |
157 self.clientSetUp() | 185 self.clientSetUp() |
158 if not hasattr(test_func, '__call__'): | 186 if not hasattr(test_func, '__call__'): |
159 raise TypeError("test_func must be a callable function") | 187 raise TypeError("test_func must be a callable function") |
160 try: | 188 try: |
161 test_func() | 189 test_func() |
162 except Exception as strerror: | 190 except BaseException as e: |
163 self.queue.put(strerror) | 191 self.queue.put(e) |
164 self.clientTearDown() | 192 finally: |
193 self.clientTearDown() | |
165 | 194 |
166 def clientSetUp(self): | 195 def clientSetUp(self): |
167 raise NotImplementedError("clientSetUp must be implemented.") | 196 raise NotImplementedError("clientSetUp must be implemented.") |
168 | 197 |
169 def clientTearDown(self): | 198 def clientTearDown(self): |
170 self.done.set() | 199 self.done.set() |
171 thread.exit() | 200 thread.exit() |
172 | 201 |
173 class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest): | 202 class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest): |
174 | 203 |
(...skipping 10 matching lines...) Expand all Loading... | |
185 ThreadableTest.clientTearDown(self) | 214 ThreadableTest.clientTearDown(self) |
186 | 215 |
187 class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest): | 216 class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest): |
188 | 217 |
189 def __init__(self, methodName='runTest'): | 218 def __init__(self, methodName='runTest'): |
190 SocketUDPTest.__init__(self, methodName=methodName) | 219 SocketUDPTest.__init__(self, methodName=methodName) |
191 ThreadableTest.__init__(self) | 220 ThreadableTest.__init__(self) |
192 | 221 |
193 def clientSetUp(self): | 222 def clientSetUp(self): |
194 self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) | 223 self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) |
224 | |
225 def clientTearDown(self): | |
226 self.cli.close() | |
227 self.cli = None | |
228 ThreadableTest.clientTearDown(self) | |
195 | 229 |
196 class SocketConnectedTest(ThreadedTCPSocketTest): | 230 class SocketConnectedTest(ThreadedTCPSocketTest): |
197 """Socket tests for client-server connection. | 231 """Socket tests for client-server connection. |
198 | 232 |
199 self.cli_conn is a client socket connected to the server. The | 233 self.cli_conn is a client socket connected to the server. The |
200 setUp() method guarantees that it is connected to the server. | 234 setUp() method guarantees that it is connected to the server. |
201 """ | 235 """ |
202 | 236 |
203 def __init__(self, methodName='runTest'): | 237 def __init__(self, methodName='runTest'): |
204 ThreadedTCPSocketTest.__init__(self, methodName=methodName) | 238 ThreadedTCPSocketTest.__init__(self, methodName=methodName) |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
242 def clientSetUp(self): | 276 def clientSetUp(self): |
243 pass | 277 pass |
244 | 278 |
245 def clientTearDown(self): | 279 def clientTearDown(self): |
246 self.cli.close() | 280 self.cli.close() |
247 self.cli = None | 281 self.cli = None |
248 ThreadableTest.clientTearDown(self) | 282 ThreadableTest.clientTearDown(self) |
249 | 283 |
250 | 284 |
251 # The following classes are used by the sendmsg()/recvmsg() tests. | 285 # The following classes are used by the sendmsg()/recvmsg() tests. |
252 # Combining, for instance, TCPTestBase and ConnectedSocketTestMixin | 286 # Combining, for instance, ConnectedStreamTestMixin and TCPTestBase |
253 # gives a drop-in replacement for SocketConnectedTest, but different | 287 # gives a drop-in replacement for SocketConnectedTest, but different |
254 # address families can be used, and the attributes serv_addr and | 288 # address families can be used, and the attributes serv_addr and |
255 # cli_addr will be set to the addresses of the endpoints. | 289 # cli_addr will be set to the addresses of the endpoints. |
256 | 290 |
257 class SocketTestBase(unittest.TestCase): | 291 class SocketTestBase(unittest.TestCase): |
258 """A base class for socket tests. | 292 """A base class for socket tests. |
259 | 293 |
260 Subclasses must provide methods newSocket() to return a new socket | 294 Subclasses must provide methods newSocket() to return a new socket |
261 and bindSock(sock) to bind it to an unused address. | 295 and bindSock(sock) to bind it to an unused address. |
262 | 296 |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
309 """Bind client socket and set self.cli_addr to its address.""" | 343 """Bind client socket and set self.cli_addr to its address.""" |
310 self.bindSock(self.cli) | 344 self.bindSock(self.cli) |
311 self.cli_addr = self.cli.getsockname() | 345 self.cli_addr = self.cli.getsockname() |
312 | 346 |
313 def clientTearDown(self): | 347 def clientTearDown(self): |
314 self.cli.close() | 348 self.cli.close() |
315 self.cli = None | 349 self.cli = None |
316 ThreadableTest.clientTearDown(self) | 350 ThreadableTest.clientTearDown(self) |
317 | 351 |
318 | 352 |
319 class ConnectedSocketTestMixin(SocketListeningTestMixin, | 353 class ConnectedStreamTestMixin(SocketListeningTestMixin, |
320 ThreadedSocketTestMixin): | 354 ThreadedSocketTestMixin): |
321 """Mixin to allow client/server stream tests with connected client. | 355 """Mixin to allow client/server stream tests with connected client. |
322 | 356 |
323 Server's socket representing connection to client is self.cli_conn | 357 Server's socket representing connection to client is self.cli_conn |
324 and client's connection to server is self.serv_conn. (Based on | 358 and client's connection to server is self.serv_conn. (Based on |
325 SocketConnectedTest.) | 359 SocketConnectedTest.) |
326 """ | 360 """ |
327 | 361 |
328 def setUp(self): | 362 def setUp(self): |
329 super().setUp() | 363 super().setUp() |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
379 | 413 |
380 host = HOST | 414 host = HOST |
381 | 415 |
382 def setUp(self): | 416 def setUp(self): |
383 super().setUp() | 417 super().setUp() |
384 self.port = self.serv_addr[1] | 418 self.port = self.serv_addr[1] |
385 | 419 |
386 def bindSock(self, sock): | 420 def bindSock(self, sock): |
387 support.bind_port(sock, host=self.host) | 421 support.bind_port(sock, host=self.host) |
388 | 422 |
389 class TCPTestBase(InetTestBase): | 423 class TCPTestBase(InetTestBase): |
Antoine Pitrou
2010/06/10 19:05:20
Is such a forest of subclasses and mixins really n
baikie
2010/06/10 21:50:48
Perhaps it could be tidied up, but I modelled them
| |
390 """Base class for TCP-over-IPv4 tests.""" | 424 """Base class for TCP-over-IPv4 tests.""" |
391 | 425 |
392 def newSocket(self): | 426 def newSocket(self): |
393 return socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 427 return socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
394 | 428 |
395 class UDPTestBase(InetTestBase): | 429 class UDPTestBase(InetTestBase): |
396 """Base class for UDP-over-IPv4 tests.""" | 430 """Base class for UDP-over-IPv4 tests.""" |
397 | 431 |
398 def newSocket(self): | 432 def newSocket(self): |
399 return socket.socket(socket.AF_INET, socket.SOCK_DGRAM) | 433 return socket.socket(socket.AF_INET, socket.SOCK_DGRAM) |
(...skipping 85 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
485 ", ".join(str(o) for o in args), err)) | 519 ", ".join(str(o) for o in args), err)) |
486 | 520 |
487 | 521 |
488 ####################################################################### | 522 ####################################################################### |
489 ## Begin Tests | 523 ## Begin Tests |
490 | 524 |
491 class GeneralModuleTests(unittest.TestCase): | 525 class GeneralModuleTests(unittest.TestCase): |
492 | 526 |
493 def test_repr(self): | 527 def test_repr(self): |
494 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 528 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
529 self.addCleanup(s.close) | |
495 self.assertTrue(repr(s).startswith("<socket.socket object")) | 530 self.assertTrue(repr(s).startswith("<socket.socket object")) |
496 | 531 |
497 def test_weakref(self): | 532 def test_weakref(self): |
498 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 533 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
499 p = proxy(s) | 534 p = proxy(s) |
500 self.assertEqual(p.fileno(), s.fileno()) | 535 self.assertEqual(p.fileno(), s.fileno()) |
501 s.close() | 536 s.close() |
502 s = None | 537 s = None |
503 try: | 538 try: |
504 p.fileno() | 539 p.fileno() |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
597 self.assertRaises(OverflowError, socket.ntohl, k) | 632 self.assertRaises(OverflowError, socket.ntohl, k) |
598 self.assertRaises(OverflowError, socket.ntohs, k) | 633 self.assertRaises(OverflowError, socket.ntohs, k) |
599 self.assertRaises(OverflowError, socket.htonl, k) | 634 self.assertRaises(OverflowError, socket.htonl, k) |
600 self.assertRaises(OverflowError, socket.htons, k) | 635 self.assertRaises(OverflowError, socket.htons, k) |
601 | 636 |
602 def testGetServBy(self): | 637 def testGetServBy(self): |
603 eq = self.assertEqual | 638 eq = self.assertEqual |
604 # Find one service that exists, then check all the related interfaces. | 639 # Find one service that exists, then check all the related interfaces. |
605 # I've ordered this by protocols that have both a tcp and udp | 640 # I've ordered this by protocols that have both a tcp and udp |
606 # protocol, at least for modern Linuxes. | 641 # protocol, at least for modern Linuxes. |
607 if sys.platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6', | 642 if (sys.platform.startswith('linux') or |
608 'freebsd7', 'freebsd8', 'darwin'): | 643 sys.platform.startswith('freebsd') or |
644 sys.platform.startswith('netbsd') or | |
645 sys.platform == 'darwin'): | |
609 # avoid the 'echo' service on this platform, as there is an | 646 # avoid the 'echo' service on this platform, as there is an |
610 # assumption breaking non-standard port/protocol entry | 647 # assumption breaking non-standard port/protocol entry |
611 services = ('daytime', 'qotd', 'domain') | 648 services = ('daytime', 'qotd', 'domain') |
612 else: | 649 else: |
613 services = ('echo', 'daytime', 'domain') | 650 services = ('echo', 'daytime', 'domain') |
614 for service in services: | 651 for service in services: |
615 try: | 652 try: |
616 port = socket.getservbyname(service, 'tcp') | 653 port = socket.getservbyname(service, 'tcp') |
617 break | 654 break |
618 except socket.error: | 655 except socket.error: |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
664 self.assertRaises(ValueError, socket.setdefaulttimeout, -1) | 701 self.assertRaises(ValueError, socket.setdefaulttimeout, -1) |
665 | 702 |
666 # Check that setting it to an invalid type raises TypeError | 703 # Check that setting it to an invalid type raises TypeError |
667 self.assertRaises(TypeError, socket.setdefaulttimeout, "spam") | 704 self.assertRaises(TypeError, socket.setdefaulttimeout, "spam") |
668 | 705 |
669 def testIPv4_inet_aton_fourbytes(self): | 706 def testIPv4_inet_aton_fourbytes(self): |
670 if not hasattr(socket, 'inet_aton'): | 707 if not hasattr(socket, 'inet_aton'): |
671 return # No inet_aton, nothing to check | 708 return # No inet_aton, nothing to check |
672 # Test that issue1008086 and issue767150 are fixed. | 709 # Test that issue1008086 and issue767150 are fixed. |
673 # It must return 4 bytes. | 710 # It must return 4 bytes. |
674 self.assertEquals(b'\x00'*4, socket.inet_aton('0.0.0.0')) | 711 self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0')) |
675 self.assertEquals(b'\xff'*4, socket.inet_aton('255.255.255.255')) | 712 self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255')) |
676 | 713 |
677 def testIPv4toString(self): | 714 def testIPv4toString(self): |
678 if not hasattr(socket, 'inet_pton'): | 715 if not hasattr(socket, 'inet_pton'): |
679 return # No inet_pton() on this platform | 716 return # No inet_pton() on this platform |
680 from socket import inet_aton as f, inet_pton, AF_INET | 717 from socket import inet_aton as f, inet_pton, AF_INET |
681 g = lambda a: inet_pton(AF_INET, a) | 718 g = lambda a: inet_pton(AF_INET, a) |
682 | 719 |
683 self.assertEquals(b'\x00\x00\x00\x00', f('0.0.0.0')) | 720 self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0')) |
684 self.assertEquals(b'\xff\x00\xff\x00', f('255.0.255.0')) | 721 self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0')) |
685 self.assertEquals(b'\xaa\xaa\xaa\xaa', f('170.170.170.170')) | 722 self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170')) |
686 self.assertEquals(b'\x01\x02\x03\x04', f('1.2.3.4')) | 723 self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4')) |
687 self.assertEquals(b'\xff\xff\xff\xff', f('255.255.255.255')) | 724 self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255')) |
688 | 725 |
689 self.assertEquals(b'\x00\x00\x00\x00', g('0.0.0.0')) | 726 self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0')) |
690 self.assertEquals(b'\xff\x00\xff\x00', g('255.0.255.0')) | 727 self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0')) |
691 self.assertEquals(b'\xaa\xaa\xaa\xaa', g('170.170.170.170')) | 728 self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170')) |
692 self.assertEquals(b'\xff\xff\xff\xff', g('255.255.255.255')) | 729 self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255')) |
693 | 730 |
694 def testIPv6toString(self): | 731 def testIPv6toString(self): |
695 if not hasattr(socket, 'inet_pton'): | 732 if not hasattr(socket, 'inet_pton'): |
696 return # No inet_pton() on this platform | 733 return # No inet_pton() on this platform |
697 try: | 734 try: |
698 from socket import inet_pton, AF_INET6, has_ipv6 | 735 from socket import inet_pton, AF_INET6, has_ipv6 |
699 if not has_ipv6: | 736 if not has_ipv6: |
700 return | 737 return |
701 except ImportError: | 738 except ImportError: |
702 return | 739 return |
703 f = lambda a: inet_pton(AF_INET6, a) | 740 f = lambda a: inet_pton(AF_INET6, a) |
704 | 741 |
705 self.assertEquals(b'\x00' * 16, f('::')) | 742 self.assertEqual(b'\x00' * 16, f('::')) |
706 self.assertEquals(b'\x00' * 16, f('0::0')) | 743 self.assertEqual(b'\x00' * 16, f('0::0')) |
707 self.assertEquals(b'\x00\x01' + b'\x00' * 14, f('1::')) | 744 self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::')) |
708 self.assertEquals( | 745 self.assertEqual( |
709 b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae', | 746 b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae', |
710 f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae') | 747 f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae') |
711 ) | 748 ) |
712 | 749 |
713 def testStringToIPv4(self): | 750 def testStringToIPv4(self): |
714 if not hasattr(socket, 'inet_ntop'): | 751 if not hasattr(socket, 'inet_ntop'): |
715 return # No inet_ntop() on this platform | 752 return # No inet_ntop() on this platform |
716 from socket import inet_ntoa as f, inet_ntop, AF_INET | 753 from socket import inet_ntoa as f, inet_ntop, AF_INET |
717 g = lambda a: inet_ntop(AF_INET, a) | 754 g = lambda a: inet_ntop(AF_INET, a) |
718 | 755 |
719 self.assertEquals('1.0.1.0', f(b'\x01\x00\x01\x00')) | 756 self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00')) |
720 self.assertEquals('170.85.170.85', f(b'\xaa\x55\xaa\x55')) | 757 self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55')) |
721 self.assertEquals('255.255.255.255', f(b'\xff\xff\xff\xff')) | 758 self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff')) |
722 self.assertEquals('1.2.3.4', f(b'\x01\x02\x03\x04')) | 759 self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04')) |
723 | 760 |
724 self.assertEquals('1.0.1.0', g(b'\x01\x00\x01\x00')) | 761 self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00')) |
725 self.assertEquals('170.85.170.85', g(b'\xaa\x55\xaa\x55')) | 762 self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55')) |
726 self.assertEquals('255.255.255.255', g(b'\xff\xff\xff\xff')) | 763 self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff')) |
727 | 764 |
728 def testStringToIPv6(self): | 765 def testStringToIPv6(self): |
729 if not hasattr(socket, 'inet_ntop'): | 766 if not hasattr(socket, 'inet_ntop'): |
730 return # No inet_ntop() on this platform | 767 return # No inet_ntop() on this platform |
731 try: | 768 try: |
732 from socket import inet_ntop, AF_INET6, has_ipv6 | 769 from socket import inet_ntop, AF_INET6, has_ipv6 |
733 if not has_ipv6: | 770 if not has_ipv6: |
734 return | 771 return |
735 except ImportError: | 772 except ImportError: |
736 return | 773 return |
737 f = lambda a: inet_ntop(AF_INET6, a) | 774 f = lambda a: inet_ntop(AF_INET6, a) |
738 | 775 |
739 self.assertEquals('::', f(b'\x00' * 16)) | 776 self.assertEqual('::', f(b'\x00' * 16)) |
740 self.assertEquals('::1', f(b'\x00' * 15 + b'\x01')) | 777 self.assertEqual('::1', f(b'\x00' * 15 + b'\x01')) |
741 self.assertEquals( | 778 self.assertEqual( |
742 'aef:b01:506:1001:ffff:9997:55:170', | 779 'aef:b01:506:1001:ffff:9997:55:170', |
743 f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70 ') | 780 f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70 ') |
744 ) | 781 ) |
745 | 782 |
746 # XXX The following don't test module-level functionality... | 783 # XXX The following don't test module-level functionality... |
747 | 784 |
748 def _get_unused_port(self, bind_address='0.0.0.0'): | 785 def _get_unused_port(self, bind_address='0.0.0.0'): |
749 """Use a temporary socket to elicit an unused ephemeral port. | 786 """Use a temporary socket to elicit an unused ephemeral port. |
750 | 787 |
751 Args: | 788 Args: |
752 bind_address: Hostname or IP address to search for a port on. | 789 bind_address: Hostname or IP address to search for a port on. |
753 | 790 |
754 Returns: A most likely to be unused port. | 791 Returns: A most likely to be unused port. |
755 """ | 792 """ |
756 tempsock = socket.socket() | 793 tempsock = socket.socket() |
757 tempsock.bind((bind_address, 0)) | 794 tempsock.bind((bind_address, 0)) |
758 host, port = tempsock.getsockname() | 795 host, port = tempsock.getsockname() |
759 tempsock.close() | 796 tempsock.close() |
760 return port | 797 return port |
761 | 798 |
762 def testSockName(self): | 799 def testSockName(self): |
763 # Testing getsockname() | 800 # Testing getsockname() |
764 port = self._get_unused_port() | 801 port = self._get_unused_port() |
765 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 802 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
803 self.addCleanup(sock.close) | |
766 sock.bind(("0.0.0.0", port)) | 804 sock.bind(("0.0.0.0", port)) |
767 name = sock.getsockname() | 805 name = sock.getsockname() |
768 # XXX(nnorwitz): http://tinyurl.com/os5jz seems to indicate | 806 # XXX(nnorwitz): http://tinyurl.com/os5jz seems to indicate |
769 # it reasonable to get the host's addr in addition to 0.0.0.0. | 807 # it reasonable to get the host's addr in addition to 0.0.0.0. |
770 # At least for eCos. This is required for the S/390 to pass. | 808 # At least for eCos. This is required for the S/390 to pass. |
771 my_ip_addr = socket.gethostbyname(socket.gethostname()) | 809 try: |
810 my_ip_addr = socket.gethostbyname(socket.gethostname()) | |
811 except socket.error: | |
812 # Probably name lookup wasn't set up right; skip this test | |
813 return | |
772 self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0]) | 814 self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0]) |
773 self.assertEqual(name[1], port) | 815 self.assertEqual(name[1], port) |
774 | 816 |
775 def testGetSockOpt(self): | 817 def testGetSockOpt(self): |
776 # Testing getsockopt() | 818 # Testing getsockopt() |
777 # We know a socket should start without reuse==0 | 819 # We know a socket should start without reuse==0 |
778 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 820 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
821 self.addCleanup(sock.close) | |
779 reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) | 822 reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) |
780 self.assertFalse(reuse != 0, "initial mode is reuse") | 823 self.assertFalse(reuse != 0, "initial mode is reuse") |
781 | 824 |
782 def testSetSockOpt(self): | 825 def testSetSockOpt(self): |
783 # Testing setsockopt() | 826 # Testing setsockopt() |
784 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 827 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
828 self.addCleanup(sock.close) | |
785 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) | 829 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) |
786 reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) | 830 reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) |
787 self.assertFalse(reuse == 0, "failed to set reuse mode") | 831 self.assertFalse(reuse == 0, "failed to set reuse mode") |
788 | 832 |
789 def testSendAfterClose(self): | 833 def testSendAfterClose(self): |
790 # testing send() after close() with timeout | 834 # testing send() after close() with timeout |
791 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | 835 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
792 sock.settimeout(1) | 836 sock.settimeout(1) |
793 sock.close() | 837 sock.close() |
794 self.assertRaises(socket.error, sock.send, b"spam") | 838 self.assertRaises(socket.error, sock.send, b"spam") |
(...skipping 12 matching lines...) Expand all Loading... | |
807 big_port = port + 65536 | 851 big_port = port + 65536 |
808 neg_port = port - 65536 | 852 neg_port = port - 65536 |
809 sock = socket.socket() | 853 sock = socket.socket() |
810 try: | 854 try: |
811 self.assertRaises(OverflowError, sock.bind, (host, big_port)) | 855 self.assertRaises(OverflowError, sock.bind, (host, big_port)) |
812 self.assertRaises(OverflowError, sock.bind, (host, neg_port)) | 856 self.assertRaises(OverflowError, sock.bind, (host, neg_port)) |
813 sock.bind((host, port)) | 857 sock.bind((host, port)) |
814 finally: | 858 finally: |
815 sock.close() | 859 sock.close() |
816 | 860 |
861 @unittest.skipUnless(os.name == "nt", "Windows specific") | |
817 def test_sock_ioctl(self): | 862 def test_sock_ioctl(self): |
818 if os.name != "nt": | |
819 return | |
820 self.assertTrue(hasattr(socket.socket, 'ioctl')) | 863 self.assertTrue(hasattr(socket.socket, 'ioctl')) |
821 self.assertTrue(hasattr(socket, 'SIO_RCVALL')) | 864 self.assertTrue(hasattr(socket, 'SIO_RCVALL')) |
822 self.assertTrue(hasattr(socket, 'RCVALL_ON')) | 865 self.assertTrue(hasattr(socket, 'RCVALL_ON')) |
823 self.assertTrue(hasattr(socket, 'RCVALL_OFF')) | 866 self.assertTrue(hasattr(socket, 'RCVALL_OFF')) |
824 self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS')) | 867 self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS')) |
825 s = socket.socket() | 868 s = socket.socket() |
869 self.addCleanup(s.close) | |
826 self.assertRaises(ValueError, s.ioctl, -1, None) | 870 self.assertRaises(ValueError, s.ioctl, -1, None) |
827 s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 100, 100)) | 871 s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 100, 100)) |
872 | |
873 def testGetaddrinfo(self): | |
874 try: | |
875 socket.getaddrinfo('localhost', 80) | |
876 except socket.gaierror as err: | |
877 if err.errno == socket.EAI_SERVICE: | |
878 # see http://bugs.python.org/issue1282647 | |
879 self.skipTest("buggy libc version") | |
880 raise | |
881 # len of every sequence is supposed to be == 5 | |
882 for info in socket.getaddrinfo(HOST, None): | |
883 self.assertEqual(len(info), 5) | |
884 # host can be a domain name, a string representation of an | |
885 # IPv4/v6 address or None | |
886 socket.getaddrinfo('localhost', 80) | |
887 socket.getaddrinfo('127.0.0.1', 80) | |
888 socket.getaddrinfo(None, 80) | |
889 if SUPPORTS_IPV6: | |
890 socket.getaddrinfo('::1', 80) | |
891 # port can be a string service name such as "http", a numeric | |
892 # port number or None | |
893 socket.getaddrinfo(HOST, "http") | |
894 socket.getaddrinfo(HOST, 80) | |
895 socket.getaddrinfo(HOST, None) | |
896 # test family and socktype filters | |
897 infos = socket.getaddrinfo(HOST, None, socket.AF_INET) | |
898 for family, _, _, _, _ in infos: | |
899 self.assertEqual(family, socket.AF_INET) | |
900 infos = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM) | |
901 for _, socktype, _, _, _ in infos: | |
902 self.assertEqual(socktype, socket.SOCK_STREAM) | |
903 # test proto and flags arguments | |
904 socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP) | |
905 socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE) | |
906 # a server willing to support both IPv4 and IPv6 will | |
907 # usually do this | |
908 socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, | |
909 socket.AI_PASSIVE) | |
910 # test keyword arguments | |
911 a = socket.getaddrinfo(HOST, None) | |
912 b = socket.getaddrinfo(host=HOST, port=None) | |
913 self.assertEqual(a, b) | |
914 a = socket.getaddrinfo(HOST, None, socket.AF_INET) | |
915 b = socket.getaddrinfo(HOST, None, family=socket.AF_INET) | |
916 self.assertEqual(a, b) | |
917 a = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM) | |
918 b = socket.getaddrinfo(HOST, None, type=socket.SOCK_STREAM) | |
919 self.assertEqual(a, b) | |
920 a = socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP) | |
921 b = socket.getaddrinfo(HOST, None, proto=socket.SOL_TCP) | |
922 self.assertEqual(a, b) | |
923 a = socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE) | |
924 b = socket.getaddrinfo(HOST, None, flags=socket.AI_PASSIVE) | |
925 self.assertEqual(a, b) | |
926 a = socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0, | |
927 socket.AI_PASSIVE) | |
928 b = socket.getaddrinfo(host=None, port=0, family=socket.AF_UNSPEC, | |
929 type=socket.SOCK_STREAM, proto=0, | |
930 flags=socket.AI_PASSIVE) | |
931 self.assertEqual(a, b) | |
932 | |
933 def test_getnameinfo(self): | |
934 # only IP addresses are allowed | |
935 self.assertRaises(socket.error, socket.getnameinfo, ('mail.python.org',0 ), 0) | |
936 | |
937 @unittest.skipUnless(support.is_resource_enabled('network'), | |
938 'network is not enabled') | |
939 def test_idna(self): | |
940 support.requires('network') | |
941 # these should all be successful | |
942 socket.gethostbyname('испытание.python.org') | |
943 socket.gethostbyname_ex('испытание.python.org') | |
944 socket.getaddrinfo('испытание.python.org',0,socket.AF_UNSPEC,socket.SOCK _STREAM) | |
945 # this may not work if the forward lookup choses the IPv6 address, as th at doesn't | |
946 # have a reverse entry yet | |
947 # socket.gethostbyaddr('испытание.python.org') | |
948 | |
949 def check_sendall_interrupted(self, with_timeout): | |
950 # socketpair() is not stricly required, but it makes things easier. | |
951 if not hasattr(signal, 'alarm') or not hasattr(socket, 'socketpair'): | |
952 self.skipTest("signal.alarm and socket.socketpair required for this test") | |
953 # Our signal handlers clobber the C errno by calling a math function | |
954 # with an invalid domain value. | |
955 def ok_handler(*args): | |
956 self.assertRaises(ValueError, math.acosh, 0) | |
957 def raising_handler(*args): | |
958 self.assertRaises(ValueError, math.acosh, 0) | |
959 1 // 0 | |
960 c, s = socket.socketpair() | |
961 old_alarm = signal.signal(signal.SIGALRM, raising_handler) | |
962 try: | |
963 if with_timeout: | |
964 # Just above the one second minimum for signal.alarm | |
965 c.settimeout(1.5) | |
966 with self.assertRaises(ZeroDivisionError): | |
967 signal.alarm(1) | |
968 c.sendall(b"x" * (1024**2)) | |
969 if with_timeout: | |
970 signal.signal(signal.SIGALRM, ok_handler) | |
971 signal.alarm(1) | |
972 self.assertRaises(socket.timeout, c.sendall, b"x" * (1024**2)) | |
973 finally: | |
974 signal.signal(signal.SIGALRM, old_alarm) | |
975 c.close() | |
976 s.close() | |
977 | |
978 def test_sendall_interrupted(self): | |
979 self.check_sendall_interrupted(False) | |
980 | |
981 def test_sendall_interrupted_with_timeout(self): | |
982 self.check_sendall_interrupted(True) | |
983 | |
984 def test_dealloc_warn(self): | |
985 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
986 r = repr(sock) | |
987 with self.assertWarns(ResourceWarning) as cm: | |
988 sock = None | |
989 support.gc_collect() | |
990 self.assertIn(r, str(cm.warning.args[0])) | |
991 # An open socket file object gets dereferenced after the socket | |
992 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) | |
993 f = sock.makefile('rb') | |
994 r = repr(sock) | |
995 sock = None | |
996 support.gc_collect() | |
997 with self.assertWarns(ResourceWarning): | |
998 f = None | |
999 support.gc_collect() | |
828 | 1000 |
829 | 1001 |
830 @unittest.skipUnless(thread, 'Threading required for this test.') | 1002 @unittest.skipUnless(thread, 'Threading required for this test.') |
831 class BasicTCPTest(SocketConnectedTest): | 1003 class BasicTCPTest(SocketConnectedTest): |
832 | 1004 |
833 def __init__(self, methodName='runTest'): | 1005 def __init__(self, methodName='runTest'): |
834 SocketConnectedTest.__init__(self, methodName=methodName) | 1006 SocketConnectedTest.__init__(self, methodName=methodName) |
835 | 1007 |
836 def testRecv(self): | 1008 def testRecv(self): |
837 # Testing large receive over TCP | 1009 # Testing large receive over TCP |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
878 break | 1050 break |
879 msg += read | 1051 msg += read |
880 self.assertEqual(msg, b'f' * 2048) | 1052 self.assertEqual(msg, b'f' * 2048) |
881 | 1053 |
882 def _testSendAll(self): | 1054 def _testSendAll(self): |
883 big_chunk = b'f' * 2048 | 1055 big_chunk = b'f' * 2048 |
884 self.serv_conn.sendall(big_chunk) | 1056 self.serv_conn.sendall(big_chunk) |
885 | 1057 |
886 def testFromFd(self): | 1058 def testFromFd(self): |
887 # Testing fromfd() | 1059 # Testing fromfd() |
888 if not hasattr(socket, "fromfd"): | |
889 return # On Windows, this doesn't exist | |
890 fd = self.cli_conn.fileno() | 1060 fd = self.cli_conn.fileno() |
891 sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM) | 1061 sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM) |
1062 self.addCleanup(sock.close) | |
1063 self.assertIsInstance(sock, socket.socket) | |
892 msg = sock.recv(1024) | 1064 msg = sock.recv(1024) |
893 self.assertEqual(msg, MSG) | 1065 self.assertEqual(msg, MSG) |
894 | 1066 |
895 def _testFromFd(self): | 1067 def _testFromFd(self): |
896 self.serv_conn.send(MSG) | 1068 self.serv_conn.send(MSG) |
897 | 1069 |
898 def testDup(self): | 1070 def testDup(self): |
899 # Testing dup() | 1071 # Testing dup() |
900 sock = self.cli_conn.dup() | 1072 sock = self.cli_conn.dup() |
1073 self.addCleanup(sock.close) | |
901 msg = sock.recv(1024) | 1074 msg = sock.recv(1024) |
902 self.assertEqual(msg, MSG) | 1075 self.assertEqual(msg, MSG) |
903 | 1076 |
904 def _testDup(self): | 1077 def _testDup(self): |
905 self.serv_conn.send(MSG) | 1078 self.serv_conn.send(MSG) |
906 | 1079 |
907 def testShutdown(self): | 1080 def testShutdown(self): |
908 # Testing shutdown() | 1081 # Testing shutdown() |
909 msg = self.cli_conn.recv(1024) | 1082 msg = self.cli_conn.recv(1024) |
910 self.assertEqual(msg, MSG) | 1083 self.assertEqual(msg, MSG) |
911 # wait for _testShutdown to finish: on OS X, when the server | 1084 # wait for _testShutdown to finish: on OS X, when the server |
912 # closes the connection the client also becomes disconnected, | 1085 # closes the connection the client also becomes disconnected, |
913 # and the client's shutdown call will fail. (Issue #4397.) | 1086 # and the client's shutdown call will fail. (Issue #4397.) |
914 self.done.wait() | 1087 self.done.wait() |
915 | 1088 |
916 def _testShutdown(self): | 1089 def _testShutdown(self): |
917 self.serv_conn.send(MSG) | 1090 self.serv_conn.send(MSG) |
918 self.serv_conn.shutdown(2) | 1091 self.serv_conn.shutdown(2) |
1092 | |
1093 def testDetach(self): | |
1094 # Testing detach() | |
1095 fileno = self.cli_conn.fileno() | |
1096 f = self.cli_conn.detach() | |
1097 self.assertEqual(f, fileno) | |
1098 # cli_conn cannot be used anymore... | |
1099 self.assertRaises(socket.error, self.cli_conn.recv, 1024) | |
1100 self.cli_conn.close() | |
1101 # ...but we can create another socket using the (still open) | |
1102 # file descriptor | |
1103 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, fileno=f) | |
1104 self.addCleanup(sock.close) | |
1105 msg = sock.recv(1024) | |
1106 self.assertEqual(msg, MSG) | |
1107 | |
1108 def _testDetach(self): | |
1109 self.serv_conn.send(MSG) | |
919 | 1110 |
920 @unittest.skipUnless(thread, 'Threading required for this test.') | 1111 @unittest.skipUnless(thread, 'Threading required for this test.') |
921 class BasicUDPTest(ThreadedUDPSocketTest): | 1112 class BasicUDPTest(ThreadedUDPSocketTest): |
922 | 1113 |
923 def __init__(self, methodName='runTest'): | 1114 def __init__(self, methodName='runTest'): |
924 ThreadedUDPSocketTest.__init__(self, methodName=methodName) | 1115 ThreadedUDPSocketTest.__init__(self, methodName=methodName) |
925 | 1116 |
926 def testSendtoAndRecv(self): | 1117 def testSendtoAndRecv(self): |
927 # Testing sendto() and Recv() over UDP | 1118 # Testing sendto() and Recv() over UDP |
928 msg = self.serv.recv(len(MSG)) | 1119 msg = self.serv.recv(len(MSG)) |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1030 # Flags that are normally set | 1221 # Flags that are normally set |
1031 msg_flags_common_set = 0 | 1222 msg_flags_common_set = 0 |
1032 | 1223 |
1033 # Flags set when a complete record has been received (e.g. MSG_EOR | 1224 # Flags set when a complete record has been received (e.g. MSG_EOR |
1034 # for SCTP) | 1225 # for SCTP) |
1035 msg_flags_eor_indicator = 0 | 1226 msg_flags_eor_indicator = 0 |
1036 | 1227 |
1037 # Flags set when a complete record has not been received | 1228 # Flags set when a complete record has not been received |
1038 # (e.g. MSG_TRUNC for datagram sockets) | 1229 # (e.g. MSG_TRUNC for datagram sockets) |
1039 msg_flags_non_eor_indicator = 0 | 1230 msg_flags_non_eor_indicator = 0 |
1040 | |
1041 class TestError(Exception): | |
Antoine Pitrou
2010/06/12 17:18:21
You don't need this. Just use self.fail().
| |
1042 # Used to indicate errors in the test code (e.g. bad arguments | |
1043 # to checkFlags()). | |
1044 pass | |
1045 | 1231 |
1046 def checkFlags(self, flags, eor=None, checkset=0, checkunset=0, ignore=0): | 1232 def checkFlags(self, flags, eor=None, checkset=0, checkunset=0, ignore=0): |
1047 # Method to check the value of msg_flags returned by recvmsg[_into](). | 1233 # Method to check the value of msg_flags returned by recvmsg[_into](). |
1048 # | 1234 # |
1049 # Checks that all bits in msg_flags_common_set attribute are | 1235 # Checks that all bits in msg_flags_common_set attribute are |
1050 # set in "flags" and all bits in msg_flags_common_unset are | 1236 # set in "flags" and all bits in msg_flags_common_unset are |
1051 # unset. | 1237 # unset. |
1052 # | 1238 # |
1053 # The "eor" argument specifies whether the flags should | 1239 # The "eor" argument specifies whether the flags should |
1054 # indicate that a full record (or datagram) has been received. | 1240 # indicate that a full record (or datagram) has been received. |
1055 # If "eor" is None, no checks are done; otherwise, checks | 1241 # If "eor" is None, no checks are done; otherwise, checks |
1056 # that: | 1242 # that: |
1057 # | 1243 # |
1058 # * if "eor" is true, all bits in msg_flags_eor_indicator are | 1244 # * if "eor" is true, all bits in msg_flags_eor_indicator are |
1059 # set and all bits in msg_flags_non_eor_indicator are unset | 1245 # set and all bits in msg_flags_non_eor_indicator are unset |
1060 # | 1246 # |
1061 # * if "eor" is false, all bits in msg_flags_non_eor_indicator | 1247 # * if "eor" is false, all bits in msg_flags_non_eor_indicator |
1062 # are set and all bits in msg_flags_eor_indicator are unset | 1248 # are set and all bits in msg_flags_eor_indicator are unset |
1063 # | 1249 # |
1064 # If "checkset" and/or "checkunset" are supplied, they require | 1250 # If "checkset" and/or "checkunset" are supplied, they require |
1065 # the given bits to be set or unset respectively, overriding | 1251 # the given bits to be set or unset respectively, overriding |
1066 # what the attributes require for those bits. | 1252 # what the attributes require for those bits. |
1067 # | 1253 # |
1068 # If any bits are set in "ignore", they will not be checked, | 1254 # If any bits are set in "ignore", they will not be checked, |
1069 # regardless of the other inputs. | 1255 # regardless of the other inputs. |
1070 # | 1256 # |
1071 # Will raise self.TestError if the inputs require a bit to be | 1257 # Will raise Exception if the inputs require a bit to be both |
1072 # both set and unset, and it is not ignored. | 1258 # set and unset, and it is not ignored. |
1073 | 1259 |
1074 defaultset = self.msg_flags_common_set | 1260 defaultset = self.msg_flags_common_set |
1075 defaultunset = self.msg_flags_common_unset | 1261 defaultunset = self.msg_flags_common_unset |
1076 | 1262 |
1077 if eor: | 1263 if eor: |
1078 defaultset |= self.msg_flags_eor_indicator | 1264 defaultset |= self.msg_flags_eor_indicator |
1079 defaultunset |= self.msg_flags_non_eor_indicator | 1265 defaultunset |= self.msg_flags_non_eor_indicator |
1080 elif eor is not None: | 1266 elif eor is not None: |
1081 defaultset |= self.msg_flags_non_eor_indicator | 1267 defaultset |= self.msg_flags_non_eor_indicator |
1082 defaultunset |= self.msg_flags_eor_indicator | 1268 defaultunset |= self.msg_flags_eor_indicator |
1083 | 1269 |
1084 # Function arguments override defaults | 1270 # Function arguments override defaults |
1085 defaultset &= ~checkunset | 1271 defaultset &= ~checkunset |
1086 defaultunset &= ~checkset | 1272 defaultunset &= ~checkset |
1087 | 1273 |
1088 # Merge arguments with remaining defaults, and check for conflicts | 1274 # Merge arguments with remaining defaults, and check for conflicts |
1089 checkset |= defaultset | 1275 checkset |= defaultset |
1090 checkunset |= defaultunset | 1276 checkunset |= defaultunset |
1091 inboth = checkset & checkunset & ~ignore | 1277 inboth = checkset & checkunset & ~ignore |
1092 if inboth: | 1278 if inboth: |
1093 raise self.TestError("contradictory set, unset requirements for " | 1279 raise Exception("contradictory set, unset requirements for flags " |
1094 "flags {0:#x}".format(inboth)) | 1280 "{0:#x}".format(inboth)) |
1095 | 1281 |
1096 # Compare with given msg_flags value | 1282 # Compare with given msg_flags value |
1097 mask = (checkset | checkunset) & ~ignore | 1283 mask = (checkset | checkunset) & ~ignore |
1098 self.assertEqual(flags & mask, checkset & mask) | 1284 self.assertEqual(flags & mask, checkset & mask) |
1099 | 1285 |
1100 | 1286 |
1101 class RecvmsgIntoMixin(SendrecvmsgBase): | 1287 class RecvmsgIntoMixin(SendrecvmsgBase): |
1102 # Mixin to implement doRecvmsg() using recvmsg_into(). | 1288 # Mixin to implement doRecvmsg() using recvmsg_into(). |
1103 | 1289 |
1104 def doRecvmsg(self, sock, bufsize, *args): | 1290 def doRecvmsg(self, sock, bufsize, *args): |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1140 return self.cli | 1326 return self.cli |
1141 | 1327 |
1142 @property | 1328 @property |
1143 def sendmsg_to_server_defaults(self): | 1329 def sendmsg_to_server_defaults(self): |
1144 return ([], [], 0, self.serv_addr) | 1330 return ([], [], 0, self.serv_addr) |
1145 | 1331 |
1146 def sendToServer(self, msg): | 1332 def sendToServer(self, msg): |
1147 return self.cli_sock.sendto(msg, self.serv_addr) | 1333 return self.cli_sock.sendto(msg, self.serv_addr) |
1148 | 1334 |
1149 | 1335 |
1150 class SendrecvmsgDgramBase(SendrecvmsgDgramFlagsBase, | |
1151 SendrecvmsgConnectionlessBase): | |
1152 # Base class for tests on datagram sockets. | |
1153 pass | |
1154 | |
1155 | |
1156 class SendrecvmsgConnectedBase(SendrecvmsgBase): | 1336 class SendrecvmsgConnectedBase(SendrecvmsgBase): |
1157 # Base class for tests on connected sockets. Users must supply | 1337 # Base class for tests on connected sockets. Users must supply |
1158 # sockets on attributes serv_conn and cli_conn (representing the | 1338 # sockets on attributes serv_conn and cli_conn (representing the |
1159 # connections *to* the server and the client), to be mapped to | 1339 # connections *to* the server and the client), to be mapped to |
1160 # cli_sock and serv_sock respectively. | 1340 # cli_sock and serv_sock respectively. |
1161 | 1341 |
1162 @property | 1342 @property |
1163 def serv_sock(self): | 1343 def serv_sock(self): |
1164 return self.cli_conn | 1344 return self.cli_conn |
1165 | 1345 |
1166 @property | 1346 @property |
1167 def cli_sock(self): | 1347 def cli_sock(self): |
1168 return self.serv_conn | 1348 return self.serv_conn |
1169 | 1349 |
1170 def checkRecvmsgAddress(self, addr1, addr2): | 1350 def checkRecvmsgAddress(self, addr1, addr2): |
1171 # Address is currently "unspecified" for a connected socket, | 1351 # Address is currently "unspecified" for a connected socket, |
1172 # so we don't examine it | 1352 # so we don't examine it |
1173 pass | 1353 pass |
1174 | |
1175 | |
1176 class SendrecvmsgSCTPStreamBase(SendrecvmsgSCTPFlagsBase, | |
1177 SendrecvmsgConnectedBase): | |
1178 # Base class for tests on one-to-one (SOCK_STREAM) SCTP sockets. | |
1179 pass | |
1180 | 1354 |
1181 | 1355 |
1182 class SendrecvmsgServerTimeoutBase(SendrecvmsgBase): | 1356 class SendrecvmsgServerTimeoutBase(SendrecvmsgBase): |
1183 # Base class to set a timeout on server's socket. | 1357 # Base class to set a timeout on server's socket. |
1184 | 1358 |
1185 def setUp(self): | 1359 def setUp(self): |
1186 super().setUp() | 1360 super().setUp() |
1187 self.serv_sock.settimeout(self.fail_timeout) | 1361 self.serv_sock.settimeout(self.fail_timeout) |
1188 | 1362 |
1189 | 1363 |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1287 def testSendmsgExcessCmsgReject(self): | 1461 def testSendmsgExcessCmsgReject(self): |
1288 # Check that sendmsg() rejects excess ancillary data items | 1462 # Check that sendmsg() rejects excess ancillary data items |
1289 # when the number that can be sent is limited. | 1463 # when the number that can be sent is limited. |
1290 self.assertEqual(self.serv_sock.recv(1000), b"done") | 1464 self.assertEqual(self.serv_sock.recv(1000), b"done") |
1291 | 1465 |
1292 def _testSendmsgExcessCmsgReject(self): | 1466 def _testSendmsgExcessCmsgReject(self): |
1293 if not hasattr(socket, "CMSG_SPACE"): | 1467 if not hasattr(socket, "CMSG_SPACE"): |
1294 # Can only send one item | 1468 # Can only send one item |
1295 with self.assertRaises(socket.error) as cm: | 1469 with self.assertRaises(socket.error) as cm: |
1296 self.sendmsgToServer([MSG], [(0, 0, b""), (0, 0, b"")]) | 1470 self.sendmsgToServer([MSG], [(0, 0, b""), (0, 0, b"")]) |
1297 self.assertIsNone(cm.exception.errno) | 1471 self.assertIsNone(cm.exception.errno) |
Antoine Pitrou
2010/06/10 19:05:20
This line should be indented to the left, otherwis
baikie
2010/06/10 21:50:48
Well spotted, thanks.
| |
1298 self.sendToServer(b"done") | 1472 self.sendToServer(b"done") |
1299 | 1473 |
1300 def testSendmsgAfterClose(self): | 1474 def testSendmsgAfterClose(self): |
1301 # Check that sendmsg() fails on a closed socket. | 1475 # Check that sendmsg() fails on a closed socket. |
1302 pass | 1476 pass |
1303 | 1477 |
1304 def _testSendmsgAfterClose(self): | 1478 def _testSendmsgAfterClose(self): |
1305 self.cli_sock.close() | 1479 self.cli_sock.close() |
1306 self.assertRaises(socket.error, self.sendmsgToServer, [MSG]) | 1480 self.assertRaises(socket.error, self.sendmsgToServer, [MSG]) |
1307 | 1481 |
(...skipping 1193 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2501 self.assertEqual(ancdata, []) | 2675 self.assertEqual(ancdata, []) |
2502 | 2676 |
2503 @testSecomdCmsgTruncInData.client_skip | 2677 @testSecomdCmsgTruncInData.client_skip |
2504 def _testSecomdCmsgTruncInData(self): | 2678 def _testSecomdCmsgTruncInData(self): |
2505 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout)) | 2679 self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout)) |
2506 self.sendToServer(MSG) | 2680 self.sendToServer(MSG) |
2507 | 2681 |
2508 | 2682 |
2509 # Derive concrete test classes for different socket types. | 2683 # Derive concrete test classes for different socket types. |
2510 | 2684 |
2511 class SendrecvmsgUDPTestBase(SendrecvmsgDgramBase, UDPTestBase, | 2685 class SendrecvmsgUDPTestBase(SendrecvmsgDgramFlagsBase, |
2512 ThreadedSocketTestMixin): | 2686 SendrecvmsgConnectionlessBase, |
2687 ThreadedSocketTestMixin, UDPTestBase): | |
2513 pass | 2688 pass |
2514 | 2689 |
2515 @requireAttrs(socket.socket, "sendmsg") | 2690 @requireAttrs(socket.socket, "sendmsg") |
2516 @unittest.skipUnless(thread, 'Threading required for this test.') | 2691 @unittest.skipUnless(thread, 'Threading required for this test.') |
2517 class SendmsgUDPTest(SendmsgConnectionlessTests, SendrecvmsgUDPTestBase): | 2692 class SendmsgUDPTest(SendmsgConnectionlessTests, SendrecvmsgUDPTestBase): |
2518 pass | 2693 pass |
2519 | 2694 |
2520 @requireAttrs(socket.socket, "recvmsg") | 2695 @requireAttrs(socket.socket, "recvmsg") |
2521 @unittest.skipUnless(thread, 'Threading required for this test.') | 2696 @unittest.skipUnless(thread, 'Threading required for this test.') |
2522 class RecvmsgUDPTest(RecvmsgTests, RecvmsgGenericTests, | 2697 class RecvmsgUDPTest(RecvmsgTests, SendrecvmsgUDPTestBase): |
2523 SendrecvmsgUDPTestBase): | |
2524 pass | 2698 pass |
2525 | 2699 |
2526 @requireAttrs(socket.socket, "recvmsg_into") | 2700 @requireAttrs(socket.socket, "recvmsg_into") |
2527 @unittest.skipUnless(thread, 'Threading required for this test.') | 2701 @unittest.skipUnless(thread, 'Threading required for this test.') |
2528 class RecvmsgIntoUDPTest(RecvmsgIntoTests, RecvmsgGenericTests, | 2702 class RecvmsgIntoUDPTest(RecvmsgIntoTests, SendrecvmsgUDPTestBase): |
2529 SendrecvmsgUDPTestBase): | |
2530 pass | 2703 pass |
2531 | 2704 |
2532 class SendrecvmsgUDP6TestBase(SendrecvmsgDgramBase, UDP6TestBase, | 2705 |
2533 ThreadedSocketTestMixin): | 2706 class SendrecvmsgUDP6TestBase(SendrecvmsgDgramFlagsBase, |
2707 SendrecvmsgConnectionlessBase, | |
2708 ThreadedSocketTestMixin, UDP6TestBase): | |
2534 pass | 2709 pass |
2535 | 2710 |
2536 @requireAttrs(socket.socket, "sendmsg") | 2711 @requireAttrs(socket.socket, "sendmsg") |
2537 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") | 2712 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") |
2538 @requireSocket("AF_INET6", "SOCK_DGRAM") | 2713 @requireSocket("AF_INET6", "SOCK_DGRAM") |
2539 @unittest.skipUnless(thread, 'Threading required for this test.') | 2714 @unittest.skipUnless(thread, 'Threading required for this test.') |
2540 class SendmsgUDP6Test(SendmsgConnectionlessTests, SendrecvmsgUDP6TestBase): | 2715 class SendmsgUDP6Test(SendmsgConnectionlessTests, SendrecvmsgUDP6TestBase): |
2541 pass | 2716 pass |
2542 | 2717 |
2543 @requireAttrs(socket.socket, "recvmsg") | 2718 @requireAttrs(socket.socket, "recvmsg") |
2544 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") | 2719 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") |
2545 @requireSocket("AF_INET6", "SOCK_DGRAM") | 2720 @requireSocket("AF_INET6", "SOCK_DGRAM") |
2546 @unittest.skipUnless(thread, 'Threading required for this test.') | 2721 @unittest.skipUnless(thread, 'Threading required for this test.') |
2547 class RecvmsgUDP6Test(RecvmsgTests, RecvmsgGenericTests, | 2722 class RecvmsgUDP6Test(RecvmsgTests, SendrecvmsgUDP6TestBase): |
2548 SendrecvmsgUDP6TestBase): | |
2549 pass | 2723 pass |
2550 | 2724 |
2551 @requireAttrs(socket.socket, "recvmsg_into") | 2725 @requireAttrs(socket.socket, "recvmsg_into") |
2552 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") | 2726 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") |
2553 @requireSocket("AF_INET6", "SOCK_DGRAM") | 2727 @requireSocket("AF_INET6", "SOCK_DGRAM") |
2554 @unittest.skipUnless(thread, 'Threading required for this test.') | 2728 @unittest.skipUnless(thread, 'Threading required for this test.') |
2555 class RecvmsgIntoUDP6Test(RecvmsgIntoTests, RecvmsgGenericTests, | 2729 class RecvmsgIntoUDP6Test(RecvmsgIntoTests, SendrecvmsgUDP6TestBase): |
2556 SendrecvmsgUDP6TestBase): | |
2557 pass | 2730 pass |
2558 | 2731 |
2559 @requireAttrs(socket.socket, "recvmsg") | 2732 @requireAttrs(socket.socket, "recvmsg") |
2560 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") | 2733 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") |
2561 @requireAttrs(socket, "IPPROTO_IPV6") | 2734 @requireAttrs(socket, "IPPROTO_IPV6") |
2562 @requireSocket("AF_INET6", "SOCK_DGRAM") | 2735 @requireSocket("AF_INET6", "SOCK_DGRAM") |
2563 @unittest.skipUnless(thread, 'Threading required for this test.') | 2736 @unittest.skipUnless(thread, 'Threading required for this test.') |
2564 class RecvmsgRFC3542AncillaryUDP6Test(RFC3542AncillaryTest, | 2737 class RecvmsgRFC3542AncillaryUDP6Test(RFC3542AncillaryTest, |
2565 SendrecvmsgUDP6TestBase): | 2738 SendrecvmsgUDP6TestBase): |
2566 pass | 2739 pass |
2567 | 2740 |
2568 @requireAttrs(socket.socket, "recvmsg_into") | 2741 @requireAttrs(socket.socket, "recvmsg_into") |
2569 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") | 2742 @unittest.skipUnless(socket.has_ipv6, "Python not built with IPv6 support") |
2570 @requireAttrs(socket, "IPPROTO_IPV6") | 2743 @requireAttrs(socket, "IPPROTO_IPV6") |
2571 @requireSocket("AF_INET6", "SOCK_DGRAM") | 2744 @requireSocket("AF_INET6", "SOCK_DGRAM") |
2572 @unittest.skipUnless(thread, 'Threading required for this test.') | 2745 @unittest.skipUnless(thread, 'Threading required for this test.') |
2573 class RecvmsgIntoRFC3542AncillaryUDP6Test(RecvmsgIntoMixin, | 2746 class RecvmsgIntoRFC3542AncillaryUDP6Test(RecvmsgIntoMixin, |
2574 RFC3542AncillaryTest, | 2747 RFC3542AncillaryTest, |
2575 SendrecvmsgUDP6TestBase): | 2748 SendrecvmsgUDP6TestBase): |
2576 pass | 2749 pass |
2577 | 2750 |
2578 class SendrecvmsgTCPTestBase(SendrecvmsgConnectedBase, TCPTestBase, | 2751 |
2579 ConnectedSocketTestMixin): | 2752 class SendrecvmsgTCPTestBase(SendrecvmsgConnectedBase, |
2753 ConnectedStreamTestMixin, TCPTestBase): | |
2580 pass | 2754 pass |
2581 | 2755 |
2582 @requireAttrs(socket.socket, "sendmsg") | 2756 @requireAttrs(socket.socket, "sendmsg") |
2583 @unittest.skipUnless(thread, 'Threading required for this test.') | 2757 @unittest.skipUnless(thread, 'Threading required for this test.') |
2584 class SendmsgTCPTest(SendmsgStreamTests, SendrecvmsgTCPTestBase): | 2758 class SendmsgTCPTest(SendmsgStreamTests, SendrecvmsgTCPTestBase): |
2585 pass | 2759 pass |
2586 | 2760 |
2587 @requireAttrs(socket.socket, "recvmsg") | 2761 @requireAttrs(socket.socket, "recvmsg") |
2588 @unittest.skipUnless(thread, 'Threading required for this test.') | 2762 @unittest.skipUnless(thread, 'Threading required for this test.') |
2589 class RecvmsgTCPTest(RecvmsgTests, RecvmsgGenericStreamTests, | 2763 class RecvmsgTCPTest(RecvmsgTests, RecvmsgGenericStreamTests, |
2590 SendrecvmsgTCPTestBase): | 2764 SendrecvmsgTCPTestBase): |
2591 pass | 2765 pass |
2592 | 2766 |
2593 @requireAttrs(socket.socket, "recvmsg_into") | 2767 @requireAttrs(socket.socket, "recvmsg_into") |
2594 @unittest.skipUnless(thread, 'Threading required for this test.') | 2768 @unittest.skipUnless(thread, 'Threading required for this test.') |
2595 class RecvmsgIntoTCPTest(RecvmsgIntoTests, RecvmsgGenericStreamTests, | 2769 class RecvmsgIntoTCPTest(RecvmsgIntoTests, RecvmsgGenericStreamTests, |
2596 SendrecvmsgTCPTestBase): | 2770 SendrecvmsgTCPTestBase): |
2597 pass | 2771 pass |
2598 | 2772 |
2599 class SendrecvmsgSCTPStreamTestBase(SendrecvmsgSCTPStreamBase, SCTPStreamBase, | 2773 |
2600 ConnectedSocketTestMixin): | 2774 class SendrecvmsgSCTPStreamTestBase(SendrecvmsgSCTPFlagsBase, |
2775 SendrecvmsgConnectedBase, | |
2776 ConnectedStreamTestMixin, SCTPStreamBase): | |
2601 pass | 2777 pass |
2602 | 2778 |
2603 @requireAttrs(socket.socket, "sendmsg") | 2779 @requireAttrs(socket.socket, "sendmsg") |
2604 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP") | 2780 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP") |
2605 @unittest.skipUnless(thread, 'Threading required for this test.') | 2781 @unittest.skipUnless(thread, 'Threading required for this test.') |
2606 class SendmsgSCTPStreamTest(SendmsgStreamTests, SendrecvmsgSCTPStreamTestBase): | 2782 class SendmsgSCTPStreamTest(SendmsgStreamTests, SendrecvmsgSCTPStreamTestBase): |
2607 pass | 2783 pass |
2608 | 2784 |
2609 @requireAttrs(socket.socket, "recvmsg") | 2785 @requireAttrs(socket.socket, "recvmsg") |
2610 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP") | 2786 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP") |
2611 @unittest.skipUnless(thread, 'Threading required for this test.') | 2787 @unittest.skipUnless(thread, 'Threading required for this test.') |
2612 class RecvmsgSCTPStreamTest(RecvmsgTests, RecvmsgGenericStreamTests, | 2788 class RecvmsgSCTPStreamTest(RecvmsgTests, RecvmsgGenericStreamTests, |
2613 SendrecvmsgSCTPStreamTestBase): | 2789 SendrecvmsgSCTPStreamTestBase): |
2614 pass | 2790 pass |
2615 | 2791 |
2616 @requireAttrs(socket.socket, "recvmsg_into") | 2792 @requireAttrs(socket.socket, "recvmsg_into") |
2617 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP") | 2793 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP") |
2618 @unittest.skipUnless(thread, 'Threading required for this test.') | 2794 @unittest.skipUnless(thread, 'Threading required for this test.') |
2619 class RecvmsgIntoSCTPStreamTest(RecvmsgIntoTests, RecvmsgGenericStreamTests, | 2795 class RecvmsgIntoSCTPStreamTest(RecvmsgIntoTests, RecvmsgGenericStreamTests, |
2620 SendrecvmsgSCTPStreamTestBase): | 2796 SendrecvmsgSCTPStreamTestBase): |
2621 pass | 2797 pass |
2622 | 2798 |
2623 class SendrecvmsgUnixStreamTestBase(SendrecvmsgConnectedBase, UnixStreamBase, | 2799 |
2624 ConnectedSocketTestMixin): | 2800 class SendrecvmsgUnixStreamTestBase(SendrecvmsgConnectedBase, |
2801 ConnectedStreamTestMixin, UnixStreamBase): | |
2625 pass | 2802 pass |
2626 | 2803 |
2627 @requireAttrs(socket.socket, "sendmsg") | 2804 @requireAttrs(socket.socket, "sendmsg") |
2628 @requireAttrs(socket, "AF_UNIX") | 2805 @requireAttrs(socket, "AF_UNIX") |
2629 @unittest.skipUnless(thread, 'Threading required for this test.') | 2806 @unittest.skipUnless(thread, 'Threading required for this test.') |
2630 class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase): | 2807 class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase): |
2631 pass | 2808 pass |
2632 | 2809 |
2633 @requireAttrs(socket.socket, "recvmsg") | 2810 @requireAttrs(socket.socket, "recvmsg") |
2634 @requireAttrs(socket, "AF_UNIX") | 2811 @requireAttrs(socket, "AF_UNIX") |
(...skipping 16 matching lines...) Expand all Loading... | |
2651 pass | 2828 pass |
2652 | 2829 |
2653 @requireAttrs(socket.socket, "sendmsg", "recvmsg_into") | 2830 @requireAttrs(socket.socket, "sendmsg", "recvmsg_into") |
2654 @requireAttrs(socket, "AF_UNIX", "SOL_SOCKET", "SCM_RIGHTS") | 2831 @requireAttrs(socket, "AF_UNIX", "SOL_SOCKET", "SCM_RIGHTS") |
2655 @unittest.skipUnless(thread, 'Threading required for this test.') | 2832 @unittest.skipUnless(thread, 'Threading required for this test.') |
2656 class RecvmsgIntoSCMRightsStreamTest(RecvmsgIntoMixin, SCMRightsTest, | 2833 class RecvmsgIntoSCMRightsStreamTest(RecvmsgIntoMixin, SCMRightsTest, |
2657 SendrecvmsgUnixStreamTestBase): | 2834 SendrecvmsgUnixStreamTestBase): |
2658 pass | 2835 pass |
2659 | 2836 |
2660 | 2837 |
2838 # Test interrupting the interruptible send/receive methods with a | |
2839 # signal when a timeout is set. These tests avoid having multiple | |
2840 # threads alive during the test so that the OS cannot deliver the | |
2841 # signal to the wrong one. | |
2842 | |
2843 class InterruptedTimeoutBase(unittest.TestCase): | |
2844 # Base class for interrupted send/receive tests. Installs an | |
2845 # empty handler for SIGALRM and removes it on teardown, along with | |
2846 # any scheduled alarms. | |
2847 | |
2848 def setUp(self): | |
2849 super().setUp() | |
2850 orig_alrm_handler = signal.signal(signal.SIGALRM, | |
2851 lambda signum, frame: None) | |
2852 self.addCleanup(signal.signal, signal.SIGALRM, orig_alrm_handler) | |
2853 self.addCleanup(self.setAlarm, 0) | |
2854 | |
2855 # Timeout for socket operations | |
2856 timeout = 4.0 | |
2857 | |
2858 # Provide setAlarm() method to schedule delivery of SIGALRM after | |
2859 # given number of seconds, or cancel it if zero, and an | |
2860 # appropriate time value to use. Use setitimer() if available. | |
2861 if hasattr(signal, "setitimer"): | |
2862 alarm_time = 0.05 | |
2863 | |
2864 def setAlarm(self, seconds): | |
2865 signal.setitimer(signal.ITIMER_REAL, seconds) | |
2866 else: | |
2867 # Old systems may deliver the alarm up to one second early | |
2868 alarm_time = 2 | |
2869 | |
2870 def setAlarm(self, seconds): | |
2871 signal.alarm(seconds) | |
2872 | |
2873 | |
2874 # Require siginterrupt() in order to ensure that system calls are | |
2875 # interrupted by default. | |
2876 @requireAttrs(signal, "siginterrupt") | |
2877 @unittest.skipUnless(hasattr(signal, "alarm") or hasattr(signal, "setitimer"), | |
2878 "Don't have signal.alarm or signal.setitimer") | |
2879 class InterruptedRecvTimeoutTest(InterruptedTimeoutBase, UDPTestBase): | |
2880 # Test interrupting the recv*() methods with signals when a | |
2881 # timeout is set. | |
2882 | |
2883 def setUp(self): | |
2884 super().setUp() | |
2885 self.serv.settimeout(self.timeout) | |
2886 | |
2887 def checkInterruptedRecv(self, func, *args, **kwargs): | |
2888 # Check that func(*args, **kwargs) raises socket.error with an | |
2889 # errno of EINTR when interrupted by a signal. | |
2890 self.setAlarm(self.alarm_time) | |
2891 with self.assertRaises(socket.error) as cm: | |
2892 func(*args, **kwargs) | |
2893 self.assertNotIsInstance(cm.exception, socket.timeout) | |
2894 self.assertEqual(cm.exception.errno, errno.EINTR) | |
2895 | |
2896 def testInterruptedRecvTimeout(self): | |
2897 self.checkInterruptedRecv(self.serv.recv, 1024) | |
2898 | |
2899 def testInterruptedRecvIntoTimeout(self): | |
2900 self.checkInterruptedRecv(self.serv.recv_into, bytearray(1024)) | |
2901 | |
2902 def testInterruptedRecvfromTimeout(self): | |
2903 self.checkInterruptedRecv(self.serv.recvfrom, 1024) | |
2904 | |
2905 def testInterruptedRecvfromIntoTimeout(self): | |
2906 self.checkInterruptedRecv(self.serv.recvfrom_into, bytearray(1024)) | |
2907 | |
2908 @requireAttrs(socket.socket, "recvmsg") | |
2909 def testInterruptedRecvmsgTimeout(self): | |
2910 self.checkInterruptedRecv(self.serv.recvmsg, 1024) | |
2911 | |
2912 @requireAttrs(socket.socket, "recvmsg_into") | |
2913 def testInterruptedRecvmsgIntoTimeout(self): | |
2914 self.checkInterruptedRecv(self.serv.recvmsg_into, [bytearray(1024)]) | |
2915 | |
2916 | |
2917 # Require siginterrupt() in order to ensure that system calls are | |
2918 # interrupted by default. | |
2919 @requireAttrs(signal, "siginterrupt") | |
2920 @unittest.skipUnless(hasattr(signal, "alarm") or hasattr(signal, "setitimer"), | |
2921 "Don't have signal.alarm or signal.setitimer") | |
2922 @unittest.skipUnless(thread, 'Threading required for this test.') | |
2923 class InterruptedSendTimeoutTest(InterruptedTimeoutBase, | |
2924 ThreadSafeCleanupTestCase, | |
2925 SocketListeningTestMixin, TCPTestBase): | |
2926 # Test interrupting the interruptible send*() methods with signals | |
2927 # when a timeout is set. | |
2928 | |
2929 def setUp(self): | |
2930 super().setUp() | |
2931 self.serv_conn = self.newSocket() | |
2932 self.addCleanup(self.serv_conn.close) | |
2933 # Use a thread to complete the connection, but wait for it to | |
2934 # terminate before running the test, so that there is only one | |
2935 # thread to accept the signal. | |
2936 cli_thread = threading.Thread(target=self.doConnect) | |
2937 cli_thread.start() | |
2938 self.cli_conn, addr = self.serv.accept() | |
2939 self.addCleanup(self.cli_conn.close) | |
2940 cli_thread.join() | |
2941 self.serv_conn.settimeout(self.timeout) | |
2942 | |
2943 def doConnect(self): | |
2944 self.serv_conn.connect(self.serv_addr) | |
2945 | |
2946 def checkInterruptedSend(self, func, *args, **kwargs): | |
2947 # Check that func(*args, **kwargs), run in a loop, raises | |
2948 # socket.error with an errno of EINTR when interrupted by a | |
2949 # signal. | |
2950 with self.assertRaises(socket.error) as cm: | |
2951 while True: | |
2952 self.setAlarm(self.alarm_time) | |
2953 func(*args, **kwargs) | |
2954 self.assertNotIsInstance(cm.exception, socket.timeout) | |
2955 self.assertEqual(cm.exception.errno, errno.EINTR) | |
2956 | |
2957 def testInterruptedSendTimeout(self): | |
2958 self.checkInterruptedSend(self.serv_conn.send, b"a"*512) | |
2959 | |
2960 def testInterruptedSendtoTimeout(self): | |
2961 # Passing an actual address here as Python's wrapper for | |
2962 # sendto() doesn't allow passing a zero-length one; POSIX | |
2963 # requires that the address is ignored since the socket is | |
2964 # connection-mode, however. | |
2965 self.checkInterruptedSend(self.serv_conn.sendto, b"a"*512, | |
2966 self.serv_addr) | |
2967 | |
2968 @requireAttrs(socket.socket, "sendmsg") | |
2969 def testInterruptedSendmsgTimeout(self): | |
2970 self.checkInterruptedSend(self.serv_conn.sendmsg, [b"a"*512]) | |
2971 | |
2972 | |
2661 @unittest.skipUnless(thread, 'Threading required for this test.') | 2973 @unittest.skipUnless(thread, 'Threading required for this test.') |
2662 class TCPCloserTest(ThreadedTCPSocketTest): | 2974 class TCPCloserTest(ThreadedTCPSocketTest): |
2663 | 2975 |
2664 def testClose(self): | 2976 def testClose(self): |
2665 conn, addr = self.serv.accept() | 2977 conn, addr = self.serv.accept() |
2666 conn.close() | 2978 conn.close() |
2667 | 2979 |
2668 sd = self.cli | 2980 sd = self.cli |
2669 read, write, err = select.select([sd], [], [], 1.0) | 2981 read, write, err = select.select([sd], [], [], 1.0) |
2670 self.assertEqual(read, [sd]) | 2982 self.assertEqual(read, [sd]) |
2671 self.assertEqual(sd.recv(1), b'') | 2983 self.assertEqual(sd.recv(1), b'') |
2672 | 2984 |
2673 # Calling close() many times should be safe. | 2985 # Calling close() many times should be safe. |
2674 conn.close() | 2986 conn.close() |
2675 conn.close() | 2987 conn.close() |
2676 | 2988 |
2677 def _testClose(self): | 2989 def _testClose(self): |
2678 self.cli.connect((HOST, self.port)) | 2990 self.cli.connect((HOST, self.port)) |
2679 time.sleep(1.0) | 2991 time.sleep(1.0) |
2680 | 2992 |
2681 @unittest.skipUnless(thread, 'Threading required for this test.') | 2993 @unittest.skipUnless(thread, 'Threading required for this test.') |
2682 class BasicSocketPairTest(SocketPairTest): | 2994 class BasicSocketPairTest(SocketPairTest): |
2683 | 2995 |
2684 def __init__(self, methodName='runTest'): | 2996 def __init__(self, methodName='runTest'): |
2685 SocketPairTest.__init__(self, methodName=methodName) | 2997 SocketPairTest.__init__(self, methodName=methodName) |
2998 | |
2999 def _check_defaults(self, sock): | |
3000 self.assertIsInstance(sock, socket.socket) | |
3001 if hasattr(socket, 'AF_UNIX'): | |
3002 self.assertEqual(sock.family, socket.AF_UNIX) | |
3003 else: | |
3004 self.assertEqual(sock.family, socket.AF_INET) | |
3005 self.assertEqual(sock.type, socket.SOCK_STREAM) | |
3006 self.assertEqual(sock.proto, 0) | |
3007 | |
3008 def _testDefaults(self): | |
3009 self._check_defaults(self.cli) | |
3010 | |
3011 def testDefaults(self): | |
3012 self._check_defaults(self.serv) | |
2686 | 3013 |
2687 def testRecv(self): | 3014 def testRecv(self): |
2688 msg = self.serv.recv(1024) | 3015 msg = self.serv.recv(1024) |
2689 self.assertEqual(msg, MSG) | 3016 self.assertEqual(msg, MSG) |
2690 | 3017 |
2691 def _testRecv(self): | 3018 def _testRecv(self): |
2692 self.cli.send(MSG) | 3019 self.cli.send(MSG) |
2693 | 3020 |
2694 def testSend(self): | 3021 def testSend(self): |
2695 self.serv.send(MSG) | 3022 self.serv.send(MSG) |
(...skipping 14 matching lines...) Expand all Loading... | |
2710 start = time.time() | 3037 start = time.time() |
2711 try: | 3038 try: |
2712 self.serv.accept() | 3039 self.serv.accept() |
2713 except socket.error: | 3040 except socket.error: |
2714 pass | 3041 pass |
2715 end = time.time() | 3042 end = time.time() |
2716 self.assertTrue((end - start) < 1.0, "Error setting non-blocking mode.") | 3043 self.assertTrue((end - start) < 1.0, "Error setting non-blocking mode.") |
2717 | 3044 |
2718 def _testSetBlocking(self): | 3045 def _testSetBlocking(self): |
2719 pass | 3046 pass |
3047 | |
3048 if hasattr(socket, "SOCK_NONBLOCK"): | |
3049 def testInitNonBlocking(self): | |
3050 v = linux_version() | |
3051 if v < (2, 6, 28): | |
3052 self.skipTest("Linux kernel 2.6.28 or higher required, not %s" | |
3053 % ".".join(map(str, v))) | |
3054 # reinit server socket | |
3055 self.serv.close() | |
3056 self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM | | |
3057 socket.SOCK_NONBLOCK) | |
3058 self.port = support.bind_port(self.serv) | |
3059 self.serv.listen(1) | |
3060 # actual testing | |
3061 start = time.time() | |
3062 try: | |
3063 self.serv.accept() | |
3064 except socket.error: | |
3065 pass | |
3066 end = time.time() | |
3067 self.assertTrue((end - start) < 1.0, "Error creating with non-blocki ng mode.") | |
3068 | |
3069 def _testInitNonBlocking(self): | |
3070 pass | |
2720 | 3071 |
2721 def testAccept(self): | 3072 def testAccept(self): |
2722 # Testing non-blocking accept | 3073 # Testing non-blocking accept |
2723 self.serv.setblocking(0) | 3074 self.serv.setblocking(0) |
2724 try: | 3075 try: |
2725 conn, addr = self.serv.accept() | 3076 conn, addr = self.serv.accept() |
2726 except socket.error: | 3077 except socket.error: |
2727 pass | 3078 pass |
2728 else: | 3079 else: |
2729 self.fail("Error trying to do non-blocking accept.") | 3080 self.fail("Error trying to do non-blocking accept.") |
2730 read, write, err = select.select([self.serv], [], []) | 3081 read, write, err = select.select([self.serv], [], []) |
2731 if self.serv in read: | 3082 if self.serv in read: |
2732 conn, addr = self.serv.accept() | 3083 conn, addr = self.serv.accept() |
3084 conn.close() | |
2733 else: | 3085 else: |
2734 self.fail("Error trying to do accept after select.") | 3086 self.fail("Error trying to do accept after select.") |
2735 | 3087 |
2736 def _testAccept(self): | 3088 def _testAccept(self): |
2737 time.sleep(0.1) | 3089 time.sleep(0.1) |
2738 self.cli.connect((HOST, self.port)) | 3090 self.cli.connect((HOST, self.port)) |
2739 | 3091 |
2740 def testConnect(self): | 3092 def testConnect(self): |
2741 # Testing non-blocking connect | 3093 # Testing non-blocking connect |
2742 conn, addr = self.serv.accept() | 3094 conn, addr = self.serv.accept() |
3095 conn.close() | |
2743 | 3096 |
2744 def _testConnect(self): | 3097 def _testConnect(self): |
2745 self.cli.settimeout(10) | 3098 self.cli.settimeout(10) |
2746 self.cli.connect((HOST, self.port)) | 3099 self.cli.connect((HOST, self.port)) |
2747 | 3100 |
2748 def testRecv(self): | 3101 def testRecv(self): |
2749 # Testing non-blocking recv | 3102 # Testing non-blocking recv |
2750 conn, addr = self.serv.accept() | 3103 conn, addr = self.serv.accept() |
2751 conn.setblocking(0) | 3104 conn.setblocking(0) |
2752 try: | 3105 try: |
2753 msg = conn.recv(len(MSG)) | 3106 msg = conn.recv(len(MSG)) |
2754 except socket.error: | 3107 except socket.error: |
2755 pass | 3108 pass |
2756 else: | 3109 else: |
2757 self.fail("Error trying to do non-blocking recv.") | 3110 self.fail("Error trying to do non-blocking recv.") |
2758 read, write, err = select.select([conn], [], []) | 3111 read, write, err = select.select([conn], [], []) |
2759 if conn in read: | 3112 if conn in read: |
2760 msg = conn.recv(len(MSG)) | 3113 msg = conn.recv(len(MSG)) |
3114 conn.close() | |
2761 self.assertEqual(msg, MSG) | 3115 self.assertEqual(msg, MSG) |
2762 else: | 3116 else: |
2763 self.fail("Error during select call to non-blocking socket.") | 3117 self.fail("Error during select call to non-blocking socket.") |
2764 | 3118 |
2765 def _testRecv(self): | 3119 def _testRecv(self): |
2766 self.cli.connect((HOST, self.port)) | 3120 self.cli.connect((HOST, self.port)) |
2767 time.sleep(0.1) | 3121 time.sleep(0.1) |
2768 self.cli.send(MSG) | 3122 self.cli.send(MSG) |
2769 | 3123 |
2770 @unittest.skipUnless(thread, 'Threading required for this test.') | 3124 @unittest.skipUnless(thread, 'Threading required for this test.') |
2771 class FileObjectClassTestCase(SocketConnectedTest): | 3125 class FileObjectClassTestCase(SocketConnectedTest): |
2772 """Unit tests for the object returned by socket.makefile() | 3126 """Unit tests for the object returned by socket.makefile() |
2773 | 3127 |
2774 self.serv_file is the io object returned by makefile() on | 3128 self.read_file is the io object returned by makefile() on |
2775 the client connection. You can read from this file to | 3129 the client connection. You can read from this file to |
2776 get output from the server. | 3130 get output from the server. |
2777 | 3131 |
2778 self.cli_file is the io object returned by makefile() on the | 3132 self.write_file is the io object returned by makefile() on the |
2779 server connection. You can write to this file to send output | 3133 server connection. You can write to this file to send output |
2780 to the client. | 3134 to the client. |
2781 """ | 3135 """ |
2782 | 3136 |
2783 bufsize = -1 # Use default buffer size | 3137 bufsize = -1 # Use default buffer size |
3138 encoding = 'utf8' | |
3139 errors = 'strict' | |
3140 newline = None | |
3141 | |
3142 read_mode = 'rb' | |
3143 read_msg = MSG | |
3144 write_mode = 'wb' | |
3145 write_msg = MSG | |
2784 | 3146 |
2785 def __init__(self, methodName='runTest'): | 3147 def __init__(self, methodName='runTest'): |
2786 SocketConnectedTest.__init__(self, methodName=methodName) | 3148 SocketConnectedTest.__init__(self, methodName=methodName) |
2787 | 3149 |
2788 def setUp(self): | 3150 def setUp(self): |
3151 self.evt1, self.evt2, self.serv_finished, self.cli_finished = [ | |
3152 threading.Event() for i in range(4)] | |
2789 SocketConnectedTest.setUp(self) | 3153 SocketConnectedTest.setUp(self) |
2790 self.serv_file = self.cli_conn.makefile('rb', self.bufsize) | 3154 self.read_file = self.cli_conn.makefile( |
3155 self.read_mode, self.bufsize, | |
3156 encoding = self.encoding, | |
3157 errors = self.errors, | |
3158 newline = self.newline) | |
2791 | 3159 |
2792 def tearDown(self): | 3160 def tearDown(self): |
2793 self.serv_file.close() | 3161 self.serv_finished.set() |
2794 self.assertTrue(self.serv_file.closed) | 3162 self.read_file.close() |
2795 self.serv_file = None | 3163 self.assertTrue(self.read_file.closed) |
3164 self.read_file = None | |
2796 SocketConnectedTest.tearDown(self) | 3165 SocketConnectedTest.tearDown(self) |
2797 | 3166 |
2798 def clientSetUp(self): | 3167 def clientSetUp(self): |
2799 SocketConnectedTest.clientSetUp(self) | 3168 SocketConnectedTest.clientSetUp(self) |
2800 self.cli_file = self.serv_conn.makefile('wb') | 3169 self.write_file = self.serv_conn.makefile( |
3170 self.write_mode, self.bufsize, | |
3171 encoding = self.encoding, | |
3172 errors = self.errors, | |
3173 newline = self.newline) | |
2801 | 3174 |
2802 def clientTearDown(self): | 3175 def clientTearDown(self): |
2803 self.cli_file.close() | 3176 self.cli_finished.set() |
2804 self.assertTrue(self.cli_file.closed) | 3177 self.write_file.close() |
2805 self.cli_file = None | 3178 self.assertTrue(self.write_file.closed) |
3179 self.write_file = None | |
2806 SocketConnectedTest.clientTearDown(self) | 3180 SocketConnectedTest.clientTearDown(self) |
2807 | 3181 |
2808 def testSmallRead(self): | 3182 def testSmallRead(self): |
2809 # Performing small file read test | 3183 # Performing small file read test |
2810 first_seg = self.serv_file.read(len(MSG)-3) | 3184 first_seg = self.read_file.read(len(self.read_msg)-3) |
2811 second_seg = self.serv_file.read(3) | 3185 second_seg = self.read_file.read(3) |
2812 msg = first_seg + second_seg | 3186 msg = first_seg + second_seg |
2813 self.assertEqual(msg, MSG) | 3187 self.assertEqual(msg, self.read_msg) |
2814 | 3188 |
2815 def _testSmallRead(self): | 3189 def _testSmallRead(self): |
2816 self.cli_file.write(MSG) | 3190 self.write_file.write(self.write_msg) |
2817 self.cli_file.flush() | 3191 self.write_file.flush() |
2818 | 3192 |
2819 def testFullRead(self): | 3193 def testFullRead(self): |
2820 # read until EOF | 3194 # read until EOF |
2821 msg = self.serv_file.read() | 3195 msg = self.read_file.read() |
2822 self.assertEqual(msg, MSG) | 3196 self.assertEqual(msg, self.read_msg) |
2823 | 3197 |
2824 def _testFullRead(self): | 3198 def _testFullRead(self): |
2825 self.cli_file.write(MSG) | 3199 self.write_file.write(self.write_msg) |
2826 self.cli_file.close() | 3200 self.write_file.close() |
2827 | 3201 |
2828 def testUnbufferedRead(self): | 3202 def testUnbufferedRead(self): |
2829 # Performing unbuffered file read test | 3203 # Performing unbuffered file read test |
2830 buf = b'' | 3204 buf = type(self.read_msg)() |
2831 while 1: | 3205 while 1: |
2832 char = self.serv_file.read(1) | 3206 char = self.read_file.read(1) |
2833 if not char: | 3207 if not char: |
2834 break | 3208 break |
2835 buf += char | 3209 buf += char |
2836 self.assertEqual(buf, MSG) | 3210 self.assertEqual(buf, self.read_msg) |
2837 | 3211 |
2838 def _testUnbufferedRead(self): | 3212 def _testUnbufferedRead(self): |
2839 self.cli_file.write(MSG) | 3213 self.write_file.write(self.write_msg) |
2840 self.cli_file.flush() | 3214 self.write_file.flush() |
2841 | 3215 |
2842 def testReadline(self): | 3216 def testReadline(self): |
2843 # Performing file readline test | 3217 # Performing file readline test |
2844 line = self.serv_file.readline() | 3218 line = self.read_file.readline() |
2845 self.assertEqual(line, MSG) | 3219 self.assertEqual(line, self.read_msg) |
2846 | 3220 |
2847 def _testReadline(self): | 3221 def _testReadline(self): |
2848 self.cli_file.write(MSG) | 3222 self.write_file.write(self.write_msg) |
2849 self.cli_file.flush() | 3223 self.write_file.flush() |
2850 | 3224 |
2851 def testCloseAfterMakefile(self): | 3225 def testCloseAfterMakefile(self): |
2852 # The file returned by makefile should keep the socket open. | 3226 # The file returned by makefile should keep the socket open. |
2853 self.cli_conn.close() | 3227 self.cli_conn.close() |
2854 # read until EOF | 3228 # read until EOF |
2855 msg = self.serv_file.read() | 3229 msg = self.read_file.read() |
2856 self.assertEqual(msg, MSG) | 3230 self.assertEqual(msg, self.read_msg) |
2857 | 3231 |
2858 def _testCloseAfterMakefile(self): | 3232 def _testCloseAfterMakefile(self): |
2859 self.cli_file.write(MSG) | 3233 self.write_file.write(self.write_msg) |
2860 self.cli_file.flush() | 3234 self.write_file.flush() |
2861 | 3235 |
2862 def testMakefileAfterMakefileClose(self): | 3236 def testMakefileAfterMakefileClose(self): |
2863 self.serv_file.close() | 3237 self.read_file.close() |
2864 msg = self.cli_conn.recv(len(MSG)) | 3238 msg = self.cli_conn.recv(len(MSG)) |
2865 self.assertEqual(msg, MSG) | 3239 if isinstance(self.read_msg, str): |
3240 msg = msg.decode() | |
3241 self.assertEqual(msg, self.read_msg) | |
2866 | 3242 |
2867 def _testMakefileAfterMakefileClose(self): | 3243 def _testMakefileAfterMakefileClose(self): |
2868 self.cli_file.write(MSG) | 3244 self.write_file.write(self.write_msg) |
2869 self.cli_file.flush() | 3245 self.write_file.flush() |
2870 | 3246 |
2871 def testClosedAttr(self): | 3247 def testClosedAttr(self): |
2872 self.assertTrue(not self.serv_file.closed) | 3248 self.assertTrue(not self.read_file.closed) |
2873 | 3249 |
2874 def _testClosedAttr(self): | 3250 def _testClosedAttr(self): |
2875 self.assertTrue(not self.cli_file.closed) | 3251 self.assertTrue(not self.write_file.closed) |
2876 | 3252 |
2877 def testAttributes(self): | 3253 def testAttributes(self): |
2878 self.assertEqual(self.serv_file.mode, 'rb') | 3254 self.assertEqual(self.read_file.mode, self.read_mode) |
2879 self.assertEqual(self.serv_file.name, self.cli_conn.fileno()) | 3255 self.assertEqual(self.read_file.name, self.cli_conn.fileno()) |
2880 | 3256 |
2881 def _testAttributes(self): | 3257 def _testAttributes(self): |
2882 self.assertEqual(self.cli_file.mode, 'wb') | 3258 self.assertEqual(self.write_file.mode, self.write_mode) |
2883 self.assertEqual(self.cli_file.name, self.serv_conn.fileno()) | 3259 self.assertEqual(self.write_file.name, self.serv_conn.fileno()) |
2884 | 3260 |
2885 def testRealClose(self): | 3261 def testRealClose(self): |
2886 self.serv_file.close() | 3262 self.read_file.close() |
2887 self.assertRaises(ValueError, self.serv_file.fileno) | 3263 self.assertRaises(ValueError, self.read_file.fileno) |
2888 self.cli_conn.close() | 3264 self.cli_conn.close() |
2889 self.assertRaises(socket.error, self.cli_conn.getsockname) | 3265 self.assertRaises(socket.error, self.cli_conn.getsockname) |
2890 | 3266 |
2891 def _testRealClose(self): | 3267 def _testRealClose(self): |
2892 pass | 3268 pass |
2893 | 3269 |
2894 | 3270 |
2895 class FileObjectInterruptedTestCase(unittest.TestCase): | 3271 class FileObjectInterruptedTestCase(unittest.TestCase): |
2896 """Test that the file object correctly handles EINTR internally.""" | 3272 """Test that the file object correctly handles EINTR internally.""" |
2897 | 3273 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
2938 | 3314 |
2939 def _test_readline(self, size=-1, buffering=-1): | 3315 def _test_readline(self, size=-1, buffering=-1): |
2940 mock_sock = self.MockSocket(recv_funcs=[ | 3316 mock_sock = self.MockSocket(recv_funcs=[ |
2941 lambda : b"This is the first line\nAnd the sec", | 3317 lambda : b"This is the first line\nAnd the sec", |
2942 self._raise_eintr, | 3318 self._raise_eintr, |
2943 lambda : b"ond line is here\n", | 3319 lambda : b"ond line is here\n", |
2944 lambda : b"", | 3320 lambda : b"", |
2945 lambda : b"", # XXX(gps): io library does an extra EOF read | 3321 lambda : b"", # XXX(gps): io library does an extra EOF read |
2946 ]) | 3322 ]) |
2947 fo = mock_sock._textiowrap_for_test(buffering=buffering) | 3323 fo = mock_sock._textiowrap_for_test(buffering=buffering) |
2948 self.assertEquals(fo.readline(size), "This is the first line\n") | 3324 self.assertEqual(fo.readline(size), "This is the first line\n") |
2949 self.assertEquals(fo.readline(size), "And the second line is here\n") | 3325 self.assertEqual(fo.readline(size), "And the second line is here\n") |
2950 | 3326 |
2951 def _test_read(self, size=-1, buffering=-1): | 3327 def _test_read(self, size=-1, buffering=-1): |
2952 mock_sock = self.MockSocket(recv_funcs=[ | 3328 mock_sock = self.MockSocket(recv_funcs=[ |
2953 lambda : b"This is the first line\nAnd the sec", | 3329 lambda : b"This is the first line\nAnd the sec", |
2954 self._raise_eintr, | 3330 self._raise_eintr, |
2955 lambda : b"ond line is here\n", | 3331 lambda : b"ond line is here\n", |
2956 lambda : b"", | 3332 lambda : b"", |
2957 lambda : b"", # XXX(gps): io library does an extra EOF read | 3333 lambda : b"", # XXX(gps): io library does an extra EOF read |
2958 ]) | 3334 ]) |
2959 expecting = (b"This is the first line\n" | 3335 expecting = (b"This is the first line\n" |
2960 b"And the second line is here\n") | 3336 b"And the second line is here\n") |
2961 fo = mock_sock._textiowrap_for_test(buffering=buffering) | 3337 fo = mock_sock._textiowrap_for_test(buffering=buffering) |
2962 if buffering == 0: | 3338 if buffering == 0: |
2963 data = b'' | 3339 data = b'' |
2964 else: | 3340 else: |
2965 data = '' | 3341 data = '' |
2966 expecting = expecting.decode('utf8') | 3342 expecting = expecting.decode('utf8') |
2967 while len(data) != len(expecting): | 3343 while len(data) != len(expecting): |
2968 part = fo.read(size) | 3344 part = fo.read(size) |
2969 if not part: | 3345 if not part: |
2970 break | 3346 break |
2971 data += part | 3347 data += part |
2972 self.assertEquals(data, expecting) | 3348 self.assertEqual(data, expecting) |
2973 | 3349 |
2974 def test_default(self): | 3350 def test_default(self): |
2975 self._test_readline() | 3351 self._test_readline() |
2976 self._test_readline(size=100) | 3352 self._test_readline(size=100) |
2977 self._test_read() | 3353 self._test_read() |
2978 self._test_read(size=100) | 3354 self._test_read(size=100) |
2979 | 3355 |
2980 def test_with_1k_buffer(self): | 3356 def test_with_1k_buffer(self): |
2981 self._test_readline(buffering=1024) | 3357 self._test_readline(buffering=1024) |
2982 self._test_readline(size=100, buffering=1024) | 3358 self._test_readline(size=100, buffering=1024) |
2983 self._test_read(buffering=1024) | 3359 self._test_read(buffering=1024) |
2984 self._test_read(size=100, buffering=1024) | 3360 self._test_read(size=100, buffering=1024) |
2985 | 3361 |
2986 def _test_readline_no_buffer(self, size=-1): | 3362 def _test_readline_no_buffer(self, size=-1): |
2987 mock_sock = self.MockSocket(recv_funcs=[ | 3363 mock_sock = self.MockSocket(recv_funcs=[ |
2988 lambda : b"a", | 3364 lambda : b"a", |
2989 lambda : b"\n", | 3365 lambda : b"\n", |
2990 lambda : b"B", | 3366 lambda : b"B", |
2991 self._raise_eintr, | 3367 self._raise_eintr, |
2992 lambda : b"b", | 3368 lambda : b"b", |
2993 lambda : b"", | 3369 lambda : b"", |
2994 ]) | 3370 ]) |
2995 fo = mock_sock._textiowrap_for_test(buffering=0) | 3371 fo = mock_sock._textiowrap_for_test(buffering=0) |
2996 self.assertEquals(fo.readline(size), b"a\n") | 3372 self.assertEqual(fo.readline(size), b"a\n") |
2997 self.assertEquals(fo.readline(size), b"Bb") | 3373 self.assertEqual(fo.readline(size), b"Bb") |
2998 | 3374 |
2999 def test_no_buffer(self): | 3375 def test_no_buffer(self): |
3000 self._test_readline_no_buffer() | 3376 self._test_readline_no_buffer() |
3001 self._test_readline_no_buffer(size=4) | 3377 self._test_readline_no_buffer(size=4) |
3002 self._test_read(buffering=0) | 3378 self._test_read(buffering=0) |
3003 self._test_read(size=100, buffering=0) | 3379 self._test_read(size=100, buffering=0) |
3004 | 3380 |
3005 | 3381 |
3006 class UnbufferedFileObjectClassTestCase(FileObjectClassTestCase): | 3382 class UnbufferedFileObjectClassTestCase(FileObjectClassTestCase): |
3007 | 3383 |
3008 """Repeat the tests from FileObjectClassTestCase with bufsize==0. | 3384 """Repeat the tests from FileObjectClassTestCase with bufsize==0. |
3009 | 3385 |
3010 In this case (and in this case only), it should be possible to | 3386 In this case (and in this case only), it should be possible to |
3011 create a file object, read a line from it, create another file | 3387 create a file object, read a line from it, create another file |
3012 object, read another line from it, without loss of data in the | 3388 object, read another line from it, without loss of data in the |
3013 first file object's buffer. Note that http.client relies on this | 3389 first file object's buffer. Note that http.client relies on this |
3014 when reading multiple requests from the same socket.""" | 3390 when reading multiple requests from the same socket.""" |
3015 | 3391 |
3016 bufsize = 0 # Use unbuffered mode | 3392 bufsize = 0 # Use unbuffered mode |
3017 | 3393 |
3018 def testUnbufferedReadline(self): | 3394 def testUnbufferedReadline(self): |
3019 # Read a line, create a new file object, read another line with it | 3395 # Read a line, create a new file object, read another line with it |
3020 line = self.serv_file.readline() # first line | 3396 line = self.read_file.readline() # first line |
3021 self.assertEqual(line, b"A. " + MSG) # first line | 3397 self.assertEqual(line, b"A. " + self.write_msg) # first line |
3022 self.serv_file = self.cli_conn.makefile('rb', 0) | 3398 self.read_file = self.cli_conn.makefile('rb', 0) |
3023 line = self.serv_file.readline() # second line | 3399 line = self.read_file.readline() # second line |
3024 self.assertEqual(line, b"B. " + MSG) # second line | 3400 self.assertEqual(line, b"B. " + self.write_msg) # second line |
3025 | 3401 |
3026 def _testUnbufferedReadline(self): | 3402 def _testUnbufferedReadline(self): |
3027 self.cli_file.write(b"A. " + MSG) | 3403 self.write_file.write(b"A. " + self.write_msg) |
3028 self.cli_file.write(b"B. " + MSG) | 3404 self.write_file.write(b"B. " + self.write_msg) |
3029 self.cli_file.flush() | 3405 self.write_file.flush() |
3030 | 3406 |
3031 def testMakefileClose(self): | 3407 def testMakefileClose(self): |
3032 # The file returned by makefile should keep the socket open... | 3408 # The file returned by makefile should keep the socket open... |
3033 self.cli_conn.close() | 3409 self.cli_conn.close() |
3034 msg = self.cli_conn.recv(1024) | 3410 msg = self.cli_conn.recv(1024) |
3035 self.assertEqual(msg, MSG) | 3411 self.assertEqual(msg, self.read_msg) |
3036 # ...until the file is itself closed | 3412 # ...until the file is itself closed |
3037 self.serv_file.close() | 3413 self.read_file.close() |
3038 self.assertRaises(socket.error, self.cli_conn.recv, 1024) | 3414 self.assertRaises(socket.error, self.cli_conn.recv, 1024) |
3039 | 3415 |
3040 def _testMakefileClose(self): | 3416 def _testMakefileClose(self): |
3041 self.cli_file.write(MSG) | 3417 self.write_file.write(self.write_msg) |
3042 self.cli_file.flush() | 3418 self.write_file.flush() |
3043 | 3419 |
3044 def testMakefileCloseSocketDestroy(self): | 3420 def testMakefileCloseSocketDestroy(self): |
3045 refcount_before = sys.getrefcount(self.cli_conn) | 3421 refcount_before = sys.getrefcount(self.cli_conn) |
3046 self.serv_file.close() | 3422 self.read_file.close() |
3047 refcount_after = sys.getrefcount(self.cli_conn) | 3423 refcount_after = sys.getrefcount(self.cli_conn) |
3048 self.assertEqual(refcount_before - 1, refcount_after) | 3424 self.assertEqual(refcount_before - 1, refcount_after) |
3049 | 3425 |
3050 def _testMakefileCloseSocketDestroy(self): | 3426 def _testMakefileCloseSocketDestroy(self): |
3051 pass | 3427 pass |
3052 | 3428 |
3429 # Non-blocking ops | |
3430 # NOTE: to set `read_file` as non-blocking, we must call | |
3431 # `cli_conn.setblocking` and vice-versa (see setUp / clientSetUp). | |
3432 | |
3433 def testSmallReadNonBlocking(self): | |
3434 self.cli_conn.setblocking(False) | |
3435 self.assertEqual(self.read_file.readinto(bytearray(10)), None) | |
3436 self.assertEqual(self.read_file.read(len(self.read_msg) - 3), None) | |
3437 self.evt1.set() | |
3438 self.evt2.wait(1.0) | |
3439 first_seg = self.read_file.read(len(self.read_msg) - 3) | |
3440 buf = bytearray(10) | |
3441 n = self.read_file.readinto(buf) | |
3442 self.assertEqual(n, 3) | |
3443 msg = first_seg + buf[:n] | |
3444 self.assertEqual(msg, self.read_msg) | |
3445 self.assertEqual(self.read_file.readinto(bytearray(16)), None) | |
3446 self.assertEqual(self.read_file.read(1), None) | |
3447 | |
3448 def _testSmallReadNonBlocking(self): | |
3449 self.evt1.wait(1.0) | |
3450 self.write_file.write(self.write_msg) | |
3451 self.write_file.flush() | |
3452 self.evt2.set() | |
3453 # Avoid cloding the socket before the server test has finished, | |
3454 # otherwise system recv() will return 0 instead of EWOULDBLOCK. | |
3455 self.serv_finished.wait(5.0) | |
3456 | |
3457 def testWriteNonBlocking(self): | |
3458 self.cli_finished.wait(5.0) | |
3459 # The client thread can't skip directly - the SkipTest exception | |
3460 # would appear as a failure. | |
3461 if self.serv_skipped: | |
3462 self.skipTest(self.serv_skipped) | |
3463 | |
3464 def _testWriteNonBlocking(self): | |
3465 self.serv_skipped = None | |
3466 self.serv_conn.setblocking(False) | |
3467 # Try to saturate the socket buffer pipe with repeated large writes. | |
3468 BIG = b"x" * (1024 ** 2) | |
3469 LIMIT = 10 | |
3470 # The first write() succeeds since a chunk of data can be buffered | |
3471 n = self.write_file.write(BIG) | |
3472 self.assertGreater(n, 0) | |
3473 for i in range(LIMIT): | |
3474 n = self.write_file.write(BIG) | |
3475 if n is None: | |
3476 # Succeeded | |
3477 break | |
3478 self.assertGreater(n, 0) | |
3479 else: | |
3480 # Let us know that this test didn't manage to establish | |
3481 # the expected conditions. This is not a failure in itself but, | |
3482 # if it happens repeatedly, the test should be fixed. | |
3483 self.serv_skipped = "failed to saturate the socket buffer" | |
3484 | |
3053 | 3485 |
3054 class LineBufferedFileObjectClassTestCase(FileObjectClassTestCase): | 3486 class LineBufferedFileObjectClassTestCase(FileObjectClassTestCase): |
3055 | 3487 |
3056 bufsize = 1 # Default-buffered for reading; line-buffered for writing | 3488 bufsize = 1 # Default-buffered for reading; line-buffered for writing |
3057 | 3489 |
3058 | 3490 |
3059 class SmallBufferedFileObjectClassTestCase(FileObjectClassTestCase): | 3491 class SmallBufferedFileObjectClassTestCase(FileObjectClassTestCase): |
3060 | 3492 |
3061 bufsize = 2 # Exercise the buffering code | 3493 bufsize = 2 # Exercise the buffering code |
3494 | |
3495 | |
3496 class UnicodeReadFileObjectClassTestCase(FileObjectClassTestCase): | |
3497 """Tests for socket.makefile() in text mode (rather than binary)""" | |
3498 | |
3499 read_mode = 'r' | |
3500 read_msg = MSG.decode('utf8') | |
3501 write_mode = 'wb' | |
3502 write_msg = MSG | |
3503 newline = '' | |
3504 | |
3505 | |
3506 class UnicodeWriteFileObjectClassTestCase(FileObjectClassTestCase): | |
3507 """Tests for socket.makefile() in text mode (rather than binary)""" | |
3508 | |
3509 read_mode = 'rb' | |
3510 read_msg = MSG | |
3511 write_mode = 'w' | |
3512 write_msg = MSG.decode('utf8') | |
3513 newline = '' | |
3514 | |
3515 | |
3516 class UnicodeReadWriteFileObjectClassTestCase(FileObjectClassTestCase): | |
3517 """Tests for socket.makefile() in text mode (rather than binary)""" | |
3518 | |
3519 read_mode = 'r' | |
3520 read_msg = MSG.decode('utf8') | |
3521 write_mode = 'w' | |
3522 write_msg = MSG.decode('utf8') | |
3523 newline = '' | |
3062 | 3524 |
3063 | 3525 |
3064 class NetworkConnectionTest(object): | 3526 class NetworkConnectionTest(object): |
3065 """Prove network connection.""" | 3527 """Prove network connection.""" |
3066 | 3528 |
3067 def clientSetUp(self): | 3529 def clientSetUp(self): |
3068 # We're inherited below by BasicTCPTest2, which also inherits | 3530 # We're inherited below by BasicTCPTest2, which also inherits |
3069 # BasicTCPTest, which defines self.port referenced below. | 3531 # BasicTCPTest, which defines self.port referenced below. |
3070 self.cli = socket.create_connection((HOST, self.port)) | 3532 self.cli = socket.create_connection((HOST, self.port)) |
3071 self.serv_conn = self.cli | 3533 self.serv_conn = self.cli |
3072 | 3534 |
3073 class BasicTCPTest2(NetworkConnectionTest, BasicTCPTest): | 3535 class BasicTCPTest2(NetworkConnectionTest, BasicTCPTest): |
3074 """Tests that NetworkConnection does not break existing TCP functionality. | 3536 """Tests that NetworkConnection does not break existing TCP functionality. |
3075 """ | 3537 """ |
3076 | 3538 |
3077 class NetworkConnectionNoServer(unittest.TestCase): | 3539 class NetworkConnectionNoServer(unittest.TestCase): |
3078 | 3540 |
3079 def testWithoutServer(self): | 3541 class MockSocket(socket.socket): |
3542 def connect(self, *args): | |
3543 raise socket.timeout('timed out') | |
3544 | |
3545 @contextlib.contextmanager | |
3546 def mocked_socket_module(self): | |
3547 """Return a socket which times out on connect""" | |
3548 old_socket = socket.socket | |
3549 socket.socket = self.MockSocket | |
3550 try: | |
3551 yield | |
3552 finally: | |
3553 socket.socket = old_socket | |
3554 | |
3555 def test_connect(self): | |
3080 port = support.find_unused_port() | 3556 port = support.find_unused_port() |
3081 self.assertRaises( | 3557 cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
3082 socket.error, | 3558 self.addCleanup(cli.close) |
3083 lambda: socket.create_connection((HOST, port)) | 3559 with self.assertRaises(socket.error) as cm: |
3084 ) | 3560 cli.connect((HOST, port)) |
3561 self.assertEqual(cm.exception.errno, errno.ECONNREFUSED) | |
3562 | |
3563 def test_create_connection(self): | |
3564 # Issue #9792: errors raised by create_connection() should have | |
3565 # a proper errno attribute. | |
3566 port = support.find_unused_port() | |
3567 with self.assertRaises(socket.error) as cm: | |
3568 socket.create_connection((HOST, port)) | |
3569 self.assertEqual(cm.exception.errno, errno.ECONNREFUSED) | |
3570 | |
3571 def test_create_connection_timeout(self): | |
3572 # Issue #9792: create_connection() should not recast timeout errors | |
3573 # as generic socket errors. | |
3574 with self.mocked_socket_module(): | |
3575 with self.assertRaises(socket.timeout): | |
3576 socket.create_connection((HOST, 1234)) | |
3577 | |
3085 | 3578 |
3086 @unittest.skipUnless(thread, 'Threading required for this test.') | 3579 @unittest.skipUnless(thread, 'Threading required for this test.') |
3087 class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest): | 3580 class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest): |
3088 | 3581 |
3089 def __init__(self, methodName='runTest'): | 3582 def __init__(self, methodName='runTest'): |
3090 SocketTCPTest.__init__(self, methodName=methodName) | 3583 SocketTCPTest.__init__(self, methodName=methodName) |
3091 ThreadableTest.__init__(self) | 3584 ThreadableTest.__init__(self) |
3092 | 3585 |
3093 def clientSetUp(self): | 3586 def clientSetUp(self): |
3094 self.source_port = support.find_unused_port() | 3587 self.source_port = support.find_unused_port() |
3095 | 3588 |
3096 def clientTearDown(self): | 3589 def clientTearDown(self): |
3097 self.cli.close() | 3590 self.cli.close() |
3098 self.cli = None | 3591 self.cli = None |
3099 ThreadableTest.clientTearDown(self) | 3592 ThreadableTest.clientTearDown(self) |
3100 | 3593 |
3101 def _justAccept(self): | 3594 def _justAccept(self): |
3102 conn, addr = self.serv.accept() | 3595 conn, addr = self.serv.accept() |
3596 conn.close() | |
3103 | 3597 |
3104 testFamily = _justAccept | 3598 testFamily = _justAccept |
3105 def _testFamily(self): | 3599 def _testFamily(self): |
3106 self.cli = socket.create_connection((HOST, self.port), timeout=30) | 3600 self.cli = socket.create_connection((HOST, self.port), timeout=30) |
3601 self.addCleanup(self.cli.close) | |
3107 self.assertEqual(self.cli.family, 2) | 3602 self.assertEqual(self.cli.family, 2) |
3108 | 3603 |
3109 testSourceAddress = _justAccept | 3604 testSourceAddress = _justAccept |
3110 def _testSourceAddress(self): | 3605 def _testSourceAddress(self): |
3111 self.cli = socket.create_connection((HOST, self.port), timeout=30, | 3606 self.cli = socket.create_connection((HOST, self.port), timeout=30, |
3112 source_address=('', self.source_port)) | 3607 source_address=('', self.source_port)) |
3608 self.addCleanup(self.cli.close) | |
3113 self.assertEqual(self.cli.getsockname()[1], self.source_port) | 3609 self.assertEqual(self.cli.getsockname()[1], self.source_port) |
3114 # The port number being used is sufficient to show that the bind() | 3610 # The port number being used is sufficient to show that the bind() |
3115 # call happened. | 3611 # call happened. |
3116 | 3612 |
3117 testTimeoutDefault = _justAccept | 3613 testTimeoutDefault = _justAccept |
3118 def _testTimeoutDefault(self): | 3614 def _testTimeoutDefault(self): |
3119 # passing no explicit timeout uses socket's global default | 3615 # passing no explicit timeout uses socket's global default |
3120 self.assertTrue(socket.getdefaulttimeout() is None) | 3616 self.assertTrue(socket.getdefaulttimeout() is None) |
3121 socket.setdefaulttimeout(42) | 3617 socket.setdefaulttimeout(42) |
3122 try: | 3618 try: |
3123 self.cli = socket.create_connection((HOST, self.port)) | 3619 self.cli = socket.create_connection((HOST, self.port)) |
3620 self.addCleanup(self.cli.close) | |
3124 finally: | 3621 finally: |
3125 socket.setdefaulttimeout(None) | 3622 socket.setdefaulttimeout(None) |
3126 self.assertEquals(self.cli.gettimeout(), 42) | 3623 self.assertEqual(self.cli.gettimeout(), 42) |
3127 | 3624 |
3128 testTimeoutNone = _justAccept | 3625 testTimeoutNone = _justAccept |
3129 def _testTimeoutNone(self): | 3626 def _testTimeoutNone(self): |
3130 # None timeout means the same as sock.settimeout(None) | 3627 # None timeout means the same as sock.settimeout(None) |
3131 self.assertTrue(socket.getdefaulttimeout() is None) | 3628 self.assertTrue(socket.getdefaulttimeout() is None) |
3132 socket.setdefaulttimeout(30) | 3629 socket.setdefaulttimeout(30) |
3133 try: | 3630 try: |
3134 self.cli = socket.create_connection((HOST, self.port), timeout=None) | 3631 self.cli = socket.create_connection((HOST, self.port), timeout=None) |
3632 self.addCleanup(self.cli.close) | |
3135 finally: | 3633 finally: |
3136 socket.setdefaulttimeout(None) | 3634 socket.setdefaulttimeout(None) |
3137 self.assertEqual(self.cli.gettimeout(), None) | 3635 self.assertEqual(self.cli.gettimeout(), None) |
3138 | 3636 |
3139 testTimeoutValueNamed = _justAccept | 3637 testTimeoutValueNamed = _justAccept |
3140 def _testTimeoutValueNamed(self): | 3638 def _testTimeoutValueNamed(self): |
3141 self.cli = socket.create_connection((HOST, self.port), timeout=30) | 3639 self.cli = socket.create_connection((HOST, self.port), timeout=30) |
3142 self.assertEqual(self.cli.gettimeout(), 30) | 3640 self.assertEqual(self.cli.gettimeout(), 30) |
3143 | 3641 |
3144 testTimeoutValueNonamed = _justAccept | 3642 testTimeoutValueNonamed = _justAccept |
3145 def _testTimeoutValueNonamed(self): | 3643 def _testTimeoutValueNonamed(self): |
3146 self.cli = socket.create_connection((HOST, self.port), 30) | 3644 self.cli = socket.create_connection((HOST, self.port), 30) |
3645 self.addCleanup(self.cli.close) | |
3147 self.assertEqual(self.cli.gettimeout(), 30) | 3646 self.assertEqual(self.cli.gettimeout(), 30) |
3148 | 3647 |
3149 @unittest.skipUnless(thread, 'Threading required for this test.') | 3648 @unittest.skipUnless(thread, 'Threading required for this test.') |
3150 class NetworkConnectionBehaviourTest(SocketTCPTest, ThreadableTest): | 3649 class NetworkConnectionBehaviourTest(SocketTCPTest, ThreadableTest): |
3151 | 3650 |
3152 def __init__(self, methodName='runTest'): | 3651 def __init__(self, methodName='runTest'): |
3153 SocketTCPTest.__init__(self, methodName=methodName) | 3652 SocketTCPTest.__init__(self, methodName=methodName) |
3154 ThreadableTest.__init__(self) | 3653 ThreadableTest.__init__(self) |
3155 | 3654 |
3156 def clientSetUp(self): | 3655 def clientSetUp(self): |
3157 pass | 3656 pass |
3158 | 3657 |
3159 def clientTearDown(self): | 3658 def clientTearDown(self): |
3160 self.cli.close() | 3659 self.cli.close() |
3161 self.cli = None | 3660 self.cli = None |
3162 ThreadableTest.clientTearDown(self) | 3661 ThreadableTest.clientTearDown(self) |
3163 | 3662 |
3164 def testInsideTimeout(self): | 3663 def testInsideTimeout(self): |
3165 conn, addr = self.serv.accept() | 3664 conn, addr = self.serv.accept() |
3665 self.addCleanup(conn.close) | |
3166 time.sleep(3) | 3666 time.sleep(3) |
3167 conn.send(b"done!") | 3667 conn.send(b"done!") |
3168 testOutsideTimeout = testInsideTimeout | 3668 testOutsideTimeout = testInsideTimeout |
3169 | 3669 |
3170 def _testInsideTimeout(self): | 3670 def _testInsideTimeout(self): |
3171 self.cli = sock = socket.create_connection((HOST, self.port)) | 3671 self.cli = sock = socket.create_connection((HOST, self.port)) |
3172 data = sock.recv(5) | 3672 data = sock.recv(5) |
3173 self.assertEqual(data, b"done!") | 3673 self.assertEqual(data, b"done!") |
3174 | 3674 |
3175 def _testOutsideTimeout(self): | 3675 def _testOutsideTimeout(self): |
(...skipping 254 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
3430 def testStream(self): | 3930 def testStream(self): |
3431 msg = self.conn.recv(1024) | 3931 msg = self.conn.recv(1024) |
3432 self.assertEqual(msg, MSG) | 3932 self.assertEqual(msg, MSG) |
3433 self.assertEqual(self.cliaddr, self.connaddr) | 3933 self.assertEqual(self.cliaddr, self.connaddr) |
3434 | 3934 |
3435 def _testStream(self): | 3935 def _testStream(self): |
3436 self.cli.send(MSG) | 3936 self.cli.send(MSG) |
3437 self.cli.close() | 3937 self.cli.close() |
3438 | 3938 |
3439 | 3939 |
3940 @unittest.skipUnless(thread, 'Threading required for this test.') | |
3941 class ContextManagersTest(ThreadedTCPSocketTest): | |
3942 | |
3943 def _testSocketClass(self): | |
3944 # base test | |
3945 with socket.socket() as sock: | |
3946 self.assertFalse(sock._closed) | |
3947 self.assertTrue(sock._closed) | |
3948 # close inside with block | |
3949 with socket.socket() as sock: | |
3950 sock.close() | |
3951 self.assertTrue(sock._closed) | |
3952 # exception inside with block | |
3953 with socket.socket() as sock: | |
3954 self.assertRaises(socket.error, sock.sendall, b'foo') | |
3955 self.assertTrue(sock._closed) | |
3956 | |
3957 def testCreateConnectionBase(self): | |
3958 conn, addr = self.serv.accept() | |
3959 self.addCleanup(conn.close) | |
3960 data = conn.recv(1024) | |
3961 conn.sendall(data) | |
3962 | |
3963 def _testCreateConnectionBase(self): | |
3964 address = self.serv.getsockname() | |
3965 with socket.create_connection(address) as sock: | |
3966 self.assertFalse(sock._closed) | |
3967 sock.sendall(b'foo') | |
3968 self.assertEqual(sock.recv(1024), b'foo') | |
3969 self.assertTrue(sock._closed) | |
3970 | |
3971 def testCreateConnectionClose(self): | |
3972 conn, addr = self.serv.accept() | |
3973 self.addCleanup(conn.close) | |
3974 data = conn.recv(1024) | |
3975 conn.sendall(data) | |
3976 | |
3977 def _testCreateConnectionClose(self): | |
3978 address = self.serv.getsockname() | |
3979 with socket.create_connection(address) as sock: | |
3980 sock.close() | |
3981 self.assertTrue(sock._closed) | |
3982 self.assertRaises(socket.error, sock.sendall, b'foo') | |
3983 | |
3984 | |
3985 @unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"), | |
3986 "SOCK_CLOEXEC not defined") | |
3987 @unittest.skipUnless(fcntl, "module fcntl not available") | |
3988 class CloexecConstantTest(unittest.TestCase): | |
3989 def test_SOCK_CLOEXEC(self): | |
3990 v = linux_version() | |
3991 if v < (2, 6, 28): | |
3992 self.skipTest("Linux kernel 2.6.28 or higher required, not %s" | |
3993 % ".".join(map(str, v))) | |
3994 s = socket.socket(socket.AF_INET, | |
3995 socket.SOCK_STREAM | socket.SOCK_CLOEXEC) | |
3996 self.assertTrue(s.type & socket.SOCK_CLOEXEC) | |
3997 self.assertTrue(fcntl.fcntl(s, fcntl.F_GETFD) & fcntl.FD_CLOEXEC) | |
3998 | |
3999 | |
4000 @unittest.skipUnless(hasattr(socket, "SOCK_NONBLOCK"), | |
4001 "SOCK_NONBLOCK not defined") | |
4002 class NonblockConstantTest(unittest.TestCase): | |
4003 def checkNonblock(self, s, nonblock=True, timeout=0.0): | |
4004 if nonblock: | |
4005 self.assertTrue(s.type & socket.SOCK_NONBLOCK) | |
4006 self.assertEqual(s.gettimeout(), timeout) | |
4007 else: | |
4008 self.assertFalse(s.type & socket.SOCK_NONBLOCK) | |
4009 self.assertEqual(s.gettimeout(), None) | |
4010 | |
4011 def test_SOCK_NONBLOCK(self): | |
4012 v = linux_version() | |
4013 if v < (2, 6, 28): | |
4014 self.skipTest("Linux kernel 2.6.28 or higher required, not %s" | |
4015 % ".".join(map(str, v))) | |
4016 # a lot of it seems silly and redundant, but I wanted to test that | |
4017 # changing back and forth worked ok | |
4018 s = socket.socket(socket.AF_INET, | |
4019 socket.SOCK_STREAM | socket.SOCK_NONBLOCK) | |
4020 self.checkNonblock(s) | |
4021 s.setblocking(1) | |
4022 self.checkNonblock(s, False) | |
4023 s.setblocking(0) | |
4024 self.checkNonblock(s) | |
4025 s.settimeout(None) | |
4026 self.checkNonblock(s, False) | |
4027 s.settimeout(2.0) | |
4028 self.checkNonblock(s, timeout=2.0) | |
4029 s.setblocking(1) | |
4030 self.checkNonblock(s, False) | |
4031 # defaulttimeout | |
4032 t = socket.getdefaulttimeout() | |
4033 socket.setdefaulttimeout(0.0) | |
4034 self.checkNonblock(socket.socket()) | |
4035 socket.setdefaulttimeout(None) | |
4036 self.checkNonblock(socket.socket(), False) | |
4037 socket.setdefaulttimeout(2.0) | |
4038 self.checkNonblock(socket.socket(), timeout=2.0) | |
4039 socket.setdefaulttimeout(None) | |
4040 self.checkNonblock(socket.socket(), False) | |
4041 socket.setdefaulttimeout(t) | |
4042 | |
4043 | |
3440 def test_main(): | 4044 def test_main(): |
3441 tests = [GeneralModuleTests, BasicTCPTest, TCPCloserTest, TCPTimeoutTest, | 4045 tests = [GeneralModuleTests, BasicTCPTest, TCPCloserTest, TCPTimeoutTest, |
3442 TestExceptions, BufferIOTest, BasicTCPTest2, BasicUDPTest, UDPTimeo utTest ] | 4046 TestExceptions, BufferIOTest, BasicTCPTest2, BasicUDPTest, UDPTimeo utTest ] |
3443 | 4047 |
3444 tests.extend([ | 4048 tests.extend([ |
3445 NonBlockingTCPTests, | 4049 NonBlockingTCPTests, |
3446 FileObjectClassTestCase, | 4050 FileObjectClassTestCase, |
3447 FileObjectInterruptedTestCase, | 4051 FileObjectInterruptedTestCase, |
3448 UnbufferedFileObjectClassTestCase, | 4052 UnbufferedFileObjectClassTestCase, |
3449 LineBufferedFileObjectClassTestCase, | 4053 LineBufferedFileObjectClassTestCase, |
3450 SmallBufferedFileObjectClassTestCase, | 4054 SmallBufferedFileObjectClassTestCase, |
4055 UnicodeReadFileObjectClassTestCase, | |
4056 UnicodeWriteFileObjectClassTestCase, | |
4057 UnicodeReadWriteFileObjectClassTestCase, | |
3451 NetworkConnectionNoServer, | 4058 NetworkConnectionNoServer, |
3452 NetworkConnectionAttributesTest, | 4059 NetworkConnectionAttributesTest, |
3453 NetworkConnectionBehaviourTest, | 4060 NetworkConnectionBehaviourTest, |
4061 ContextManagersTest, | |
4062 CloexecConstantTest, | |
4063 NonblockConstantTest | |
3454 ]) | 4064 ]) |
4065 if hasattr(socket, "socketpair"): | |
4066 tests.append(BasicSocketPairTest) | |
4067 if sys.platform == 'linux2': | |
4068 tests.append(TestLinuxAbstractNamespace) | |
4069 if isTipcAvailable(): | |
4070 tests.append(TIPCTest) | |
4071 tests.append(TIPCThreadableTest) | |
3455 tests.extend([ | 4072 tests.extend([ |
3456 CmsgMacroTests, | 4073 CmsgMacroTests, |
3457 SendmsgUDPTest, | 4074 SendmsgUDPTest, |
3458 RecvmsgUDPTest, | 4075 RecvmsgUDPTest, |
3459 RecvmsgIntoUDPTest, | 4076 RecvmsgIntoUDPTest, |
3460 SendmsgUDP6Test, | 4077 SendmsgUDP6Test, |
3461 RecvmsgUDP6Test, | 4078 RecvmsgUDP6Test, |
3462 RecvmsgRFC3542AncillaryUDP6Test, | 4079 RecvmsgRFC3542AncillaryUDP6Test, |
3463 RecvmsgIntoRFC3542AncillaryUDP6Test, | 4080 RecvmsgIntoRFC3542AncillaryUDP6Test, |
3464 RecvmsgIntoUDP6Test, | 4081 RecvmsgIntoUDP6Test, |
3465 SendmsgTCPTest, | 4082 SendmsgTCPTest, |
3466 RecvmsgTCPTest, | 4083 RecvmsgTCPTest, |
3467 RecvmsgIntoTCPTest, | 4084 RecvmsgIntoTCPTest, |
3468 SendmsgSCTPStreamTest, | 4085 SendmsgSCTPStreamTest, |
3469 RecvmsgSCTPStreamTest, | 4086 RecvmsgSCTPStreamTest, |
3470 RecvmsgIntoSCTPStreamTest, | 4087 RecvmsgIntoSCTPStreamTest, |
3471 SendmsgUnixStreamTest, | 4088 SendmsgUnixStreamTest, |
3472 RecvmsgUnixStreamTest, | 4089 RecvmsgUnixStreamTest, |
3473 RecvmsgIntoUnixStreamTest, | 4090 RecvmsgIntoUnixStreamTest, |
3474 RecvmsgSCMRightsStreamTest, | 4091 RecvmsgSCMRightsStreamTest, |
3475 RecvmsgIntoSCMRightsStreamTest, | 4092 RecvmsgIntoSCMRightsStreamTest, |
4093 # These are slow when setitimer() is not available | |
4094 InterruptedRecvTimeoutTest, | |
4095 InterruptedSendTimeoutTest, | |
3476 ]) | 4096 ]) |
3477 if hasattr(socket, "socketpair"): | |
3478 tests.append(BasicSocketPairTest) | |
3479 if sys.platform == 'linux2': | |
3480 tests.append(TestLinuxAbstractNamespace) | |
3481 if isTipcAvailable(): | |
3482 tests.append(TIPCTest) | |
3483 tests.append(TIPCThreadableTest) | |
3484 | 4097 |
3485 thread_info = support.threading_setup() | 4098 thread_info = support.threading_setup() |
3486 support.run_unittest(*tests) | 4099 support.run_unittest(*tests) |
3487 support.threading_cleanup(*thread_info) | 4100 support.threading_cleanup(*thread_info) |
3488 | 4101 |
3489 if __name__ == "__main__": | 4102 if __name__ == "__main__": |
3490 test_main() | 4103 test_main() |
LEFT | RIGHT |