/policy-and-header-refactor/Lib/test/test_socket.py

   1#!/usr/bin/env python3
   2
   3import unittest
   4from test import support
   5
   6import errno
   7import io
   8import socket
   9import select
  10import time
  11import traceback
  12import queue
  13import sys
  14import os
  15import array
  16from weakref import proxy
  17import signal
  18
  19HOST = support.HOST
  20MSG = b'Michael Gilfix was here\n'
  21
  22try:
  23    import _thread as thread
  24    import threading
  25except ImportError:
  26    thread = None
  27    threading = None
  28
  29class SocketTCPTest(unittest.TestCase):
  30
  31    def setUp(self):
  32        self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  33        self.port = support.bind_port(self.serv)
  34        self.serv.listen(1)
  35
  36    def tearDown(self):
  37        self.serv.close()
  38        self.serv = None
  39
  40class SocketUDPTest(unittest.TestCase):
  41
  42    def setUp(self):
  43        self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  44        self.port = support.bind_port(self.serv)
  45
  46    def tearDown(self):
  47        self.serv.close()
  48        self.serv = None
  49
  50class ThreadableTest:
  51    """Threadable Test class
  52
  53    The ThreadableTest class makes it easy to create a threaded
  54    client/server pair from an existing unit test. To create a
  55    new threaded class from an existing unit test, use multiple
  56    inheritance:
  57
  58        class NewClass (OldClass, ThreadableTest):
  59            pass
  60
  61    This class defines two new fixture functions with obvious
  62    purposes for overriding:
  63
  64        clientSetUp ()
  65        clientTearDown ()
  66
  67    Any new test functions within the class must then define
  68    tests in pairs, where the test name is preceeded with a
  69    '_' to indicate the client portion of the test. Ex:
  70
  71        def testFoo(self):
  72            # Server portion
  73
  74        def _testFoo(self):
  75            # Client portion
  76
  77    Any exceptions raised by the clients during their tests
  78    are caught and transferred to the main thread to alert
  79    the testing framework.
  80
  81    Note, the server setup function cannot call any blocking
  82    functions that rely on the client thread during setup,
  83    unless serverExplicitReady() is called just before
  84    the blocking call (such as in setting up a client/server
  85    connection and performing the accept() in setUp().
  86    """
  87
  88    def __init__(self):
  89        # Swap the true setup function
  90        self.__setUp = self.setUp
  91        self.__tearDown = self.tearDown
  92        self.setUp = self._setUp
  93        self.tearDown = self._tearDown
  94
  95    def serverExplicitReady(self):
  96        """This method allows the server to explicitly indicate that
  97        it wants the client thread to proceed. This is useful if the
  98        server is about to execute a blocking routine that is
  99        dependent upon the client thread during its setup routine."""
 100        self.server_ready.set()
 101
 102    def _setUp(self):
 103        self.server_ready = threading.Event()
 104        self.client_ready = threading.Event()
 105        self.done = threading.Event()
 106        self.queue = queue.Queue(1)
 107
 108        # Do some munging to start the client test.
 109        methodname = self.id()
 110        i = methodname.rfind('.')
 111        methodname = methodname[i+1:]
 112        test_method = getattr(self, '_' + methodname)
 113        self.client_thread = thread.start_new_thread(
 114            self.clientRun, (test_method,))
 115
 116        self.__setUp()
 117        if not self.server_ready.is_set():
 118            self.server_ready.set()
 119        self.client_ready.wait()
 120
 121    def _tearDown(self):
 122        self.__tearDown()
 123        self.done.wait()
 124
 125        if self.queue.qsize():
 126            msg = self.queue.get()
 127            self.fail(msg)
 128
 129    def clientRun(self, test_func):
 130        self.server_ready.wait()
 131        self.client_ready.set()
 132        self.clientSetUp()
 133        if not hasattr(test_func, '__call__'):
 134            raise TypeError("test_func must be a callable function")
 135        try:
 136            test_func()
 137        except Exception as strerror:
 138            self.queue.put(strerror)
 139        self.clientTearDown()
 140
 141    def clientSetUp(self):
 142        raise NotImplementedError("clientSetUp must be implemented.")
 143
 144    def clientTearDown(self):
 145        self.done.set()
 146        thread.exit()
 147
 148class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest):
 149
 150    def __init__(self, methodName='runTest'):
 151        SocketTCPTest.__init__(self, methodName=methodName)
 152        ThreadableTest.__init__(self)
 153
 154    def clientSetUp(self):
 155        self.cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 156
 157    def clientTearDown(self):
 158        self.cli.close()
 159        self.cli = None
 160        ThreadableTest.clientTearDown(self)
 161
 162class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest):
 163
 164    def __init__(self, methodName='runTest'):
 165        SocketUDPTest.__init__(self, methodName=methodName)
 166        ThreadableTest.__init__(self)
 167
 168    def clientSetUp(self):
 169        self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 170
 171class SocketConnectedTest(ThreadedTCPSocketTest):
 172    """Socket tests for client-server connection.
 173
 174    self.cli_conn is a client socket connected to the server.  The
 175    setUp() method guarantees that it is connected to the server.
 176    """
 177
 178    def __init__(self, methodName='runTest'):
 179        ThreadedTCPSocketTest.__init__(self, methodName=methodName)
 180
 181    def setUp(self):
 182        ThreadedTCPSocketTest.setUp(self)
 183        # Indicate explicitly we're ready for the client thread to
 184        # proceed and then perform the blocking call to accept
 185        self.serverExplicitReady()
 186        conn, addr = self.serv.accept()
 187        self.cli_conn = conn
 188
 189    def tearDown(self):
 190        self.cli_conn.close()
 191        self.cli_conn = None
 192        ThreadedTCPSocketTest.tearDown(self)
 193
 194    def clientSetUp(self):
 195        ThreadedTCPSocketTest.clientSetUp(self)
 196        self.cli.connect((HOST, self.port))
 197        self.serv_conn = self.cli
 198
 199    def clientTearDown(self):
 200        self.serv_conn.close()
 201        self.serv_conn = None
 202        ThreadedTCPSocketTest.clientTearDown(self)
 203
 204class SocketPairTest(unittest.TestCase, ThreadableTest):
 205
 206    def __init__(self, methodName='runTest'):
 207        unittest.TestCase.__init__(self, methodName=methodName)
 208        ThreadableTest.__init__(self)
 209
 210    def setUp(self):
 211        self.serv, self.cli = socket.socketpair()
 212
 213    def tearDown(self):
 214        self.serv.close()
 215        self.serv = None
 216
 217    def clientSetUp(self):
 218        pass
 219
 220    def clientTearDown(self):
 221        self.cli.close()
 222        self.cli = None
 223        ThreadableTest.clientTearDown(self)
 224
 225
 226#######################################################################
 227## Begin Tests
 228
 229class GeneralModuleTests(unittest.TestCase):
 230
 231    def test_repr(self):
 232        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 233        self.assertTrue(repr(s).startswith("<socket.socket object"))
 234
 235    def test_weakref(self):
 236        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 237        p = proxy(s)
 238        self.assertEqual(p.fileno(), s.fileno())
 239        s.close()
 240        s = None
 241        try:
 242            p.fileno()
 243        except ReferenceError:
 244            pass
 245        else:
 246            self.fail('Socket proxy still exists')
 247
 248    def testSocketError(self):
 249        # Testing socket module exceptions
 250        def raise_error(*args, **kwargs):
 251            raise socket.error
 252        def raise_herror(*args, **kwargs):
 253            raise socket.herror
 254        def raise_gaierror(*args, **kwargs):
 255            raise socket.gaierror
 256        self.assertRaises(socket.error, raise_error,
 257                              "Error raising socket exception.")
 258        self.assertRaises(socket.error, raise_herror,
 259                              "Error raising socket exception.")
 260        self.assertRaises(socket.error, raise_gaierror,
 261                              "Error raising socket exception.")
 262
 263    def testCrucialConstants(self):
 264        # Testing for mission critical constants
 265        socket.AF_INET
 266        socket.SOCK_STREAM
 267        socket.SOCK_DGRAM
 268        socket.SOCK_RAW
 269        socket.SOCK_RDM
 270        socket.SOCK_SEQPACKET
 271        socket.SOL_SOCKET
 272        socket.SO_REUSEADDR
 273
 274    def testHostnameRes(self):
 275        # Testing hostname resolution mechanisms
 276        hostname = socket.gethostname()
 277        try:
 278            ip = socket.gethostbyname(hostname)
 279        except socket.error:
 280            # Probably name lookup wasn't set up right; skip this test
 281            return
 282        self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.")
 283        try:
 284            hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
 285        except socket.error:
 286            # Probably a similar problem as above; skip this test
 287            return
 288        all_host_names = [hostname, hname] + aliases
 289        fqhn = socket.getfqdn(ip)
 290        if not fqhn in all_host_names:
 291            self.fail("Error testing host resolution mechanisms. (fqdn: %s, all: %s)" % (fqhn, repr(all_host_names)))
 292
 293    def testRefCountGetNameInfo(self):
 294        # Testing reference count for getnameinfo
 295        if hasattr(sys, "getrefcount"):
 296            try:
 297                # On some versions, this loses a reference
 298                orig = sys.getrefcount(__name__)
 299                socket.getnameinfo(__name__,0)
 300            except TypeError:
 301                if sys.getrefcount(__name__) != orig:
 302                    self.fail("socket.getnameinfo loses a reference")
 303
 304    def testInterpreterCrash(self):
 305        # Making sure getnameinfo doesn't crash the interpreter
 306        try:
 307            # On some versions, this crashes the interpreter.
 308            socket.getnameinfo(('x', 0, 0, 0), 0)
 309        except socket.error:
 310            pass
 311
 312    def testNtoH(self):
 313        # This just checks that htons etc. are their own inverse,
 314        # when looking at the lower 16 or 32 bits.
 315        sizes = {socket.htonl: 32, socket.ntohl: 32,
 316                 socket.htons: 16, socket.ntohs: 16}
 317        for func, size in sizes.items():
 318            mask = (1<<size) - 1
 319            for i in (0, 1, 0xffff, ~0xffff, 2, 0x01234567, 0x76543210):
 320                self.assertEqual(i & mask, func(func(i&mask)) & mask)
 321
 322            swapped = func(mask)
 323            self.assertEqual(swapped & mask, mask)
 324            self.assertRaises(OverflowError, func, 1<<34)
 325
 326    def testNtoHErrors(self):
 327        good_values = [ 1, 2, 3, 1, 2, 3 ]
 328        bad_values = [ -1, -2, -3, -1, -2, -3 ]
 329        for k in good_values:
 330            socket.ntohl(k)
 331            socket.ntohs(k)
 332            socket.htonl(k)
 333            socket.htons(k)
 334        for k in bad_values:
 335            self.assertRaises(OverflowError, socket.ntohl, k)
 336            self.assertRaises(OverflowError, socket.ntohs, k)
 337            self.assertRaises(OverflowError, socket.htonl, k)
 338            self.assertRaises(OverflowError, socket.htons, k)
 339
 340    def testGetServBy(self):
 341        eq = self.assertEqual
 342        # Find one service that exists, then check all the related interfaces.
 343        # I've ordered this by protocols that have both a tcp and udp
 344        # protocol, at least for modern Linuxes.
 345        if sys.platform in ('linux2', 'freebsd4', 'freebsd5', 'freebsd6',
 346                            'freebsd7', 'freebsd8', 'darwin'):
 347            # avoid the 'echo' service on this platform, as there is an
 348            # assumption breaking non-standard port/protocol entry
 349            services = ('daytime', 'qotd', 'domain')
 350        else:
 351            services = ('echo', 'daytime', 'domain')
 352        for service in services:
 353            try:
 354                port = socket.getservbyname(service, 'tcp')
 355                break
 356            except socket.error:
 357                pass
 358        else:
 359            raise socket.error
 360        # Try same call with optional protocol omitted
 361        port2 = socket.getservbyname(service)
 362        eq(port, port2)
 363        # Try udp, but don't barf it it doesn't exist
 364        try:
 365            udpport = socket.getservbyname(service, 'udp')
 366        except socket.error:
 367            udpport = None
 368        else:
 369            eq(udpport, port)
 370        # Now make sure the lookup by port returns the same service name
 371        eq(socket.getservbyport(port2), service)
 372        eq(socket.getservbyport(port, 'tcp'), service)
 373        if udpport is not None:
 374            eq(socket.getservbyport(udpport, 'udp'), service)
 375        # Make sure getservbyport does not accept out of range ports.
 376        self.assertRaises(OverflowError, socket.getservbyport, -1)
 377        self.assertRaises(OverflowError, socket.getservbyport, 65536)
 378
 379    def testDefaultTimeout(self):
 380        # Testing default timeout
 381        # The default timeout should initially be None
 382        self.assertEqual(socket.getdefaulttimeout(), None)
 383        s = socket.socket()
 384        self.assertEqual(s.gettimeout(), None)
 385        s.close()
 386
 387        # Set the default timeout to 10, and see if it propagates
 388        socket.setdefaulttimeout(10)
 389        self.assertEqual(socket.getdefaulttimeout(), 10)
 390        s = socket.socket()
 391        self.assertEqual(s.gettimeout(), 10)
 392        s.close()
 393
 394        # Reset the default timeout to None, and see if it propagates
 395        socket.setdefaulttimeout(None)
 396        self.assertEqual(socket.getdefaulttimeout(), None)
 397        s = socket.socket()
 398        self.assertEqual(s.gettimeout(), None)
 399        s.close()
 400
 401        # Check that setting it to an invalid value raises ValueError
 402        self.assertRaises(ValueError, socket.setdefaulttimeout, -1)
 403
 404        # Check that setting it to an invalid type raises TypeError
 405        self.assertRaises(TypeError, socket.setdefaulttimeout, "spam")
 406
 407    def testIPv4_inet_aton_fourbytes(self):
 408        if not hasattr(socket, 'inet_aton'):
 409            return  # No inet_aton, nothing to check
 410        # Test that issue1008086 and issue767150 are fixed.
 411        # It must return 4 bytes.
 412        self.assertEquals(b'\x00'*4, socket.inet_aton('0.0.0.0'))
 413        self.assertEquals(b'\xff'*4, socket.inet_aton('255.255.255.255'))
 414
 415    def testIPv4toString(self):
 416        if not hasattr(socket, 'inet_pton'):
 417            return # No inet_pton() on this platform
 418        from socket import inet_aton as f, inet_pton, AF_INET
 419        g = lambda a: inet_pton(AF_INET, a)
 420
 421        self.assertEquals(b'\x00\x00\x00\x00', f('0.0.0.0'))
 422        self.assertEquals(b'\xff\x00\xff\x00', f('255.0.255.0'))
 423        self.assertEquals(b'\xaa\xaa\xaa\xaa', f('170.170.170.170'))
 424        self.assertEquals(b'\x01\x02\x03\x04', f('1.2.3.4'))
 425        self.assertEquals(b'\xff\xff\xff\xff', f('255.255.255.255'))
 426
 427        self.assertEquals(b'\x00\x00\x00\x00', g('0.0.0.0'))
 428        self.assertEquals(b'\xff\x00\xff\x00', g('255.0.255.0'))
 429        self.assertEquals(b'\xaa\xaa\xaa\xaa', g('170.170.170.170'))
 430        self.assertEquals(b'\xff\xff\xff\xff', g('255.255.255.255'))
 431
 432    def testIPv6toString(self):
 433        if not hasattr(socket, 'inet_pton'):
 434            return # No inet_pton() on this platform
 435        try:
 436            from socket import inet_pton, AF_INET6, has_ipv6
 437            if not has_ipv6:
 438                return
 439        except ImportError:
 440            return
 441        f = lambda a: inet_pton(AF_INET6, a)
 442
 443        self.assertEquals(b'\x00' * 16, f('::'))
 444        self.assertEquals(b'\x00' * 16, f('0::0'))
 445        self.assertEquals(b'\x00\x01' + b'\x00' * 14, f('1::'))
 446        self.assertEquals(
 447            b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae',
 448            f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae')
 449        )
 450
 451    def testStringToIPv4(self):
 452        if not hasattr(socket, 'inet_ntop'):
 453            return # No inet_ntop() on this platform
 454        from socket import inet_ntoa as f, inet_ntop, AF_INET
 455        g = lambda a: inet_ntop(AF_INET, a)
 456
 457        self.assertEquals('1.0.1.0', f(b'\x01\x00\x01\x00'))
 458        self.assertEquals('170.85.170.85', f(b'\xaa\x55\xaa\x55'))
 459        self.assertEquals('255.255.255.255', f(b'\xff\xff\xff\xff'))
 460        self.assertEquals('1.2.3.4', f(b'\x01\x02\x03\x04'))
 461
 462        self.assertEquals('1.0.1.0', g(b'\x01\x00\x01\x00'))
 463        self.assertEquals('170.85.170.85', g(b'\xaa\x55\xaa\x55'))
 464        self.assertEquals('255.255.255.255', g(b'\xff\xff\xff\xff'))
 465
 466    def testStringToIPv6(self):
 467        if not hasattr(socket, 'inet_ntop'):
 468            return # No inet_ntop() on this platform
 469        try:
 470            from socket import inet_ntop, AF_INET6, has_ipv6
 471            if not has_ipv6:
 472                return
 473        except ImportError:
 474            return
 475        f = lambda a: inet_ntop(AF_INET6, a)
 476
 477        self.assertEquals('::', f(b'\x00' * 16))
 478        self.assertEquals('::1', f(b'\x00' * 15 + b'\x01'))
 479        self.assertEquals(
 480            'aef:b01:506:1001:ffff:9997:55:170',
 481            f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70')
 482        )
 483
 484    # XXX The following don't test module-level functionality...
 485
 486    def _get_unused_port(self, bind_address='0.0.0.0'):
 487        """Use a temporary socket to elicit an unused ephemeral port.
 488
 489        Args:
 490            bind_address: Hostname or IP address to search for a port on.
 491
 492        Returns: A most likely to be unused port.
 493        """
 494        tempsock = socket.socket()
 495        tempsock.bind((bind_address, 0))
 496        host, port = tempsock.getsockname()
 497        tempsock.close()
 498        return port
 499
 500    def testSockName(self):
 501        # Testing getsockname()
 502        port = self._get_unused_port()
 503        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 504        sock.bind(("0.0.0.0", port))
 505        name = sock.getsockname()
 506        # XXX(nnorwitz): http://tinyurl.com/os5jz seems to indicate
 507        # it reasonable to get the host's addr in addition to 0.0.0.0.
 508        # At least for eCos.  This is required for the S/390 to pass.
 509        my_ip_addr = socket.gethostbyname(socket.gethostname())
 510        self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
 511        self.assertEqual(name[1], port)
 512
 513    def testGetSockOpt(self):
 514        # Testing getsockopt()
 515        # We know a socket should start without reuse==0
 516        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 517        reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
 518        self.assertFalse(reuse != 0, "initial mode is reuse")
 519
 520    def testSetSockOpt(self):
 521        # Testing setsockopt()
 522        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 523        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 524        reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
 525        self.assertFalse(reuse == 0, "failed to set reuse mode")
 526
 527    def testSendAfterClose(self):
 528        # testing send() after close() with timeout
 529        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 530        sock.settimeout(1)
 531        sock.close()
 532        self.assertRaises(socket.error, sock.send, b"spam")
 533
 534    def testNewAttributes(self):
 535        # testing .family, .type and .protocol
 536        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 537        self.assertEqual(sock.family, socket.AF_INET)
 538        self.assertEqual(sock.type, socket.SOCK_STREAM)
 539        self.assertEqual(sock.proto, 0)
 540        sock.close()
 541
 542    def test_getsockaddrarg(self):
 543        host = '0.0.0.0'
 544        port = self._get_unused_port(bind_address=host)
 545        big_port = port + 65536
 546        neg_port = port - 65536
 547        sock = socket.socket()
 548        try:
 549            self.assertRaises(OverflowError, sock.bind, (host, big_port))
 550            self.assertRaises(OverflowError, sock.bind, (host, neg_port))
 551            sock.bind((host, port))
 552        finally:
 553            sock.close()
 554
 555    def test_sock_ioctl(self):
 556        if os.name != "nt":
 557            return
 558        self.assertTrue(hasattr(socket.socket, 'ioctl'))
 559        self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
 560        self.assertTrue(hasattr(socket, 'RCVALL_ON'))
 561        self.assertTrue(hasattr(socket, 'RCVALL_OFF'))
 562        self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS'))
 563        s = socket.socket()
 564        self.assertRaises(ValueError, s.ioctl, -1, None)
 565        s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 100, 100))
 566
 567
 568@unittest.skipUnless(thread, 'Threading required for this test.')
 569class BasicTCPTest(SocketConnectedTest):
 570
 571    def __init__(self, methodName='runTest'):
 572        SocketConnectedTest.__init__(self, methodName=methodName)
 573
 574    def testRecv(self):
 575        # Testing large receive over TCP
 576        msg = self.cli_conn.recv(1024)
 577        self.assertEqual(msg, MSG)
 578
 579    def _testRecv(self):
 580        self.serv_conn.send(MSG)
 581
 582    def testOverFlowRecv(self):
 583        # Testing receive in chunks over TCP
 584        seg1 = self.cli_conn.recv(len(MSG) - 3)
 585        seg2 = self.cli_conn.recv(1024)
 586        msg = seg1 + seg2
 587        self.assertEqual(msg, MSG)
 588
 589    def _testOverFlowRecv(self):
 590        self.serv_conn.send(MSG)
 591
 592    def testRecvFrom(self):
 593        # Testing large recvfrom() over TCP
 594        msg, addr = self.cli_conn.recvfrom(1024)
 595        self.assertEqual(msg, MSG)
 596
 597    def _testRecvFrom(self):
 598        self.serv_conn.send(MSG)
 599
 600    def testOverFlowRecvFrom(self):
 601        # Testing recvfrom() in chunks over TCP
 602        seg1, addr = self.cli_conn.recvfrom(len(MSG)-3)
 603        seg2, addr = self.cli_conn.recvfrom(1024)
 604        msg = seg1 + seg2
 605        self.assertEqual(msg, MSG)
 606
 607    def _testOverFlowRecvFrom(self):
 608        self.serv_conn.send(MSG)
 609
 610    def testSendAll(self):
 611        # Testing sendall() with a 2048 byte string over TCP
 612        msg = b''
 613        while 1:
 614            read = self.cli_conn.recv(1024)
 615            if not read:
 616                break
 617            msg += read
 618        self.assertEqual(msg, b'f' * 2048)
 619
 620    def _testSendAll(self):
 621        big_chunk = b'f' * 2048
 622        self.serv_conn.sendall(big_chunk)
 623
 624    def testFromFd(self):
 625        # Testing fromfd()
 626        if not hasattr(socket, "fromfd"):
 627            return # On Windows, this doesn't exist
 628        fd = self.cli_conn.fileno()
 629        sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
 630        msg = sock.recv(1024)
 631        self.assertEqual(msg, MSG)
 632
 633    def _testFromFd(self):
 634        self.serv_conn.send(MSG)
 635
 636    def testDup(self):
 637        # Testing dup()
 638        sock = self.cli_conn.dup()
 639        msg = sock.recv(1024)
 640        self.assertEqual(msg, MSG)
 641
 642    def _testDup(self):
 643        self.serv_conn.send(MSG)
 644
 645    def testShutdown(self):
 646        # Testing shutdown()
 647        msg = self.cli_conn.recv(1024)
 648        self.assertEqual(msg, MSG)
 649        # wait for _testShutdown to finish: on OS X, when the server
 650        # closes the connection the client also becomes disconnected,
 651        # and the client's shutdown call will fail. (Issue #4397.)
 652        self.done.wait()
 653
 654    def _testShutdown(self):
 655        self.serv_conn.send(MSG)
 656        self.serv_conn.shutdown(2)
 657
 658@unittest.skipUnless(thread, 'Threading required for this test.')
 659class BasicUDPTest(ThreadedUDPSocketTest):
 660
 661    def __init__(self, methodName='runTest'):
 662        ThreadedUDPSocketTest.__init__(self, methodName=methodName)
 663
 664    def testSendtoAndRecv(self):
 665        # Testing sendto() and Recv() over UDP
 666        msg = self.serv.recv(len(MSG))
 667        self.assertEqual(msg, MSG)
 668
 669    def _testSendtoAndRecv(self):
 670        self.cli.sendto(MSG, 0, (HOST, self.port))
 671
 672    def testRecvFrom(self):
 673        # Testing recvfrom() over UDP
 674        msg, addr = self.serv.recvfrom(len(MSG))
 675        self.assertEqual(msg, MSG)
 676
 677    def _testRecvFrom(self):
 678        self.cli.sendto(MSG, 0, (HOST, self.port))
 679
 680    def testRecvFromNegative(self):
 681        # Negative lengths passed to recvfrom should give ValueError.
 682        self.assertRaises(ValueError, self.serv.recvfrom, -1)
 683
 684    def _testRecvFromNegative(self):
 685        self.cli.sendto(MSG, 0, (HOST, self.port))
 686
 687@unittest.skipUnless(thread, 'Threading required for this test.')
 688class TCPCloserTest(ThreadedTCPSocketTest):
 689
 690    def testClose(self):
 691        conn, addr = self.serv.accept()
 692        conn.close()
 693
 694        sd = self.cli
 695        read, write, err = select.select([sd], [], [], 1.0)
 696        self.assertEqual(read, [sd])
 697        self.assertEqual(sd.recv(1), b'')
 698
 699        # Calling close() many times should be safe.
 700        conn.close()
 701        conn.close()
 702
 703    def _testClose(self):
 704        self.cli.connect((HOST, self.port))
 705        time.sleep(1.0)
 706
 707@unittest.skipUnless(thread, 'Threading required for this test.')
 708class BasicSocketPairTest(SocketPairTest):
 709
 710    def __init__(self, methodName='runTest'):
 711        SocketPairTest.__init__(self, methodName=methodName)
 712
 713    def testRecv(self):
 714        msg = self.serv.recv(1024)
 715        self.assertEqual(msg, MSG)
 716
 717    def _testRecv(self):
 718        self.cli.send(MSG)
 719
 720    def testSend(self):
 721        self.serv.send(MSG)
 722
 723    def _testSend(self):
 724        msg = self.cli.recv(1024)
 725        self.assertEqual(msg, MSG)
 726
 727@unittest.skipUnless(thread, 'Threading required for this test.')
 728class NonBlockingTCPTests(ThreadedTCPSocketTest):
 729
 730    def __init__(self, methodName='runTest'):
 731        ThreadedTCPSocketTest.__init__(self, methodName=methodName)
 732
 733    def testSetBlocking(self):
 734        # Testing whether set blocking works
 735        self.serv.setblocking(0)
 736        start = time.time()
 737        try:
 738            self.serv.accept()
 739        except socket.error:
 740            pass
 741        end = time.time()
 742        self.assertTrue((end - start) < 1.0, "Error setting non-blocking mode.")
 743
 744    def _testSetBlocking(self):
 745        pass
 746
 747    def testAccept(self):
 748        # Testing non-blocking accept
 749        self.serv.setblocking(0)
 750        try:
 751            conn, addr = self.serv.accept()
 752        except socket.error:
 753            pass
 754        else:
 755            self.fail("Error trying to do non-blocking accept.")
 756        read, write, err = select.select([self.serv], [], [])
 757        if self.serv in read:
 758            conn, addr = self.serv.accept()
 759        else:
 760            self.fail("Error trying to do accept after select.")
 761
 762    def _testAccept(self):
 763        time.sleep(0.1)
 764        self.cli.connect((HOST, self.port))
 765
 766    def testConnect(self):
 767        # Testing non-blocking connect
 768        conn, addr = self.serv.accept()
 769
 770    def _testConnect(self):
 771        self.cli.settimeout(10)
 772        self.cli.connect((HOST, self.port))
 773
 774    def testRecv(self):
 775        # Testing non-blocking recv
 776        conn, addr = self.serv.accept()
 777        conn.setblocking(0)
 778        try:
 779            msg = conn.recv(len(MSG))
 780        except socket.error:
 781            pass
 782        else:
 783            self.fail("Error trying to do non-blocking recv.")
 784        read, write, err = select.select([conn], [], [])
 785        if conn in read:
 786            msg = conn.recv(len(MSG))
 787            self.assertEqual(msg, MSG)
 788        else:
 789            self.fail("Error during select call to non-blocking socket.")
 790
 791    def _testRecv(self):
 792        self.cli.connect((HOST, self.port))
 793        time.sleep(0.1)
 794        self.cli.send(MSG)
 795
 796@unittest.skipUnless(thread, 'Threading required for this test.')
 797class FileObjectClassTestCase(SocketConnectedTest):
 798    """Unit tests for the object returned by socket.makefile()
 799
 800    self.serv_file is the io object returned by makefile() on
 801    the client connection.  You can read from this file to
 802    get output from the server.
 803
 804    self.cli_file is the io object returned by makefile() on the
 805    server connection.  You can write to this file to send output
 806    to the client.
 807    """
 808
 809    bufsize = -1 # Use default buffer size
 810
 811    def __init__(self, methodName='runTest'):
 812        SocketConnectedTest.__init__(self, methodName=methodName)
 813
 814    def setUp(self):
 815        SocketConnectedTest.setUp(self)
 816        self.serv_file = self.cli_conn.makefile('rb', self.bufsize)
 817
 818    def tearDown(self):
 819        self.serv_file.close()
 820        self.assertTrue(self.serv_file.closed)
 821        self.serv_file = None
 822        SocketConnectedTest.tearDown(self)
 823
 824    def clientSetUp(self):
 825        SocketConnectedTest.clientSetUp(self)
 826        self.cli_file = self.serv_conn.makefile('wb')
 827
 828    def clientTearDown(self):
 829        self.cli_file.close()
 830        self.assertTrue(self.cli_file.closed)
 831        self.cli_file = None
 832        SocketConnectedTest.clientTearDown(self)
 833
 834    def testSmallRead(self):
 835        # Performing small file read test
 836        first_seg = self.serv_file.read(len(MSG)-3)
 837        second_seg = self.serv_file.read(3)
 838        msg = first_seg + second_seg
 839        self.assertEqual(msg, MSG)
 840
 841    def _testSmallRead(self):
 842        self.cli_file.write(MSG)
 843        self.cli_file.flush()
 844
 845    def testFullRead(self):
 846        # read until EOF
 847        msg = self.serv_file.read()
 848        self.assertEqual(msg, MSG)
 849
 850    def _testFullRead(self):
 851        self.cli_file.write(MSG)
 852        self.cli_file.close()
 853
 854    def testUnbufferedRead(self):
 855        # Performing unbuffered file read test
 856        buf = b''
 857        while 1:
 858            char = self.serv_file.read(1)
 859            if not char:
 860                break
 861            buf += char
 862        self.assertEqual(buf, MSG)
 863
 864    def _testUnbufferedRead(self):
 865        self.cli_file.write(MSG)
 866        self.cli_file.flush()
 867
 868    def testReadline(self):
 869        # Performing file readline test
 870        line = self.serv_file.readline()
 871        self.assertEqual(line, MSG)
 872
 873    def _testReadline(self):
 874        self.cli_file.write(MSG)
 875        self.cli_file.flush()
 876
 877    def testCloseAfterMakefile(self):
 878        # The file returned by makefile should keep the socket open.
 879        self.cli_conn.close()
 880        # read until EOF
 881        msg = self.serv_file.read()
 882        self.assertEqual(msg, MSG)
 883
 884    def _testCloseAfterMakefile(self):
 885        self.cli_file.write(MSG)
 886        self.cli_file.flush()
 887
 888    def testMakefileAfterMakefileClose(self):
 889        self.serv_file.close()
 890        msg = self.cli_conn.recv(len(MSG))
 891        self.assertEqual(msg, MSG)
 892
 893    def _testMakefileAfterMakefileClose(self):
 894        self.cli_file.write(MSG)
 895        self.cli_file.flush()
 896
 897    def testClosedAttr(self):
 898        self.assertTrue(not self.serv_file.closed)
 899
 900    def _testClosedAttr(self):
 901        self.assertTrue(not self.cli_file.closed)
 902
 903    def testAttributes(self):
 904        self.assertEqual(self.serv_file.mode, 'rb')
 905        self.assertEqual(self.serv_file.name, self.cli_conn.fileno())
 906
 907    def _testAttributes(self):
 908        self.assertEqual(self.cli_file.mode, 'wb')
 909        self.assertEqual(self.cli_file.name, self.serv_conn.fileno())
 910
 911    def testRealClose(self):
 912        self.serv_file.close()
 913        self.assertRaises(ValueError, self.serv_file.fileno)
 914        self.cli_conn.close()
 915        self.assertRaises(socket.error, self.cli_conn.getsockname)
 916
 917    def _testRealClose(self):
 918        pass
 919
 920
 921class FileObjectInterruptedTestCase(unittest.TestCase):
 922    """Test that the file object correctly handles EINTR internally."""
 923
 924    class MockSocket(object):
 925        def __init__(self, recv_funcs=()):
 926            # A generator that returns callables that we'll call for each
 927            # call to recv().
 928            self._recv_step = iter(recv_funcs)
 929
 930        def recv_into(self, buffer):
 931            data = next(self._recv_step)()
 932            assert len(buffer) >= len(data)
 933            buffer[:len(data)] = data
 934            return len(data)
 935
 936        def _decref_socketios(self):
 937            pass
 938
 939        def _textiowrap_for_test(self, buffering=-1):
 940            raw = socket.SocketIO(self, "r")
 941            if buffering < 0:
 942                buffering = io.DEFAULT_BUFFER_SIZE
 943            if buffering == 0:
 944                return raw
 945            buffer = io.BufferedReader(raw, buffering)
 946            text = io.TextIOWrapper(buffer, None, None)
 947            text.mode = "rb"
 948            return text
 949
 950    @staticmethod
 951    def _raise_eintr():
 952        raise socket.error(errno.EINTR)
 953
 954    def _textiowrap_mock_socket(self, mock, buffering=-1):
 955        raw = socket.SocketIO(mock, "r")
 956        if buffering < 0:
 957            buffering = io.DEFAULT_BUFFER_SIZE
 958        if buffering == 0:
 959            return raw
 960        buffer = io.BufferedReader(raw, buffering)
 961        text = io.TextIOWrapper(buffer, None, None)
 962        text.mode = "rb"
 963        return text
 964
 965    def _test_readline(self, size=-1, buffering=-1):
 966        mock_sock = self.MockSocket(recv_funcs=[
 967                lambda : b"This is the first line\nAnd the sec",
 968                self._raise_eintr,
 969                lambda : b"ond line is here\n",
 970                lambda : b"",
 971                lambda : b"",  # XXX(gps): io library does an extra EOF read
 972            ])
 973        fo = mock_sock._textiowrap_for_test(buffering=buffering)
 974        self.assertEquals(fo.readline(size), "This is the first line\n")
 975        self.assertEquals(fo.readline(size), "And the second line is here\n")
 976
 977    def _test_read(self, size=-1, buffering=-1):
 978        mock_sock = self.MockSocket(recv_funcs=[
 979                lambda : b"This is the first line\nAnd the sec",
 980                self._raise_eintr,
 981                lambda : b"ond line is here\n",
 982                lambda : b"",
 983                lambda : b"",  # XXX(gps): io library does an extra EOF read
 984            ])
 985        expecting = (b"This is the first line\n"
 986                     b"And the second line is here\n")
 987        fo = mock_sock._textiowrap_for_test(buffering=buffering)
 988        if buffering == 0:
 989            data = b''
 990        else:
 991            data = ''
 992            expecting = expecting.decode('utf8')
 993        while len(data) != len(expecting):
 994            part = fo.read(size)
 995            if not part:
 996                break
 997            data += part
 998        self.assertEquals(data, expecting)
 999
1000    def test_default(self):
1001        self._test_readline()
1002        self._test_readline(size=100)
1003        self._test_read()
1004        self._test_read(size=100)
1005
1006    def test_with_1k_buffer(self):
1007        self._test_readline(buffering=1024)
1008        self._test_readline(size=100, buffering=1024)
1009        self._test_read(buffering=1024)
1010        self._test_read(size=100, buffering=1024)
1011
1012    def _test_readline_no_buffer(self, size=-1):
1013        mock_sock = self.MockSocket(recv_funcs=[
1014                lambda : b"a",
1015                lambda : b"\n",
1016                lambda : b"B",
1017                self._raise_eintr,
1018                lambda : b"b",
1019                lambda : b"",
1020            ])
1021        fo = mock_sock._textiowrap_for_test(buffering=0)
1022        self.assertEquals(fo.readline(size), b"a\n")
1023        self.assertEquals(fo.readline(size), b"Bb")
1024
1025    def test_no_buffer(self):
1026        self._test_readline_no_buffer()
1027        self._test_readline_no_buffer(size=4)
1028        self._test_read(buffering=0)
1029        self._test_read(size=100, buffering=0)
1030
1031
1032class UnbufferedFileObjectClassTestCase(FileObjectClassTestCase):
1033
1034    """Repeat the tests from FileObjectClassTestCase with bufsize==0.
1035
1036    In this case (and in this case only), it should be possible to
1037    create a file object, read a line from it, create another file
1038    object, read another line from it, without loss of data in the
1039    first file object's buffer.  Note that http.client relies on this
1040    when reading multiple requests from the same socket."""
1041
1042    bufsize = 0 # Use unbuffered mode
1043
1044    def testUnbufferedReadline(self):
1045        # Read a line, create a new file object, read another line with it
1046        line = self.serv_file.readline() # first line
1047        self.assertEqual(line, b"A. " + MSG) # first line
1048        self.serv_file = self.cli_conn.makefile('rb', 0)
1049        line = self.serv_file.readline() # second line
1050        self.assertEqual(line, b"B. " + MSG) # second line
1051
1052    def _testUnbufferedReadline(self):
1053        self.cli_file.write(b"A. " + MSG)
1054        self.cli_file.write(b"B. " + MSG)
1055        self.cli_file.flush()
1056
1057    def testMakefileClose(self):
1058        # The file returned by makefile should keep the socket open...
1059        self.cli_conn.close()
1060        msg = self.cli_conn.recv(1024)
1061        self.assertEqual(msg, MSG)
1062        # ...until the file is itself closed
1063        self.serv_file.close()
1064        self.assertRaises(socket.error, self.cli_conn.recv, 1024)
1065
1066    def _testMakefileClose(self):
1067        self.cli_file.write(MSG)
1068        self.cli_file.flush()
1069
1070    def testMakefileCloseSocketDestroy(self):
1071        refcount_before = sys.getrefcount(self.cli_conn)
1072        self.serv_file.close()
1073        refcount_after = sys.getrefcount(self.cli_conn)
1074        self.assertEqual(refcount_before - 1, refcount_after)
1075
1076    def _testMakefileCloseSocketDestroy(self):
1077        pass
1078
1079
1080class LineBufferedFileObjectClassTestCase(FileObjectClassTestCase):
1081
1082    bufsize = 1 # Default-buffered for reading; line-buffered for writing
1083
1084
1085class SmallBufferedFileObjectClassTestCase(FileObjectClassTestCase):
1086
1087    bufsize = 2 # Exercise the buffering code
1088
1089
1090class NetworkConnectionTest(object):
1091    """Prove network connection."""
1092
1093    def clientSetUp(self):
1094        # We're inherited below by BasicTCPTest2, which also inherits
1095        # BasicTCPTest, which defines self.port referenced below.
1096        self.cli = socket.create_connection((HOST, self.port))
1097        self.serv_conn = self.cli
1098
1099class BasicTCPTest2(NetworkConnectionTest, BasicTCPTest):
1100    """Tests that NetworkConnection does not break existing TCP functionality.
1101    """
1102
1103class NetworkConnectionNoServer(unittest.TestCase):
1104
1105    def testWithoutServer(self):
1106        port = support.find_unused_port()
1107        self.assertRaises(
1108            socket.error,
1109            lambda: socket.create_connection((HOST, port))
1110        )
1111
1112@unittest.skipUnless(thread, 'Threading required for this test.')
1113class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest):
1114
1115    def __init__(self, methodName='runTest'):
1116        SocketTCPTest.__init__(self, methodName=methodName)
1117        ThreadableTest.__init__(self)
1118
1119    def clientSetUp(self):
1120        self.source_port = support.find_unused_port()
1121
1122    def clientTearDown(self):
1123        self.cli.close()
1124        self.cli = None
1125        ThreadableTest.clientTearDown(self)
1126
1127    def _justAccept(self):
1128        conn, addr = self.serv.accept()
1129
1130    testFamily = _justAccept
1131    def _testFamily(self):
1132        self.cli = socket.create_connection((HOST, self.port), timeout=30)
1133        self.assertEqual(self.cli.family, 2)
1134
1135    testSourceAddress = _justAccept
1136    def _testSourceAddress(self):
1137        self.cli = socket.create_connection((HOST, self.port), timeout=30,
1138                source_address=('', self.source_port))
1139        self.assertEqual(self.cli.getsockname()[1], self.source_port)
1140        # The port number being used is sufficient to show that the bind()
1141        # call happened.
1142
1143    testTimeoutDefault = _justAccept
1144    def _testTimeoutDefault(self):
1145        # passing no explicit timeout uses socket's global default
1146        self.assertTrue(socket.getdefaulttimeout() is None)
1147        socket.setdefaulttimeout(42)
1148        try:
1149            self.cli = socket.create_connection((HOST, self.port))
1150        finally:
1151            socket.setdefaulttimeout(None)
1152        self.assertEquals(self.cli.gettimeout(), 42)
1153
1154    testTimeoutNone = _justAccept
1155    def _testTimeoutNone(self):
1156        # None timeout means the same as sock.settimeout(None)
1157        self.assertTrue(socket.getdefaulttimeout() is None)
1158        socket.setdefaulttimeout(30)
1159        try:
1160            self.cli = socket.create_connection((HOST, self.port), timeout=None)
1161        finally:
1162            socket.setdefaulttimeout(None)
1163        self.assertEqual(self.cli.gettimeout(), None)
1164
1165    testTimeoutValueNamed = _justAccept
1166    def _testTimeoutValueNamed(self):
1167        self.cli = socket.create_connection((HOST, self.port), timeout=30)
1168        self.assertEqual(self.cli.gettimeout(), 30)
1169
1170    testTimeoutValueNonamed = _justAccept
1171    def _testTimeoutValueNonamed(self):
1172        self.cli = socket.create_connection((HOST, self.port), 30)
1173        self.assertEqual(self.cli.gettimeout(), 30)
1174
1175@unittest.skipUnless(thread, 'Threading required for this test.')
1176class NetworkConnectionBehaviourTest(SocketTCPTest, ThreadableTest):
1177
1178    def __init__(self, methodName='runTest'):
1179        SocketTCPTest.__init__(self, methodName=methodName)
1180        ThreadableTest.__init__(self)
1181
1182    def clientSetUp(self):
1183        pass
1184
1185    def clientTearDown(self):
1186        self.cli.close()
1187        self.cli = None
1188        ThreadableTest.clientTearDown(self)
1189
1190    def testInsideTimeout(self):
1191        conn, addr = self.serv.accept()
1192        time.sleep(3)
1193        conn.send(b"done!")
1194    testOutsideTimeout = testInsideTimeout
1195
1196    def _testInsideTimeout(self):
1197        self.cli = sock = socket.create_connection((HOST, self.port))
1198        data = sock.recv(5)
1199        self.assertEqual(data, b"done!")
1200
1201    def _testOutsideTimeout(self):
1202        self.cli = sock = socket.create_connection((HOST, self.port), timeout=1)
1203        self.assertRaises(socket.timeout, lambda: sock.recv(5))
1204
1205
1206class TCPTimeoutTest(SocketTCPTest):
1207
1208    def testTCPTimeout(self):
1209        def raise_timeout(*args, **kwargs):
1210            self.serv.settimeout(1.0)
1211            self.serv.accept()
1212        self.assertRaises(socket.timeout, raise_timeout,
1213                              "Error generating a timeout exception (TCP)")
1214
1215    def testTimeoutZero(self):
1216        ok = False
1217        try:
1218            self.serv.settimeout(0.0)
1219            foo = self.serv.accept()
1220        except socket.timeout:
1221            self.fail("caught timeout instead of error (TCP)")
1222        except socket.error:
1223            ok = True
1224        except:
1225            self.fail("caught unexpected exception (TCP)")
1226        if not ok:
1227            self.fail("accept() returned success when we did not expect it")
1228
1229    def testInterruptedTimeout(self):
1230        # XXX I don't know how to do this test on MSWindows or any other
1231        # plaform that doesn't support signal.alarm() or os.kill(), though
1232        # the bug should have existed on all platforms.
1233        if not hasattr(signal, "alarm"):
1234            return                  # can only test on *nix
1235        self.serv.settimeout(5.0)   # must be longer than alarm
1236        class Alarm(Exception):
1237            pass
1238        def alarm_handler(signal, frame):
1239            raise Alarm
1240        old_alarm = signal.signal(signal.SIGALRM, alarm_handler)
1241        try:
1242            signal.alarm(2)    # POSIX allows alarm to be up to 1 second early
1243            try:
1244                foo = self.serv.accept()
1245            except socket.timeout:
1246                self.fail("caught timeout instead of Alarm")
1247            except Alarm:
1248                pass
1249            except:
1250                self.fail("caught other exception instead of Alarm:"
1251                          " %s(%s):\n%s" %
1252                          (sys.exc_info()[:2] + (traceback.format_exc(),)))
1253            else:
1254                self.fail("nothing caught")
1255            finally:
1256                signal.alarm(0)         # shut off alarm
1257        except Alarm:
1258            self.fail("got Alarm in wrong place")
1259        finally:
1260            # no alarm can be pending.  Safe to restore old handler.
1261            signal.signal(signal.SIGALRM, old_alarm)
1262
1263class UDPTimeoutTest(SocketTCPTest):
1264
1265    def testUDPTimeout(self):
1266        def raise_timeout(*args, **kwargs):
1267            self.serv.settimeout(1.0)
1268            self.serv.recv(1024)
1269        self.assertRaises(socket.timeout, raise_timeout,
1270                              "Error generating a timeout exception (UDP)")
1271
1272    def testTimeoutZero(self):
1273        ok = False
1274        try:
1275            self.serv.settimeout(0.0)
1276            foo = self.serv.recv(1024)
1277        except socket.timeout:
1278            self.fail("caught timeout instead of error (UDP)")
1279        except socket.error:
1280            ok = True
1281        except:
1282            self.fail("caught unexpected exception (UDP)")
1283        if not ok:
1284            self.fail("recv() returned success when we did not expect it")
1285
1286class TestExceptions(unittest.TestCase):
1287
1288    def testExceptionTree(self):
1289        self.assertTrue(issubclass(socket.error, Exception))
1290        self.assertTrue(issubclass(socket.herror, socket.error))
1291        self.assertTrue(issubclass(socket.gaierror, socket.error))
1292        self.assertTrue(issubclass(socket.timeout, socket.error))
1293
1294class TestLinuxAbstractNamespace(unittest.TestCase):
1295
1296    UNIX_PATH_MAX = 108
1297
1298    def testLinuxAbstractNamespace(self):
1299        address = b"\x00python-test-hello\x00\xff"
1300        s1 = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
1301        s1.bind(address)
1302        s1.listen(1)
1303        s2 = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
1304        s2.connect(s1.getsockname())
1305        s1.accept()
1306        self.assertEqual(s1.getsockname(), address)
1307        self.assertEqual(s2.getpeername(), address)
1308
1309    def testMaxName(self):
1310        address = b"\x00" + b"h" * (self.UNIX_PATH_MAX - 1)
1311        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
1312        s.bind(address)
1313        self.assertEqual(s.getsockname(), address)
1314
1315    def testNameOverflow(self):
1316        address = "\x00" + "h" * self.UNIX_PATH_MAX
1317        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
1318        self.assertRaises(socket.error, s.bind, address)
1319
1320
1321@unittest.skipUnless(thread, 'Threading required for this test.')
1322class BufferIOTest(SocketConnectedTest):
1323    """
1324    Test the buffer versions of socket.recv() and socket.send().
1325    """
1326    def __init__(self, methodName='runTest'):
1327        SocketConnectedTest.__init__(self, methodName=methodName)
1328
1329    def testRecvIntoArray(self):
1330        buf = bytearray(1024)
1331        nbytes = self.cli_conn.recv_into(buf)
1332        self.assertEqual(nbytes, len(MSG))
1333        msg = buf[:len(MSG)]
1334        self.assertEqual(msg, MSG)
1335
1336    def _testRecvIntoArray(self):
1337        buf = bytes(MSG)
1338        self.serv_conn.send(buf)
1339
1340    def testRecvIntoBytearray(self):
1341        buf = bytearray(1024)
1342        nbytes = self.cli_conn.recv_into(buf)
1343        self.assertEqual(nbytes, len(MSG))
1344        msg = buf[:len(MSG)]
1345        self.assertEqual(msg, MSG)
1346
1347    _testRecvIntoBytearray = _testRecvIntoArray
1348
1349    def testRecvIntoMemoryview(self):
1350        buf = bytearray(1024)
1351        nbytes = self.cli_conn.recv_into(memoryview(buf))
1352        self.assertEqual(nbytes, len(MSG))
1353        msg = buf[:len(MSG)]
1354        self.assertEqual(msg, MSG)
1355
1356    _testRecvIntoMemoryview = _testRecvIntoArray
1357
1358    def testRecvFromIntoArray(self):
1359        buf = bytearray(1024)
1360        nbytes, addr = self.cli_conn.recvfrom_into(buf)
1361        self.assertEqual(nbytes, len(MSG))
1362        msg = buf[:len(MSG)]
1363        self.assertEqual(msg, MSG)
1364
1365    def _testRecvFromIntoArray(self):
1366        buf = bytes(MSG)
1367        self.serv_conn.send(buf)
1368
1369    def testRecvFromIntoBytearray(self):
1370        buf = bytearray(1024)
1371        nbytes, addr = self.cli_conn.recvfrom_into(buf)
1372        self.assertEqual(nbytes, len(MSG))
1373        msg = buf[:len(MSG)]
1374        self.assertEqual(msg, MSG)
1375
1376    _testRecvFromIntoBytearray = _testRecvFromIntoArray
1377
1378    def testRecvFromIntoMemoryview(self):
1379        buf = bytearray(1024)
1380        nbytes, addr = self.cli_conn.recvfrom_into(memoryview(buf))
1381        self.assertEqual(nbytes, len(MSG))
1382        msg = buf[:len(MSG)]
1383        self.assertEqual(msg, MSG)
1384
1385    _testRecvFromIntoMemoryview = _testRecvFromIntoArray
1386
1387
1388TIPC_STYPE = 2000
1389TIPC_LOWER = 200
1390TIPC_UPPER = 210
1391
1392def isTipcAvailable():
1393    """Check if the TIPC module is loaded
1394
1395    The TIPC module is not loaded automatically on Ubuntu and probably
1396    other Linux distros.
1397    """
1398    if not hasattr(socket, "AF_TIPC"):
1399        return False
1400    if not os.path.isfile("/proc/modules"):
1401        return False
1402    with open("/proc/modules") as f:
1403        for line in f:
1404            if line.startswith("tipc "):
1405                return True
1406    if support.verbose:
1407        print("TIPC module is not loaded, please 'sudo modprobe tipc'")
1408    return False
1409
1410class TIPCTest (unittest.TestCase):
1411    def testRDM(self):
1412        srv = socket.socket(socket.AF_TIPC, socket.SOCK_RDM)
1413        cli = socket.socket(socket.AF_TIPC, socket.SOCK_RDM)
1414
1415        srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
1416        srvaddr = (socket.TIPC_ADDR_NAMESEQ, TIPC_STYPE,
1417                TIPC_LOWER, TIPC_UPPER)
1418        srv.bind(srvaddr)
1419
1420        sendaddr = (socket.TIPC_ADDR_NAME, TIPC_STYPE,
1421                TIPC_LOWER + int((TIPC_UPPER - TIPC_LOWER) / 2), 0)
1422        cli.sendto(MSG, sendaddr)
1423
1424        msg, recvaddr = srv.recvfrom(1024)
1425
1426        self.assertEqual(cli.getsockname(), recvaddr)
1427        self.assertEqual(msg, MSG)
1428
1429
1430class TIPCThreadableTest (unittest.TestCase, ThreadableTest):
1431    def __init__(self, methodName = 'runTest'):
1432        unittest.TestCase.__init__(self, methodName = methodName)
1433        ThreadableTest.__init__(self)
1434
1435    def setUp(self):
1436        self.srv = socket.socket(socket.AF_TIPC, socket.SOCK_STREAM)
1437        self.srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
1438        srvaddr = (socket.TIPC_ADDR_NAMESEQ, TIPC_STYPE,
1439                TIPC_LOWER, TIPC_UPPER)
1440        self.srv.bind(srvaddr)
1441        self.srv.listen(5)
1442        self.serverExplicitReady()
1443        self.conn, self.connaddr = self.srv.accept()
1444
1445    def clientSetUp(self):
1446        # The is a hittable race between serverExplicitReady() and the
1447        # accept() call; sleep a little while to avoid it, otherwise
1448        # we could get an exception
1449        time.sleep(0.1)
1450        self.cli = socket.socket(socket.AF_TIPC, socket.SOCK_STREAM)
1451        addr = (socket.TIPC_ADDR_NAME, TIPC_STYPE,
1452                TIPC_LOWER + int((TIPC_UPPER - TIPC_LOWER) / 2), 0)
1453        self.cli.connect(addr)
1454        self.cliaddr = self.cli.getsockname()
1455
1456    def testStream(self):
1457        msg = self.conn.recv(1024)
1458        self.assertEqual(msg, MSG)
1459        self.assertEqual(self.cliaddr, self.connaddr)
1460
1461    def _testStream(self):
1462        self.cli.send(MSG)
1463        self.cli.close()
1464
1465
1466def test_main():
1467    tests = [GeneralModuleTests, BasicTCPTest, TCPCloserTest, TCPTimeoutTest,
1468             TestExceptions, BufferIOTest, BasicTCPTest2, BasicUDPTest, UDPTimeoutTest ]
1469
1470    tests.extend([
1471        NonBlockingTCPTests,
1472        FileObjectClassTestCase,
1473        FileObjectInterruptedTestCase,
1474        UnbufferedFileObjectClassTestCase,
1475        LineBufferedFileObjectClassTestCase,
1476        SmallBufferedFileObjectClassTestCase,
1477        NetworkConnectionNoServer,
1478        NetworkConnectionAttributesTest,
1479        NetworkConnectionBehaviourTest,
1480    ])
1481    if hasattr(socket, "socketpair"):
1482        tests.append(BasicSocketPairTest)
1483    if sys.platform == 'linux2':
1484        tests.append(TestLinuxAbstractNamespace)
1485    if isTipcAvailable():
1486        tests.append(TIPCTest)
1487        tests.append(TIPCThreadableTest)
1488
1489    thread_info = support.threading_setup()
1490    support.run_unittest(*tests)
1491    support.threading_cleanup(*thread_info)
1492
1493if __name__ == "__main__":
1494    test_main()