Using appropriate checks in tests

Lib/test/test_socket.py

-#!/usr/bin/env python3
-
 import unittest
 from test import support
-from unittest.case import _ExpectedFailure
 
 import errno
 import io
 import socket
 import select
 import tempfile
-import _testcapi
 import time
 import traceback
 import queue
 import sys
 import os
 import array
 import platform
 import contextlib
 from weakref import proxy
 import signal
 import math
 import pickle
 import struct
 try:
-    import fcntl
-except ImportError:
-    fcntl = False
-try:
     import multiprocessing
 except ImportError:
     multiprocessing = False
+try:
+    import fcntl
+except ImportError:
+    fcntl = None
 
 HOST = support.HOST
 MSG = 'Michael Gilfix was here\u1234\r\n'.encode('utf-8') ## test unicode string and carriage return
 
 try:
     import _thread as thread
     import threading
 except ImportError:
     thread = None
     threading = None
 
 def _have_socket_can():
     """Check whether CAN sockets are supported on this host."""
     try:
         s = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
-    except (AttributeError, socket.error, OSError):
+    except (AttributeError, OSError):
         return False
     else:
         s.close()
     return True
 
 def _have_socket_rds():
     """Check whether RDS sockets are supported on this host."""
     try:
         s = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
     except (AttributeError, OSError):
@@ skipping 54 matching lines @@
 
     """To be able to run this test, a `vcan0` CAN interface can be created with
     the following commands:
     # modprobe vcan
     # ip link add dev vcan0 type vcan
     # ifconfig vcan0 up
     """
     interface = 'vcan0'
     bufsize = 128
 
+    """The CAN frame structure is defined in <linux/can.h>:
+
+    struct can_frame {
+        canid_t can_id;  /* 32 bit CAN_ID + EFF/RTR/ERR flags */
+        __u8    can_dlc; /* data length code: 0 .. 8 */
+        __u8    data[8] __attribute__((aligned(8)));
+    };
+    """
+    can_frame_fmt = "=IB3x8s"
+    can_frame_size = struct.calcsize(can_frame_fmt)
+
+    """The Broadcast Management Command frame structure is defined
+    in <linux/can/bcm.h>:
+
+    struct bcm_msg_head {
+        __u32 opcode;
+        __u32 flags;
+        __u32 count;
+        struct timeval ival1, ival2;
+        canid_t can_id;
+        __u32 nframes;
+        struct can_frame frames[0];
+    }
+
+    `bcm_msg_head` must be 8 bytes aligned because of the `frames` member (see
+    `struct can_frame` definition). Must use native not standard types for packing.
+    """
+    bcm_cmd_msg_fmt = "@3I4l2I"
+    bcm_cmd_msg_fmt += "x" * (struct.calcsize(bcm_cmd_msg_fmt) % 8)
+
     def setUp(self):
         self.s = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
         self.addCleanup(self.s.close)
         try:
             self.s.bind((self.interface,))
-        except socket.error:
+        except OSError:
             self.skipTest('network interface `%s` does not exist' %
                            self.interface)
 
 
 class SocketRDSTest(unittest.TestCase):
 
     """To be able to run this test, the `rds` kernel module must be loaded:
     # modprobe rds
     """
     bufsize = 8192
@@ skipping 95 matching lines @@
         self.server_ready.wait()
         self.clientSetUp()
         self.client_ready.set()
         if self.server_crashed:
             self.clientTearDown()
             return
         if not hasattr(test_func, '__call__'):
             raise TypeError("test_func must be a callable function")
         try:
             test_func()
-        except _ExpectedFailure:
-            # We deliberately ignore expected failures
-            pass
         except BaseException as e:
             self.queue.put(e)
         finally:
             self.clientTearDown()
 
     def clientSetUp(self):
         raise NotImplementedError("clientSetUp must be implemented.")
 
     def clientTearDown(self):
         self.done.set()
@@ skipping 30 matching lines @@
 class ThreadedCANSocketTest(SocketCANTest, ThreadableTest):
 
     def __init__(self, methodName='runTest'):
         SocketCANTest.__init__(self, methodName=methodName)
         ThreadableTest.__init__(self)
 
     def clientSetUp(self):
         self.cli = socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW)
         try:
             self.cli.bind((self.interface,))
-        except socket.error:
+        except OSError:
             # skipTest should not be called here, and will be called in the
             # server instead
             pass
 
     def clientTearDown(self):
         self.cli.close()
         self.cli = None
         ThreadableTest.clientTearDown(self)
 
 class ThreadedRDSSocketTest(SocketRDSTest, ThreadableTest):
@@ skipping 227 matching lines @@
     """Base class for SCTP tests in one-to-one (SOCK_STREAM) mode."""
 
     def newSocket(self):
         return socket.socket(socket.AF_INET, socket.SOCK_STREAM,
                              socket.IPPROTO_SCTP)
 
 
 class Inet6TestBase(InetTestBase):
     """Base class for IPv6 socket tests."""
 
-    # Don't use "localhost" here - it may not have an IPv6 address
-    # assigned to it by default (e.g. in /etc/hosts), and if someone
-    # has assigned it an IPv4-mapped address, then it's unlikely to
-    # work with the full IPv6 API.
-    host = "::1"
+    host = support.HOSTv6
 
 class UDP6TestBase(Inet6TestBase):
     """Base class for UDP-over-IPv6 tests."""
 
     def newSocket(self):
         return socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
 
 
 # Test-skipping decorators for use with ThreadableTest.
 
@@ skipping 40 matching lines @@
     err = None
     missing = [obj for obj in args if
                isinstance(obj, str) and not hasattr(socket, obj)]
     if missing:
         err = "don't have " + ", ".join(name for name in missing)
     else:
         callargs = [getattr(socket, obj) if isinstance(obj, str) else obj
                     for obj in args]
         try:
             s = socket.socket(*callargs)
-        except socket.error as e:
+        except OSError as e:
             # XXX: check errno?
             err = str(e)
         else:
             s.close()
     return skipWithClientIf(
         err is not None,
         "can't create socket({0}): {1}".format(
             ", ".join(str(o) for o in args), err))
 
 
 #######################################################################
 ## Begin Tests
 
 class GeneralModuleTests(unittest.TestCase):
 
     def test_repr(self):
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.addCleanup(s.close)
-        self.assertTrue(repr(s).startswith("<socket.socket object"))
+        with s:
+            self.assertIn('fd=%i' % s.fileno(), repr(s))
+            self.assertIn('family=%s' % socket.AF_INET, repr(s))
+            self.assertIn('type=%s' % socket.SOCK_STREAM, repr(s))
+            self.assertIn('proto=0', repr(s))
+            self.assertNotIn('raddr', repr(s))
+            s.bind(('127.0.0.1', 0))
+            self.assertIn('laddr', repr(s))
+            self.assertIn(str(s.getsockname()), repr(s))
+        self.assertIn('[closed]', repr(s))
+        self.assertNotIn('laddr', repr(s))
 
     def test_weakref(self):
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         p = proxy(s)
         self.assertEqual(p.fileno(), s.fileno())
         s.close()
         s = None
         try:
             p.fileno()
         except ReferenceError:
             pass
         else:
             self.fail('Socket proxy still exists')
 
     def testSocketError(self):
         # Testing socket module exceptions
         msg = "Error raising socket exception (%s)."
-        with self.assertRaises(socket.error, msg=msg % 'socket.error'):
-            raise socket.error
-        with self.assertRaises(socket.error, msg=msg % 'socket.herror'):
+        with self.assertRaises(OSError, msg=msg % 'OSError'):
+            raise OSError
+        with self.assertRaises(OSError, msg=msg % 'socket.herror'):
             raise socket.herror
-        with self.assertRaises(socket.error, msg=msg % 'socket.gaierror'):
+        with self.assertRaises(OSError, msg=msg % 'socket.gaierror'):
             raise socket.gaierror
 
     def testSendtoErrors(self):
         # Testing that sendto doens't masks failures. See #10169.
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self.addCleanup(s.close)
         s.bind(('', 0))
         sockname = s.getsockname()
         # 2 args
         with self.assertRaises(TypeError) as cm:
@@ skipping 42 matching lines @@
         socket.SOCK_RDM
         socket.SOCK_SEQPACKET
         socket.SOL_SOCKET
         socket.SO_REUSEADDR
 
     def testHostnameRes(self):
         # Testing hostname resolution mechanisms
         hostname = socket.gethostname()
         try:
             ip = socket.gethostbyname(hostname)
-        except socket.error:
+        except OSError:
             # Probably name lookup wasn't set up right; skip this test
-            return
-        self.assertGreaterEqual(ip.find('.'), 0, "Error resolving host to ip.")
+            self.skipTest('name lookup failure')
+        self.assertIn('.', ip, "Error resolving host to ip.")
         try:
             hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
-        except socket.error:
+        except OSError:
             # Probably a similar problem as above; skip this test
-            return
+            self.skipTest('name lookup failure')
         all_host_names = [hostname, hname] + aliases
         fqhn = socket.getfqdn(ip)
         if not fqhn in all_host_names:
             self.fail("Error testing host resolution mechanisms. (fqdn: %s, all: %s)" % (fqhn, repr(all_host_names)))
+
+    def test_host_resolution(self):
+        for addr in ['0.1.1.~1', '1+.1.1.1', '::1q', '::1::2',
+                     '1:1:1:1:1:1:1:1:1']:
+            self.assertRaises(OSError, socket.gethostbyname, addr)
+            self.assertRaises(OSError, socket.gethostbyaddr, addr)
+
+        for addr in [support.HOST, '10.0.0.1', '255.255.255.255']:
+            self.assertEqual(socket.gethostbyname(addr), addr)
+
+        # we don't test support.HOSTv6 because there's a chance it doesn't have
+        # a matching name entry (e.g. 'ip6-localhost')
+        for host in [support.HOST]:
+            self.assertIn(host, socket.gethostbyaddr(host)[2])
 
     @unittest.skipUnless(hasattr(socket, 'sethostname'), "test needs socket.sethostname()")
     @unittest.skipUnless(hasattr(socket, 'gethostname'), "test needs socket.gethostname()")
     def test_sethostname(self):
         oldhn = socket.gethostname()
         try:
             socket.sethostname('new')
-        except socket.error as e:
+        except OSError as e:
             if e.errno == errno.EPERM:
                 self.skipTest("test should be run as root")
             else:
                 raise
         try:
             # running test as root!
             self.assertEqual(socket.gethostname(), 'new')
             # Should work with bytes objects too
             socket.sethostname(b'bar')
             self.assertEqual(socket.gethostname(), 'bar')
@@ skipping 13 matching lines @@
             self.assertIsInstance(_index, int)
             self.assertEqual(index, _index)
             _name = socket.if_indextoname(index)
             self.assertIsInstance(_name, str)
             self.assertEqual(name, _name)
 
     @unittest.skipUnless(hasattr(socket, 'if_nameindex'),
                          'socket.if_nameindex() not available.')
     def testInvalidInterfaceNameIndex(self):
         # test nonexistent interface index/name
-        self.assertRaises(socket.error, socket.if_indextoname, 0)
-        self.assertRaises(socket.error, socket.if_nametoindex, '_DEADBEEF')
+        self.assertRaises(OSError, socket.if_indextoname, 0)
+        self.assertRaises(OSError, socket.if_nametoindex, '_DEADBEEF')
         # test with invalid values
         self.assertRaises(TypeError, socket.if_nametoindex, 0)
         self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
 
+    @unittest.skipUnless(hasattr(sys, 'getrefcount'),
+                         'test needs sys.getrefcount()')
     def testRefCountGetNameInfo(self):
         # Testing reference count for getnameinfo
-        if hasattr(sys, "getrefcount"):
-            try:
-                # On some versions, this loses a reference
-                orig = sys.getrefcount(__name__)
-                socket.getnameinfo(__name__,0)
-            except TypeError:
-                if sys.getrefcount(__name__) != orig:
-                    self.fail("socket.getnameinfo loses a reference")
+        try:
+            # On some versions, this loses a reference
+            orig = sys.getrefcount(__name__)
+            socket.getnameinfo(__name__,0)
+        except TypeError:
+            if sys.getrefcount(__name__) != orig:
+                self.fail("socket.getnameinfo loses a reference")
 
     def testInterpreterCrash(self):
         # Making sure getnameinfo doesn't crash the interpreter
         try:
             # On some versions, this crashes the interpreter.
             socket.getnameinfo(('x', 0, 0, 0), 0)
-        except socket.error:
+        except OSError:
             pass
 
     def testNtoH(self):
         # This just checks that htons etc. are their own inverse,
         # when looking at the lower 16 or 32 bits.
         sizes = {socket.htonl: 32, socket.ntohl: 32,
                  socket.htons: 16, socket.ntohs: 16}
         for func, size in sizes.items():
             mask = (1<<size) - 1
             for i in (0, 1, 0xffff, ~0xffff, 2, 0x01234567, 0x76543210):
@@ skipping 26 matching lines @@
             or sys.platform in ('linux', 'darwin')):
             # avoid the 'echo' service on this platform, as there is an
             # assumption breaking non-standard port/protocol entry
             services = ('daytime', 'qotd', 'domain')
         else:
             services = ('echo', 'daytime', 'domain')
         for service in services:
             try:
                 port = socket.getservbyname(service, 'tcp')
                 break
-            except socket.error:
+            except OSError:
                 pass
         else:
-            raise socket.error
+            raise OSError
         # Try same call with optional protocol omitted
         port2 = socket.getservbyname(service)
         eq(port, port2)
-        # Try udp, but don't barf it it doesn't exist
+        # Try udp, but don't barf if it doesn't exist
         try:
             udpport = socket.getservbyname(service, 'udp')
-        except socket.error:
+        except OSError:
             udpport = None
         else:
             eq(udpport, port)
         # Now make sure the lookup by port returns the same service name
         eq(socket.getservbyport(port2), service)
         eq(socket.getservbyport(port, 'tcp'), service)
         if udpport is not None:
             eq(socket.getservbyport(udpport, 'udp'), service)
         # Make sure getservbyport does not accept out of range ports.
         self.assertRaises(OverflowError, socket.getservbyport, -1)
@@ skipping 20 matching lines @@
         s = socket.socket()
         self.assertEqual(s.gettimeout(), None)
         s.close()
 
         # Check that setting it to an invalid value raises ValueError
         self.assertRaises(ValueError, socket.setdefaulttimeout, -1)
 
         # Check that setting it to an invalid type raises TypeError
         self.assertRaises(TypeError, socket.setdefaulttimeout, "spam")
 
+    @unittest.skipUnless(hasattr(socket, 'inet_aton'),
+                         'test needs socket.inet_aton()')
     def testIPv4_inet_aton_fourbytes(self):
-        if not hasattr(socket, 'inet_aton'):
-            return  # No inet_aton, nothing to check
         # Test that issue1008086 and issue767150 are fixed.
         # It must return 4 bytes.
         self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0'))
         self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255'))
 
+    @unittest.skipUnless(hasattr(socket, 'inet_pton'),
+                         'test needs socket.inet_pton()')
     def testIPv4toString(self):
-        if not hasattr(socket, 'inet_pton'):
-            return # No inet_pton() on this platform
         from socket import inet_aton as f, inet_pton, AF_INET
         g = lambda a: inet_pton(AF_INET, a)
 
         assertInvalid = lambda func,a: self.assertRaises(
-            (socket.error, ValueError), func, a
+            (OSError, ValueError), func, a
         )
 
         self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0'))
         self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0'))
         self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170'))
         self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4'))
         self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255'))
         assertInvalid(f, '0.0.0.')
         assertInvalid(f, '300.0.0.0')
         assertInvalid(f, 'a.0.0.0')
         assertInvalid(f, '1.2.3.4.5')
         assertInvalid(f, '::1')
 
         self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0'))
         self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0'))
         self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170'))
         self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255'))
         assertInvalid(g, '0.0.0.')
         assertInvalid(g, '300.0.0.0')
         assertInvalid(g, 'a.0.0.0')
         assertInvalid(g, '1.2.3.4.5')
         assertInvalid(g, '::1')
 
+    @unittest.skipUnless(hasattr(socket, 'inet_pton'),
+                         'test needs socket.inet_pton()')
     def testIPv6toString(self):
-        if not hasattr(socket, 'inet_pton'):
-            return # No inet_pton() on this platform
         try:
             from socket import inet_pton, AF_INET6, has_ipv6
             if not has_ipv6:
-                return
+                self.skipTest('IPv6 not available')
         except ImportError:
-            return
+            self.skipTest('could not import needed symbols from socket')
+
+        if sys.platform == "win32":
+            try:
+                inet_pton(AF_INET6, '::')
+            except OSError as e:
+                if e.winerror == 10022:
+                    self.skipTest('IPv6 might not be supported')
+
         f = lambda a: inet_pton(AF_INET6, a)
         assertInvalid = lambda a: self.assertRaises(
-            (socket.error, ValueError), f, a
+            (OSError, ValueError), f, a
         )
 
         self.assertEqual(b'\x00' * 16, f('::'))
         self.assertEqual(b'\x00' * 16, f('0::0'))
         self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::'))
         self.assertEqual(
             b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae',
             f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae')
         )
         self.assertEqual(
@@ skipping 22 matching lines @@
             b'\x00\x42\xa8\xb9\x00\x00\x00\x02\xff\xff\xa2\x9b\xfe\x2a\x17\x40',
             f('42:a8b9:0:2:ffff:a29b:254.42.23.64')
         )
         assertInvalid('255.254.253.252')
         assertInvalid('1::260.2.3.0')
         assertInvalid('1::0.be.e.0')
         assertInvalid('1:2:3:4:5:6:7:1.2.3.4')
         assertInvalid('::1.2.3.4:0')
         assertInvalid('0.100.200.0:3:4:5:6:7:8')
 
+    @unittest.skipUnless(hasattr(socket, 'inet_ntop'),
+                         'test needs socket.inet_ntop()')
     def testStringToIPv4(self):
-        if not hasattr(socket, 'inet_ntop'):
-            return # No inet_ntop() on this platform
         from socket import inet_ntoa as f, inet_ntop, AF_INET
         g = lambda a: inet_ntop(AF_INET, a)
         assertInvalid = lambda func,a: self.assertRaises(
-            (socket.error, ValueError), func, a
+            (OSError, ValueError), func, a
         )
 
         self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00'))
         self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55'))
         self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff'))
         self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04'))
         assertInvalid(f, b'\x00' * 3)
         assertInvalid(f, b'\x00' * 5)
         assertInvalid(f, b'\x00' * 16)
 
         self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00'))
         self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55'))
         self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff'))
         assertInvalid(g, b'\x00' * 3)
         assertInvalid(g, b'\x00' * 5)
         assertInvalid(g, b'\x00' * 16)
 
+    @unittest.skipUnless(hasattr(socket, 'inet_ntop'),
+                         'test needs socket.inet_ntop()')
     def testStringToIPv6(self):
-        if not hasattr(socket, 'inet_ntop'):
-            return # No inet_ntop() on this platform
         try:
             from socket import inet_ntop, AF_INET6, has_ipv6
             if not has_ipv6:
-                return
+                self.skipTest('IPv6 not available')
         except ImportError:
-            return
+            self.skipTest('could not import needed symbols from socket')
+
+        if sys.platform == "win32":
+            try:
+                inet_ntop(AF_INET6, b'\x00' * 16)
+            except OSError as e:
+                if e.winerror == 10022:
+                    self.skipTest('IPv6 might not be supported')
+
         f = lambda a: inet_ntop(AF_INET6, a)
         assertInvalid = lambda a: self.assertRaises(
-            (socket.error, ValueError), f, a
+            (OSError, ValueError), f, a
         )
 
         self.assertEqual('::', f(b'\x00' * 16))
         self.assertEqual('::1', f(b'\x00' * 15 + b'\x01'))
         self.assertEqual(
             'aef:b01:506:1001:ffff:9997:55:170',
             f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70')
         )
 
         assertInvalid(b'\x12' * 15)
         assertInvalid(b'\x12' * 17)
         assertInvalid(b'\x12' * 4)
 
     # XXX The following don't test module-level functionality...
 
     def testSockName(self):
         # Testing getsockname()
         port = support.find_unused_port()
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.addCleanup(sock.close)
         sock.bind(("0.0.0.0", port))
         name = sock.getsockname()
         # XXX(nnorwitz): http://tinyurl.com/os5jz seems to indicate
         # it reasonable to get the host's addr in addition to 0.0.0.0.
         # At least for eCos.  This is required for the S/390 to pass.
         try:
             my_ip_addr = socket.gethostbyname(socket.gethostname())
-        except socket.error:
+        except OSError:
             # Probably name lookup wasn't set up right; skip this test
-            return
+            self.skipTest('name lookup failure')
         self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
         self.assertEqual(name[1], port)
 
     def testGetSockOpt(self):
         # Testing getsockopt()
         # We know a socket should start without reuse==0
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.addCleanup(sock.close)
         reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
         self.assertEqual(reuse, 0, "initial mode is reuse")
 
     def testSetSockOpt(self):
         # Testing setsockopt()
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.addCleanup(sock.close)
         sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
         self.assertNotEqual(reuse, 0, "failed to set reuse mode")
 
     def testSendAfterClose(self):
         # testing send() after close() with timeout
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.settimeout(1)
         sock.close()
-        self.assertRaises(socket.error, sock.send, b"spam")
+        self.assertRaises(OSError, sock.send, b"spam")
 
     def testNewAttributes(self):
         # testing .family, .type and .protocol
+
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.assertEqual(sock.family, socket.AF_INET)
-        self.assertEqual(sock.type, socket.SOCK_STREAM)
+        if hasattr(socket, 'SOCK_CLOEXEC'):
+            self.assertIn(sock.type,
+                          (socket.SOCK_STREAM | socket.SOCK_CLOEXEC,
+                           socket.SOCK_STREAM))
+        else:
+            self.assertEqual(sock.type, socket.SOCK_STREAM)
         self.assertEqual(sock.proto, 0)
         sock.close()
 
     def test_getsockaddrarg(self):
         host = '0.0.0.0'
         port = support.find_unused_port()
         big_port = port + 65536
         neg_port = port - 65536
         sock = socket.socket()
         try:
@@ skipping 32 matching lines @@
         socket.getaddrinfo('127.0.0.1', 80)
         socket.getaddrinfo(None, 80)
         if support.IPV6_ENABLED:
             socket.getaddrinfo('::1', 80)
         # port can be a string service name such as "http", a numeric
         # port number or None
         socket.getaddrinfo(HOST, "http")
         socket.getaddrinfo(HOST, 80)
         socket.getaddrinfo(HOST, None)
         # test family and socktype filters
-        infos = socket.getaddrinfo(HOST, None, socket.AF_INET)
-        for family, _, _, _, _ in infos:
+        infos = socket.getaddrinfo(HOST, 80, socket.AF_INET, socket.SOCK_STREAM)
+        for family, type, _, _, _ in infos:
             self.assertEqual(family, socket.AF_INET)
+            self.assertEqual(str(family), 'AddressFamily.AF_INET')
+            self.assertEqual(type, socket.SOCK_STREAM)
+            self.assertEqual(str(type), 'SocketType.SOCK_STREAM')
         infos = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
         for _, socktype, _, _, _ in infos:
             self.assertEqual(socktype, socket.SOCK_STREAM)
         # test proto and flags arguments
         socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
         socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
         # a server willing to support both IPv4 and IPv6 will
         # usually do this
         socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
                            socket.AI_PASSIVE)
@@ skipping 15 matching lines @@
         self.assertEqual(a, b)
         a = socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
                                socket.AI_PASSIVE)
         b = socket.getaddrinfo(host=None, port=0, family=socket.AF_UNSPEC,
                                type=socket.SOCK_STREAM, proto=0,
                                flags=socket.AI_PASSIVE)
         self.assertEqual(a, b)
         # Issue #6697.
         self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
 
+        # Issue 17269
+        if hasattr(socket, 'AI_NUMERICSERV'):
+            socket.getaddrinfo("localhost", None, 0, 0, 0, socket.AI_NUMERICSERV)
+
     def test_getnameinfo(self):
         # only IP addresses are allowed
-        self.assertRaises(socket.error, socket.getnameinfo, ('mail.python.org',0), 0)
+        self.assertRaises(OSError, socket.getnameinfo, ('mail.python.org',0), 0)
 
     @unittest.skipUnless(support.is_resource_enabled('network'),
                          'network is not enabled')
     def test_idna(self):
         # Check for internet access before running test (issue #12804).
         try:
             socket.gethostbyname('python.org')
         except socket.gaierror as e:
             if e.errno == socket.EAI_NODATA:
                 self.skipTest('internet access required for this test')
@@ skipping 17 matching lines @@
             self.assertRaises(ValueError, math.acosh, 0)
             1 // 0
         c, s = socket.socketpair()
         old_alarm = signal.signal(signal.SIGALRM, raising_handler)
         try:
             if with_timeout:
                 # Just above the one second minimum for signal.alarm
                 c.settimeout(1.5)
             with self.assertRaises(ZeroDivisionError):
                 signal.alarm(1)
-                c.sendall(b"x" * (1024**2))
+                c.sendall(b"x" * support.SOCK_MAX_SIZE)
             if with_timeout:
                 signal.signal(signal.SIGALRM, ok_handler)
                 signal.alarm(1)
-                self.assertRaises(socket.timeout, c.sendall, b"x" * (1024**2))
+                self.assertRaises(socket.timeout, c.sendall,
+                                  b"x" * support.SOCK_MAX_SIZE)
         finally:
+            signal.alarm(0)
             signal.signal(signal.SIGALRM, old_alarm)
             c.close()
             s.close()
 
     def test_sendall_interrupted(self):
         self.check_sendall_interrupted(False)
 
     def test_sendall_interrupted_with_timeout(self):
         self.check_sendall_interrupted(True)
 
@@ skipping 30 matching lines @@
             self.assertRaises(ValueError, fp.readable)
             self.assertRaises(ValueError, fp.writable)
             self.assertRaises(ValueError, fp.seekable)
 
     def test_pickle(self):
         sock = socket.socket()
         with sock:
             for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
                 self.assertRaises(TypeError, pickle.dumps, sock, protocol)
 
-    def test_listen_backlog0(self):
+    def test_listen_backlog(self):
+        for backlog in 0, -1:
+            srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            srv.bind((HOST, 0))
+            srv.listen(backlog)
+            srv.close()
+
+    @support.cpython_only
+    def test_listen_backlog_overflow(self):
+        # Issue 15989
+        import _testcapi
         srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         srv.bind((HOST, 0))
-        # backlog = 0
-        srv.listen(0)
+        self.assertRaises(OverflowError, srv.listen, _testcapi.INT_MAX + 1)
         srv.close()
 
     @unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
     def test_flowinfo(self):
         self.assertRaises(OverflowError, socket.getnameinfo,
-                          ('::1',0, 0xffffffff), 0)
+                          (support.HOSTv6, 0, 0xffffffff), 0)
         with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
-            self.assertRaises(OverflowError, s.bind, ('::1', 0, -10))
-
+            self.assertRaises(OverflowError, s.bind, (support.HOSTv6, 0, -10))
+
+    def test_str_for_enums(self):
+        # Make sure that the AF_* and SOCK_* constants have enum-like string
+        # reprs.
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            self.assertEqual(str(s.family), 'AddressFamily.AF_INET')
+            self.assertEqual(str(s.type), 'SocketType.SOCK_STREAM')
+
+    @unittest.skipIf(os.name == 'nt', 'Will not work on Windows')
+    def test_uknown_socket_family_repr(self):
+        # Test that when created with a family that's not one of the known
+        # AF_*/SOCK_* constants, socket.family just returns the number.
+        #
+        # To do this we fool socket.socket into believing it already has an
+        # open fd because on this path it doesn't actually verify the family and
+        # type and populates the socket object.
+        #
+        # On Windows this trick won't work, so the test is skipped.
+        fd, _ = tempfile.mkstemp()
+        with socket.socket(family=42424, type=13331, fileno=fd) as s:
+            self.assertEqual(s.family, 42424)
+            self.assertEqual(s.type, 13331)
 
 @unittest.skipUnless(HAVE_SOCKET_CAN, 'SocketCan required for this test.')
 class BasicCANTest(unittest.TestCase):
 
     def testCrucialConstants(self):
         socket.AF_CAN
         socket.PF_CAN
         socket.CAN_RAW
 
+    @unittest.skipUnless(hasattr(socket, "CAN_BCM"),
+                         'socket.CAN_BCM required for this test.')
+    def testBCMConstants(self):
+        socket.CAN_BCM
+
+        # opcodes
+        socket.CAN_BCM_TX_SETUP     # create (cyclic) transmission task
+        socket.CAN_BCM_TX_DELETE    # remove (cyclic) transmission task
+        socket.CAN_BCM_TX_READ      # read properties of (cyclic) transmission task
+        socket.CAN_BCM_TX_SEND      # send one CAN frame
+        socket.CAN_BCM_RX_SETUP     # create RX content filter subscription
+        socket.CAN_BCM_RX_DELETE    # remove RX content filter subscription
+        socket.CAN_BCM_RX_READ      # read properties of RX content filter subscription
+        socket.CAN_BCM_TX_STATUS    # reply to TX_READ request
+        socket.CAN_BCM_TX_EXPIRED   # notification on performed transmissions (count=0)
+        socket.CAN_BCM_RX_STATUS    # reply to RX_READ request
+        socket.CAN_BCM_RX_TIMEOUT   # cyclic message is absent
+        socket.CAN_BCM_RX_CHANGED   # updated CAN frame (detected content change)
+
     def testCreateSocket(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
             pass
 
+    @unittest.skipUnless(hasattr(socket, "CAN_BCM"),
+                         'socket.CAN_BCM required for this test.')
+    def testCreateBCMSocket(self):
+        with socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_BCM) as s:
+            pass
+
     def testBindAny(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
             s.bind(('', ))
 
     def testTooLongInterfaceName(self):
         # most systems limit IFNAMSIZ to 16, take 1024 to be sure
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
-            self.assertRaisesRegex(socket.error, 'interface name too long',
+            self.assertRaisesRegex(OSError, 'interface name too long',
                                    s.bind, ('x' * 1024,))
 
     @unittest.skipUnless(hasattr(socket, "CAN_RAW_LOOPBACK"),
                          'socket.CAN_RAW_LOOPBACK required for this test.')
     def testLoopback(self):
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
             for loopback in (0, 1):
                 s.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_LOOPBACK,
                              loopback)
                 self.assertEqual(loopback,
                     s.getsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_LOOPBACK))
 
     @unittest.skipUnless(hasattr(socket, "CAN_RAW_FILTER"),
                          'socket.CAN_RAW_FILTER required for this test.')
     def testFilter(self):
         can_id, can_mask = 0x200, 0x700
         can_filter = struct.pack("=II", can_id, can_mask)
         with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) as s:
             s.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_FILTER, can_filter)
             self.assertEqual(can_filter,
                     s.getsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_FILTER, 8))
 
 
 @unittest.skipUnless(HAVE_SOCKET_CAN, 'SocketCan required for this test.')
-@unittest.skipUnless(thread, 'Threading required for this test.')
 class CANTest(ThreadedCANSocketTest):
-
-    """The CAN frame structure is defined in <linux/can.h>:
-
-    struct can_frame {
-        canid_t can_id;  /* 32 bit CAN_ID + EFF/RTR/ERR flags */
-        __u8    can_dlc; /* data length code: 0 .. 8 */
-        __u8    data[8] __attribute__((aligned(8)));
-    };
-    """
-    can_frame_fmt = "=IB3x8s"
 
     def __init__(self, methodName='runTest'):
         ThreadedCANSocketTest.__init__(self, methodName=methodName)
 
     @classmethod
     def build_can_frame(cls, can_id, data):
         """Build a CAN frame."""
         can_dlc = len(data)
         data = data.ljust(8, b'\x00')
         return struct.pack(cls.can_frame_fmt, can_id, can_dlc, data)
@@ skipping 28 matching lines @@
 
         cf, addr = self.s.recvfrom(self.bufsize)
         self.assertEqual(self.cf2, cf)
 
     def _testSendMultiFrames(self):
         self.cf1 = self.build_can_frame(0x07, b'\x44\x33\x22\x11')
         self.cli.send(self.cf1)
 
         self.cf2 = self.build_can_frame(0x12, b'\x99\x22\x33')
         self.cli.send(self.cf2)
+
+    @unittest.skipUnless(hasattr(socket, "CAN_BCM"),
+                         'socket.CAN_BCM required for this test.')
+    def _testBCM(self):
+        cf, addr = self.cli.recvfrom(self.bufsize)
+        self.assertEqual(self.cf, cf)
+        can_id, can_dlc, data = self.dissect_can_frame(cf)
+        self.assertEqual(self.can_id, can_id)
+        self.assertEqual(self.data, data)
+
+    @unittest.skipUnless(hasattr(socket, "CAN_BCM"),
+                         'socket.CAN_BCM required for this test.')
+    def testBCM(self):
+        bcm = socket.socket(socket.PF_CAN, socket.SOCK_DGRAM, socket.CAN_BCM)
+        self.addCleanup(bcm.close)
+        bcm.connect((self.interface,))
+        self.can_id = 0x123
+        self.data = bytes([0xc0, 0xff, 0xee])
+        self.cf = self.build_can_frame(self.can_id, self.data)
+        opcode = socket.CAN_BCM_TX_SEND
+        flags = 0
+        count = 0
+        ival1_seconds = ival1_usec = ival2_seconds = ival2_usec = 0
+        bcm_can_id = 0x0222
+        nframes = 1
+        assert len(self.cf) == 16
+        header = struct.pack(self.bcm_cmd_msg_fmt,
+                    opcode,
+                    flags,
+                    count,
+                    ival1_seconds,
+                    ival1_usec,
+                    ival2_seconds,
+                    ival2_usec,
+                    bcm_can_id,
+                    nframes,
+                    )
+        header_plus_frame = header + self.cf
+        bytes_sent = bcm.send(header_plus_frame)
+        self.assertEqual(bytes_sent, len(header_plus_frame))
 
 
 @unittest.skipUnless(HAVE_SOCKET_RDS, 'RDS sockets required for this test.')
 class BasicRDSTest(unittest.TestCase):
 
     def testCrucialConstants(self):
         socket.AF_RDS
         socket.PF_RDS
 
     def testCreateSocket(self):
@@ skipping 183 matching lines @@
         self.assertEqual(msg, MSG)
         # wait for _testShutdown to finish: on OS X, when the server
         # closes the connection the client also becomes disconnected,
         # and the client's shutdown call will fail. (Issue #4397.)
         self.done.wait()
 
     def _testShutdown(self):
         self.serv_conn.send(MSG)
         self.serv_conn.shutdown(2)
 
+    testShutdown_overflow = support.cpython_only(testShutdown)
+
+    @support.cpython_only
+    def _testShutdown_overflow(self):
+        import _testcapi
+        self.serv_conn.send(MSG)
+        # Issue 15989
+        self.assertRaises(OverflowError, self.serv_conn.shutdown,
+                          _testcapi.INT_MAX + 1)
+        self.assertRaises(OverflowError, self.serv_conn.shutdown,
+                          2 + (_testcapi.UINT_MAX + 1))
+        self.serv_conn.shutdown(2)
+
     def testDetach(self):
         # Testing detach()
         fileno = self.cli_conn.fileno()
         f = self.cli_conn.detach()
         self.assertEqual(f, fileno)
         # cli_conn cannot be used anymore...
         self.assertTrue(self.cli_conn._closed)
-        self.assertRaises(socket.error, self.cli_conn.recv, 1024)
+        self.assertRaises(OSError, self.cli_conn.recv, 1024)
         self.cli_conn.close()
         # ...but we can create another socket using the (still open)
         # file descriptor
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, fileno=f)
         self.addCleanup(sock.close)
         msg = sock.recv(1024)
         self.assertEqual(msg, MSG)
 
     def _testDetach(self):
         self.serv_conn.send(MSG)
@@ skipping 348 matching lines @@
         self.sendToServer(b"done")
 
     def testSendmsgExcessCmsgReject(self):
         # Check that sendmsg() rejects excess ancillary data items
         # when the number that can be sent is limited.
         self.assertEqual(self.serv_sock.recv(1000), b"done")
 
     def _testSendmsgExcessCmsgReject(self):
         if not hasattr(socket, "CMSG_SPACE"):
             # Can only send one item
-            with self.assertRaises(socket.error) as cm:
+            with self.assertRaises(OSError) as cm:
                 self.sendmsgToServer([MSG], [(0, 0, b""), (0, 0, b"")])
             self.assertIsNone(cm.exception.errno)
         self.sendToServer(b"done")
 
     def testSendmsgAfterClose(self):
         # Check that sendmsg() fails on a closed socket.
         pass
 
     def _testSendmsgAfterClose(self):
         self.cli_sock.close()
-        self.assertRaises(socket.error, self.sendmsgToServer, [MSG])
+        self.assertRaises(OSError, self.sendmsgToServer, [MSG])
 
 
 class SendmsgStreamTests(SendmsgTests):
     # Tests for sendmsg() which require a stream socket and do not
     # involve recvmsg() or recvmsg_into().
 
     def testSendmsgExplicitNoneAddr(self):
         # Check that peer address can be specified as None.
         self.assertEqual(self.serv_sock.recv(len(MSG)), MSG)
 
@@ skipping 23 matching lines @@
                       "MSG_DONTWAIT not known to work on this platform when "
                       "sending")
     def testSendmsgDontWait(self):
         # Check that MSG_DONTWAIT in flags causes non-blocking behaviour.
         self.assertEqual(self.serv_sock.recv(512), b"a"*512)
         self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
 
     @testSendmsgDontWait.client_skip
     def _testSendmsgDontWait(self):
         try:
-            with self.assertRaises(socket.error) as cm:
+            with self.assertRaises(OSError) as cm:
                 while True:
                     self.sendmsgToServer([b"a"*512], [], socket.MSG_DONTWAIT)
             self.assertIn(cm.exception.errno,
                           (errno.EAGAIN, errno.EWOULDBLOCK))
         finally:
             self.misc_event.set()
 
 
 class SendmsgConnectionlessTests(SendmsgTests):
     # Tests for sendmsg() which require a connectionless-mode
     # (e.g. datagram) socket, and do not involve recvmsg() or
     # recvmsg_into().
 
     def testSendmsgNoDestAddr(self):
         # Check that sendmsg() fails when no destination address is
         # given for unconnected socket.
         pass
 
     def _testSendmsgNoDestAddr(self):
-        self.assertRaises(socket.error, self.cli_sock.sendmsg,
+        self.assertRaises(OSError, self.cli_sock.sendmsg,
                           [MSG])
-        self.assertRaises(socket.error, self.cli_sock.sendmsg,
+        self.assertRaises(OSError, self.cli_sock.sendmsg,
                           [MSG], [], 0, None)
 
 
 class RecvmsgGenericTests(SendrecvmsgBase):
     # Tests for recvmsg() which can also be emulated using
     # recvmsg_into(), and can use any socket type.
 
     def testRecvmsg(self):
         # Receive a simple message with recvmsg[_into]().
         msg, ancdata, flags, addr = self.doRecvmsg(self.serv_sock, len(MSG))
@@ skipping 65 matching lines @@
         self.checkRecvmsgAddress(addr, self.cli_addr)
         self.assertEqual(ancdata, [])
         self.checkFlags(flags, eor=True)
 
     def _testRecvmsgLongAncillaryBuf(self):
         self.sendToServer(MSG)
 
     def testRecvmsgAfterClose(self):
         # Check that recvmsg[_into]() fails on a closed socket.
         self.serv_sock.close()
-        self.assertRaises(socket.error, self.doRecvmsg, self.serv_sock, 1024)
+        self.assertRaises(OSError, self.doRecvmsg, self.serv_sock, 1024)
 
     def _testRecvmsgAfterClose(self):
         pass
 
     def testRecvmsgTimeout(self):
         # Check that timeout works.
         try:
             self.serv_sock.settimeout(0.03)
             self.assertRaises(socket.timeout,
                               self.doRecvmsg, self.serv_sock, len(MSG))
@@ skipping 201 matching lines @@
     def _testRecvmsgIntoScatter(self):
         self.sendToServer(b"Mary had a little lamb")
 
 
 class CmsgMacroTests(unittest.TestCase):
     # Test the functions CMSG_LEN() and CMSG_SPACE().  Tests
     # assumptions used by sendmsg() and recvmsg[_into](), which share
     # code with these functions.
 
     # Match the definition in socketmodule.c
-    socklen_t_limit = min(0x7fffffff, _testcapi.INT_MAX)
+    try:
+        import _testcapi
+    except ImportError:
+        socklen_t_limit = 0x7fffffff
+    else:
+        socklen_t_limit = min(0x7fffffff, _testcapi.INT_MAX)
 
     @requireAttrs(socket, "CMSG_LEN")
     def testCMSG_LEN(self):
         # Test CMSG_LEN() with various valid and invalid values,
         # checking the assumptions used by recvmsg() and sendmsg().
         toobig = self.socklen_t_limit - socket.CMSG_LEN(0) + 1
         values = list(range(257)) + list(range(toobig - 257, toobig))
 
         # struct cmsghdr has at least three members, two of which are ints
         self.assertGreater(socket.CMSG_LEN(0), array.array("i").itemsize * 2)
@@ skipping 152 matching lines @@
                              self.doRecvmsg(self.serv_sock, len(MSG),
                                             socket.CMSG_LEN(4 * SIZEOF_INT)),
                              # RFC 3542 says implementations may set
                              # MSG_CTRUNC if there isn't enough space
                              # for trailing padding.
                              ignoreflags=socket.MSG_CTRUNC)
 
     def _testFDPassCMSG_LEN(self):
         self.createAndSendFDs(1)
 
-    # Issue #12958: The following test has problems on Mac OS X
-    @support.anticipate_failure(sys.platform == "darwin")
+    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparate(self):
         # Pass two FDs in two separate arrays.  Arrays may be combined
         # into a single control message by the OS.
         self.checkRecvmsgFDs(2,
                              self.doRecvmsg(self.serv_sock, len(MSG), 10240),
                              maxcmsgs=2)
 
     @testFDPassSeparate.client_skip
-    @support.anticipate_failure(sys.platform == "darwin")
+    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
     def _testFDPassSeparate(self):
         fd0, fd1 = self.newFDs(2)
         self.assertEqual(
             self.sendmsgToServer([MSG], [(socket.SOL_SOCKET,
                                           socket.SCM_RIGHTS,
                                           array.array("i", [fd0])),
                                          (socket.SOL_SOCKET,
                                           socket.SCM_RIGHTS,
                                           array.array("i", [fd1]))]),
             len(MSG))
 
-    # Issue #12958: The following test has problems on Mac OS X
-    @support.anticipate_failure(sys.platform == "darwin")
+    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
     @requireAttrs(socket, "CMSG_SPACE")
     def testFDPassSeparateMinSpace(self):
         # Pass two FDs in two separate arrays, receiving them into the
         # minimum space for two arrays.
         self.checkRecvmsgFDs(2,
                              self.doRecvmsg(self.serv_sock, len(MSG),
                                             socket.CMSG_SPACE(SIZEOF_INT) +
                                             socket.CMSG_LEN(SIZEOF_INT)),
                              maxcmsgs=2, ignoreflags=socket.MSG_CTRUNC)
 
     @testFDPassSeparateMinSpace.client_skip
-    @support.anticipate_failure(sys.platform == "darwin")
+    @unittest.skipIf(sys.platform == "darwin", "skipping, see issue #12958")
     def _testFDPassSeparateMinSpace(self):
         fd0, fd1 = self.newFDs(2)
         self.assertEqual(
             self.sendmsgToServer([MSG], [(socket.SOL_SOCKET,
                                           socket.SCM_RIGHTS,
                                           array.array("i", [fd0])),
                                          (socket.SOL_SOCKET,
                                           socket.SCM_RIGHTS,
                                           array.array("i", [fd1]))]),
             len(MSG))
 
     def sendAncillaryIfPossible(self, msg, ancdata):
         # Try to send msg and ancdata to server, but if the system
         # call fails, just send msg with no ancillary data.
         try:
             nbytes = self.sendmsgToServer([msg], ancdata)
-        except socket.error as e:
+        except OSError as e:
             # Check that it was the system call that failed
             self.assertIsInstance(e.errno, int)
             nbytes = self.sendmsgToServer([msg])
         self.assertEqual(nbytes, len(msg))
 
     def testFDPassEmpty(self):
         # Try to pass an empty FD array.  Can receive either no array
         # or an empty array.
         self.checkRecvmsgFDs(0, self.doRecvmsg(self.serv_sock,
                                                len(MSG), 10240),
@@ skipping 357 matching lines @@
     @testOddCmsgSize.client_skip
     def _testOddCmsgSize(self):
         self.assertTrue(self.misc_event.wait(timeout=self.fail_timeout))
         try:
             nbytes = self.sendmsgToServer(
                 [MSG],
                 [(socket.IPPROTO_IPV6, socket.IPV6_TCLASS,
                   array.array("i", [self.traffic_class]).tobytes() + b"\x00"),
                  (socket.IPPROTO_IPV6, socket.IPV6_HOPLIMIT,
                   array.array("i", [self.hop_limit]))])
-        except socket.error as e:
+        except OSError as e:
             self.assertIsInstance(e.errno, int)
             nbytes = self.sendmsgToServer(
                 [MSG],
                 [(socket.IPPROTO_IPV6, socket.IPV6_TCLASS,
                   array.array("i", [self.traffic_class])),
                  (socket.IPPROTO_IPV6, socket.IPV6_HOPLIMIT,
                   array.array("i", [self.hop_limit]))])
             self.assertEqual(nbytes, len(MSG))
 
     # Tests for proper handling of truncated ancillary data
@@ skipping 240 matching lines @@
 
 @requireAttrs(socket.socket, "recvmsg_into")
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class RecvmsgIntoUDPTest(RecvmsgIntoTests, SendrecvmsgUDPTestBase):
     pass
 
 
 class SendrecvmsgUDP6TestBase(SendrecvmsgDgramFlagsBase,
                               SendrecvmsgConnectionlessBase,
                               ThreadedSocketTestMixin, UDP6TestBase):
-    pass
+
+    def checkRecvmsgAddress(self, addr1, addr2):
+        # Called to compare the received address with the address of
+        # the peer, ignoring scope ID
+        self.assertEqual(addr1[:-1], addr2[:-1])
 
 @requireAttrs(socket.socket, "sendmsg")
 @unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
 @requireSocket("AF_INET6", "SOCK_DGRAM")
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class SendmsgUDP6Test(SendmsgConnectionlessTests, SendrecvmsgUDP6TestBase):
     pass
 
 @requireAttrs(socket.socket, "recvmsg")
 @unittest.skipUnless(support.IPV6_ENABLED, 'IPv6 required for this test.')
@@ skipping 60 matching lines @@
 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP")
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class SendmsgSCTPStreamTest(SendmsgStreamTests, SendrecvmsgSCTPStreamTestBase):
     pass
 
 @requireAttrs(socket.socket, "recvmsg")
 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP")
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class RecvmsgSCTPStreamTest(RecvmsgTests, RecvmsgGenericStreamTests,
                             SendrecvmsgSCTPStreamTestBase):
-    pass
+
+    def testRecvmsgEOF(self):
+        try:
+            super(RecvmsgSCTPStreamTest, self).testRecvmsgEOF()
+        except OSError as e:
+            if e.errno != errno.ENOTCONN:
+                raise
+            self.skipTest("sporadic ENOTCONN (kernel issue?) - see issue #13876")
 
 @requireAttrs(socket.socket, "recvmsg_into")
 @requireSocket("AF_INET", "SOCK_STREAM", "IPPROTO_SCTP")
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class RecvmsgIntoSCTPStreamTest(RecvmsgIntoTests, RecvmsgGenericStreamTests,
                                 SendrecvmsgSCTPStreamTestBase):
-    pass
+
+    def testRecvmsgEOF(self):
+        try:
+            super(RecvmsgIntoSCTPStreamTest, self).testRecvmsgEOF()
+        except OSError as e:
+            if e.errno != errno.ENOTCONN:
+                raise
+            self.skipTest("sporadic ENOTCONN (kernel issue?) - see issue #13876")
 
 
 class SendrecvmsgUnixStreamTestBase(SendrecvmsgConnectedBase,
                                     ConnectedStreamTestMixin, UnixStreamBase):
     pass
 
 @requireAttrs(socket.socket, "sendmsg")
 @requireAttrs(socket, "AF_UNIX")
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class SendmsgUnixStreamTest(SendmsgStreamTests, SendrecvmsgUnixStreamTestBase):
@@ skipping 70 matching lines @@
                      "Don't have signal.alarm or signal.setitimer")
 class InterruptedRecvTimeoutTest(InterruptedTimeoutBase, UDPTestBase):
     # Test interrupting the recv*() methods with signals when a
     # timeout is set.
 
     def setUp(self):
         super().setUp()
         self.serv.settimeout(self.timeout)
 
     def checkInterruptedRecv(self, func, *args, **kwargs):
-        # Check that func(*args, **kwargs) raises socket.error with an
+        # Check that func(*args, **kwargs) raises OSError with an
         # errno of EINTR when interrupted by a signal.
         self.setAlarm(self.alarm_time)
-        with self.assertRaises(socket.error) as cm:
+        with self.assertRaises(OSError) as cm:
             func(*args, **kwargs)
         self.assertNotIsInstance(cm.exception, socket.timeout)
         self.assertEqual(cm.exception.errno, errno.EINTR)
 
     def testInterruptedRecvTimeout(self):
         self.checkInterruptedRecv(self.serv.recv, 1024)
 
     def testInterruptedRecvIntoTimeout(self):
         self.checkInterruptedRecv(self.serv.recv_into, bytearray(1024))
 
@@ skipping 36 matching lines @@
         self.cli_conn, addr = self.serv.accept()
         self.addCleanup(self.cli_conn.close)
         cli_thread.join()
         self.serv_conn.settimeout(self.timeout)
 
     def doConnect(self):
         self.serv_conn.connect(self.serv_addr)
 
     def checkInterruptedSend(self, func, *args, **kwargs):
         # Check that func(*args, **kwargs), run in a loop, raises
-        # socket.error with an errno of EINTR when interrupted by a
+        # OSError with an errno of EINTR when interrupted by a
         # signal.
-        with self.assertRaises(socket.error) as cm:
+        with self.assertRaises(OSError) as cm:
             while True:
                 self.setAlarm(self.alarm_time)
                 func(*args, **kwargs)
         self.assertNotIsInstance(cm.exception, socket.timeout)
         self.assertEqual(cm.exception.errno, errno.EINTR)
 
-    # Issue #12958: The following tests have problems on Mac OS X
-    @support.anticipate_failure(sys.platform == "darwin")
+    # Issue #12958: The following tests have problems on OS X prior to 10.7
+    @support.requires_mac_ver(10, 7)
     def testInterruptedSendTimeout(self):
         self.checkInterruptedSend(self.serv_conn.send, b"a"*512)
 
-    @support.anticipate_failure(sys.platform == "darwin")
+    @support.requires_mac_ver(10, 7)
     def testInterruptedSendtoTimeout(self):
         # Passing an actual address here as Python's wrapper for
         # sendto() doesn't allow passing a zero-length one; POSIX
         # requires that the address is ignored since the socket is
         # connection-mode, however.
         self.checkInterruptedSend(self.serv_conn.sendto, b"a"*512,
                                   self.serv_addr)
 
-    @support.anticipate_failure(sys.platform == "darwin")
+    @support.requires_mac_ver(10, 7)
     @requireAttrs(socket.socket, "sendmsg")
     def testInterruptedSendmsgTimeout(self):
         self.checkInterruptedSend(self.serv_conn.sendmsg, [b"a"*512])
 
 
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class TCPCloserTest(ThreadedTCPSocketTest):
 
     def testClose(self):
         conn, addr = self.serv.accept()
         conn.close()
 
         sd = self.cli
         read, write, err = select.select([sd], [], [], 1.0)
         self.assertEqual(read, [sd])
         self.assertEqual(sd.recv(1), b'')
 
         # Calling close() many times should be safe.
         conn.close()
         conn.close()
 
     def _testClose(self):
         self.cli.connect((HOST, self.port))
         time.sleep(1.0)
 
+@unittest.skipUnless(hasattr(socket, 'socketpair'),
+                     'test needs socket.socketpair()')
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class BasicSocketPairTest(SocketPairTest):
 
     def __init__(self, methodName='runTest'):
         SocketPairTest.__init__(self, methodName=methodName)
 
     def _check_defaults(self, sock):
         self.assertIsInstance(sock, socket.socket)
         if hasattr(socket, 'AF_UNIX'):
             self.assertEqual(sock.family, socket.AF_UNIX)
@@ skipping 23 matching lines @@
         self.assertEqual(msg, MSG)
 
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class NonBlockingTCPTests(ThreadedTCPSocketTest):
 
     def __init__(self, methodName='runTest'):
         ThreadedTCPSocketTest.__init__(self, methodName=methodName)
 
     def testSetBlocking(self):
         # Testing whether set blocking works
-        self.serv.setblocking(0)
+        self.serv.setblocking(True)
+        self.assertIsNone(self.serv.gettimeout())
+        self.serv.setblocking(False)
+        self.assertEqual(self.serv.gettimeout(), 0.0)
         start = time.time()
         try:
             self.serv.accept()
-        except socket.error:
+        except OSError:
             pass
         end = time.time()
         self.assertLess(end - start, 1.0, "Error setting non-blocking mode.")
 
     def _testSetBlocking(self):
         pass
 
-    if hasattr(socket, "SOCK_NONBLOCK"):
-        @support.requires_linux_version(2, 6, 28)
-        def testInitNonBlocking(self):
-            # reinit server socket
-            self.serv.close()
-            self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM |
-                                                      socket.SOCK_NONBLOCK)
-            self.port = support.bind_port(self.serv)
-            self.serv.listen(1)
-            # actual testing
-            start = time.time()
-            try:
-                self.serv.accept()
-            except socket.error:
-                pass
-            end = time.time()
-            self.assertLess(end - start, 1.0, "Error creating with non-blocking mode.")
-
-        def _testInitNonBlocking(self):
+    @support.cpython_only
+    def testSetBlocking_overflow(self):
+        # Issue 15989
+        import _testcapi
+        if _testcapi.UINT_MAX >= _testcapi.ULONG_MAX:
+            self.skipTest('needs UINT_MAX < ULONG_MAX')
+        self.serv.setblocking(False)
+        self.assertEqual(self.serv.gettimeout(), 0.0)
+        self.serv.setblocking(_testcapi.UINT_MAX + 1)
+        self.assertIsNone(self.serv.gettimeout())
+
+    _testSetBlocking_overflow = support.cpython_only(_testSetBlocking)
+
+    @unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
+                         'test needs socket.SOCK_NONBLOCK')
+    @support.requires_linux_version(2, 6, 28)
+    def testInitNonBlocking(self):
+        # reinit server socket
+        self.serv.close()
+        self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM |
+                                                  socket.SOCK_NONBLOCK)
+        self.port = support.bind_port(self.serv)
+        self.serv.listen(1)
+        # actual testing
+        start = time.time()
+        try:
+            self.serv.accept()
+        except OSError:
             pass
+        end = time.time()
+        self.assertLess(end - start, 1.0, "Error creating with non-blocking mode.")
+
+    def _testInitNonBlocking(self):
+        pass
 
     def testInheritFlags(self):
         # Issue #7995: when calling accept() on a listening socket with a
         # timeout, the resulting socket should not be non-blocking.
         self.serv.settimeout(10)
         try:
             conn, addr = self.serv.accept()
             message = conn.recv(len(MSG))
         finally:
             conn.close()
             self.serv.settimeout(None)
 
     def _testInheritFlags(self):
         time.sleep(0.1)
         self.cli.connect((HOST, self.port))
         time.sleep(0.5)
         self.cli.send(MSG)
 
     def testAccept(self):
         # Testing non-blocking accept
         self.serv.setblocking(0)
         try:
             conn, addr = self.serv.accept()
-        except socket.error:
+        except OSError:
             pass
         else:
             self.fail("Error trying to do non-blocking accept.")
         read, write, err = select.select([self.serv], [], [])
         if self.serv in read:
             conn, addr = self.serv.accept()
             conn.close()
         else:
             self.fail("Error trying to do accept after select.")
 
     def _testAccept(self):
         time.sleep(0.1)
         self.cli.connect((HOST, self.port))
 
     def testConnect(self):
         # Testing non-blocking connect
         conn, addr = self.serv.accept()
         conn.close()
 
     def _testConnect(self):
         self.cli.settimeout(10)
         self.cli.connect((HOST, self.port))
 
     def testRecv(self):
         # Testing non-blocking recv
         conn, addr = self.serv.accept()
         conn.setblocking(0)
         try:
             msg = conn.recv(len(MSG))
-        except socket.error:
+        except OSError:
             pass
         else:
             self.fail("Error trying to do non-blocking recv.")
         read, write, err = select.select([conn], [], [])
         if conn in read:
             msg = conn.recv(len(MSG))
             conn.close()
             self.assertEqual(msg, MSG)
         else:
             self.fail("Error during select call to non-blocking socket.")
@@ skipping 62 matching lines @@
         SocketConnectedTest.clientTearDown(self)
 
     def testReadAfterTimeout(self):
         # Issue #7322: A file object must disallow further reads
         # after a timeout has occurred.
         self.cli_conn.settimeout(1)
         self.read_file.read(3)
         # First read raises a timeout
         self.assertRaises(socket.timeout, self.read_file.read, 1)
         # Second read is disallowed
-        with self.assertRaises(IOError) as ctx:
+        with self.assertRaises(OSError) as ctx:
             self.read_file.read(1)
         self.assertIn("cannot read from timed out object", str(ctx.exception))
 
     def _testReadAfterTimeout(self):
         self.write_file.write(self.write_msg[0:3])
         self.write_file.flush()
         self.serv_finished.wait()
 
     def testSmallRead(self):
         # Performing small file read test
@@ skipping 54 matching lines @@
         msg = self.cli_conn.recv(len(MSG))
         if isinstance(self.read_msg, str):
             msg = msg.decode()
         self.assertEqual(msg, self.read_msg)
 
     def _testMakefileAfterMakefileClose(self):
         self.write_file.write(self.write_msg)
         self.write_file.flush()
 
     def testClosedAttr(self):
-        self.assertFalse(self.read_file.closed)
+        self.assertTrue(not self.read_file.closed)
 
     def _testClosedAttr(self):
-        self.assertFalse(self.write_file.closed)
+        self.assertTrue(not self.write_file.closed)
 
     def testAttributes(self):
         self.assertEqual(self.read_file.mode, self.read_mode)
         self.assertEqual(self.read_file.name, self.cli_conn.fileno())
 
     def _testAttributes(self):
         self.assertEqual(self.write_file.mode, self.write_mode)
         self.assertEqual(self.write_file.name, self.serv_conn.fileno())
 
     def testRealClose(self):
         self.read_file.close()
         self.assertRaises(ValueError, self.read_file.fileno)
         self.cli_conn.close()
-        self.assertRaises(socket.error, self.cli_conn.getsockname)
+        self.assertRaises(OSError, self.cli_conn.getsockname)
 
     def _testRealClose(self):
         pass
 
 
 class FileObjectInterruptedTestCase(unittest.TestCase):
     """Test that the file object correctly handles EINTR internally."""
 
     class MockSocket(object):
         def __init__(self, recv_funcs=()):
@@ skipping 16 matching lines @@
                 buffering = io.DEFAULT_BUFFER_SIZE
             if buffering == 0:
                 return raw
             buffer = io.BufferedReader(raw, buffering)
             text = io.TextIOWrapper(buffer, None, None)
             text.mode = "rb"
             return text
 
     @staticmethod
     def _raise_eintr():
-        raise socket.error(errno.EINTR, "interrupted")
+        raise OSError(errno.EINTR, "interrupted")
 
     def _textiowrap_mock_socket(self, mock, buffering=-1):
         raw = socket.SocketIO(mock, "r")
         if buffering < 0:
             buffering = io.DEFAULT_BUFFER_SIZE
         if buffering == 0:
             return raw
         buffer = io.BufferedReader(raw, buffering)
         text = io.TextIOWrapper(buffer, None, None)
         text.mode = "rb"
@@ skipping 91 matching lines @@
         self.write_file.write(b"B. " + self.write_msg)
         self.write_file.flush()
 
     def testMakefileClose(self):
         # The file returned by makefile should keep the socket open...
         self.cli_conn.close()
         msg = self.cli_conn.recv(1024)
         self.assertEqual(msg, self.read_msg)
         # ...until the file is itself closed
         self.read_file.close()
-        self.assertRaises(socket.error, self.cli_conn.recv, 1024)
+        self.assertRaises(OSError, self.cli_conn.recv, 1024)
 
     def _testMakefileClose(self):
         self.write_file.write(self.write_msg)
         self.write_file.flush()
 
     def testMakefileCloseSocketDestroy(self):
         refcount_before = sys.getrefcount(self.cli_conn)
         self.read_file.close()
         refcount_after = sys.getrefcount(self.cli_conn)
         self.assertEqual(refcount_before - 1, refcount_after)
@@ skipping 37 matching lines @@
         self.cli_finished.wait(5.0)
         # The client thread can't skip directly - the SkipTest exception
         # would appear as a failure.
         if self.serv_skipped:
             self.skipTest(self.serv_skipped)
 
     def _testWriteNonBlocking(self):
         self.serv_skipped = None
         self.serv_conn.setblocking(False)
         # Try to saturate the socket buffer pipe with repeated large writes.
-        BIG = b"x" * (1024 ** 2)
+        BIG = b"x" * support.SOCK_MAX_SIZE
         LIMIT = 10
         # The first write() succeeds since a chunk of data can be buffered
         n = self.write_file.write(BIG)
         self.assertGreater(n, 0)
         for i in range(LIMIT):
             n = self.write_file.write(BIG)
             if n is None:
                 # Succeeded
                 break
             self.assertGreater(n, 0)
@@ skipping 70 matching lines @@
         socket.socket = self.MockSocket
         try:
             yield
         finally:
             socket.socket = old_socket
 
     def test_connect(self):
         port = support.find_unused_port()
         cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.addCleanup(cli.close)
-        with self.assertRaises(socket.error) as cm:
+        with self.assertRaises(OSError) as cm:
             cli.connect((HOST, port))
         self.assertEqual(cm.exception.errno, errno.ECONNREFUSED)
 
     def test_create_connection(self):
         # Issue #9792: errors raised by create_connection() should have
         # a proper errno attribute.
         port = support.find_unused_port()
-        with self.assertRaises(socket.error) as cm:
+        with self.assertRaises(OSError) as cm:
             socket.create_connection((HOST, port))
 
         # Issue #16257: create_connection() calls getaddrinfo() against
         # 'localhost'.  This may result in an IPV6 addr being returned
         # as well as an IPV4 one:
         #   >>> socket.getaddrinfo('localhost', port, 0, SOCK_STREAM)
         #   >>> [(2,  2, 0, '', ('127.0.0.1', 41230)),
         #        (26, 2, 0, '', ('::1', 41230, 0, 0))]
         #
         # create_connection() enumerates through all the addresses returned
@@ skipping 127 matching lines @@
         self.assertRaises(socket.timeout, raise_timeout,
                               "Error generating a timeout exception (TCP)")
 
     def testTimeoutZero(self):
         ok = False
         try:
             self.serv.settimeout(0.0)
             foo = self.serv.accept()
         except socket.timeout:
             self.fail("caught timeout instead of error (TCP)")
-        except socket.error:
+        except OSError:
             ok = True
         except:
             self.fail("caught unexpected exception (TCP)")
         if not ok:
             self.fail("accept() returned success when we did not expect it")
 
+    @unittest.skipUnless(hasattr(signal, 'alarm'),
+                         'test needs signal.alarm()')
     def testInterruptedTimeout(self):
         # XXX I don't know how to do this test on MSWindows or any other
         # plaform that doesn't support signal.alarm() or os.kill(), though
         # the bug should have existed on all platforms.
-        if not hasattr(signal, "alarm"):
-            return                  # can only test on *nix
         self.serv.settimeout(5.0)   # must be longer than alarm
         class Alarm(Exception):
             pass
         def alarm_handler(signal, frame):
             raise Alarm
         old_alarm = signal.signal(signal.SIGALRM, alarm_handler)
         try:
             signal.alarm(2)    # POSIX allows alarm to be up to 1 second early
             try:
                 foo = self.serv.accept()
@@ skipping 24 matching lines @@
         self.assertRaises(socket.timeout, raise_timeout,
                               "Error generating a timeout exception (UDP)")
 
     def testTimeoutZero(self):
         ok = False
         try:
             self.serv.settimeout(0.0)
             foo = self.serv.recv(1024)
         except socket.timeout:
             self.fail("caught timeout instead of error (UDP)")
-        except socket.error:
+        except OSError:
             ok = True
         except:
             self.fail("caught unexpected exception (UDP)")
         if not ok:
             self.fail("recv() returned success when we did not expect it")
 
 class TestExceptions(unittest.TestCase):
 
     def testExceptionTree(self):
-        self.assertTrue(issubclass(socket.error, Exception))
-        self.assertTrue(issubclass(socket.herror, socket.error))
-        self.assertTrue(issubclass(socket.gaierror, socket.error))
-        self.assertTrue(issubclass(socket.timeout, socket.error))
-
+        self.assertTrue(issubclass(OSError, Exception))
+        self.assertTrue(issubclass(socket.herror, OSError))
+        self.assertTrue(issubclass(socket.gaierror, OSError))
+        self.assertTrue(issubclass(socket.timeout, OSError))
+
+@unittest.skipUnless(sys.platform == 'linux', 'Linux specific test')
 class TestLinuxAbstractNamespace(unittest.TestCase):
 
     UNIX_PATH_MAX = 108
 
     def testLinuxAbstractNamespace(self):
         address = b"\x00python-test-hello\x00\xff"
         with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s1:
             s1.bind(address)
             s1.listen(1)
             with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s2:
                 s2.connect(s1.getsockname())
                 with s1.accept()[0] as s3:
                     self.assertEqual(s1.getsockname(), address)
                     self.assertEqual(s2.getpeername(), address)
 
     def testMaxName(self):
         address = b"\x00" + b"h" * (self.UNIX_PATH_MAX - 1)
         with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
             s.bind(address)
             self.assertEqual(s.getsockname(), address)
 
     def testNameOverflow(self):
         address = "\x00" + "h" * self.UNIX_PATH_MAX
         with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
-            self.assertRaises(socket.error, s.bind, address)
+            self.assertRaises(OSError, s.bind, address)
 
     def testStrName(self):
         # Check that an abstract name can be passed as a string.
         s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         try:
             s.bind("\x00python\x00test\x00")
             self.assertEqual(s.getsockname(), b"\x00python\x00test\x00")
         finally:
             s.close()
 
+@unittest.skipUnless(hasattr(socket, 'AF_UNIX'), 'test needs socket.AF_UNIX')
 class TestUnixDomain(unittest.TestCase):
 
     def setUp(self):
         self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 
     def tearDown(self):
         self.sock.close()
 
     def encoded(self, path):
         # Return the given path encoded in the file system encoding,
@@ skipping 110 matching lines @@
 
     def testRecvFromIntoMemoryview(self):
         buf = bytearray(1024)
         nbytes, addr = self.cli_conn.recvfrom_into(memoryview(buf))
         self.assertEqual(nbytes, len(MSG))
         msg = buf[:len(MSG)]
         self.assertEqual(msg, MSG)
 
     _testRecvFromIntoMemoryview = _testRecvFromIntoArray
 
+    def testRecvFromIntoSmallBuffer(self):
+        # See issue #20246.
+        buf = bytearray(8)
+        self.assertRaises(ValueError, self.cli_conn.recvfrom_into, buf, 1024)
+
+    def _testRecvFromIntoSmallBuffer(self):
+        self.serv_conn.send(MSG)
+
+    def testRecvFromIntoEmptyBuffer(self):
+        buf = bytearray()
+        self.cli_conn.recvfrom_into(buf)
+        self.cli_conn.recvfrom_into(buf, 0)
+
+    _testRecvFromIntoEmptyBuffer = _testRecvFromIntoArray
+
 
 TIPC_STYPE = 2000
 TIPC_LOWER = 200
 TIPC_UPPER = 210
 
 def isTipcAvailable():
     """Check if the TIPC module is loaded
 
     The TIPC module is not loaded automatically on Ubuntu and probably
     other Linux distros.
     """
     if not hasattr(socket, "AF_TIPC"):
         return False
     if not os.path.isfile("/proc/modules"):
         return False
     with open("/proc/modules") as f:
         for line in f:
             if line.startswith("tipc "):
                 return True
-    if support.verbose:
-        print("TIPC module is not loaded, please 'sudo modprobe tipc'")
     return False
 
+@unittest.skipUnless(isTipcAvailable(),
+                     "TIPC module is not loaded, please 'sudo modprobe tipc'")
 class TIPCTest(unittest.TestCase):
     def testRDM(self):
         srv = socket.socket(socket.AF_TIPC, socket.SOCK_RDM)
         cli = socket.socket(socket.AF_TIPC, socket.SOCK_RDM)
         self.addCleanup(srv.close)
         self.addCleanup(cli.close)
 
         srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         srvaddr = (socket.TIPC_ADDR_NAMESEQ, TIPC_STYPE,
                 TIPC_LOWER, TIPC_UPPER)
         srv.bind(srvaddr)
 
         sendaddr = (socket.TIPC_ADDR_NAME, TIPC_STYPE,
                 TIPC_LOWER + int((TIPC_UPPER - TIPC_LOWER) / 2), 0)
         cli.sendto(MSG, sendaddr)
 
         msg, recvaddr = srv.recvfrom(1024)
 
         self.assertEqual(cli.getsockname(), recvaddr)
         self.assertEqual(msg, MSG)
 
 
+@unittest.skipUnless(isTipcAvailable(),
+                     "TIPC module is not loaded, please 'sudo modprobe tipc'")
 class TIPCThreadableTest(unittest.TestCase, ThreadableTest):
     def __init__(self, methodName = 'runTest'):
         unittest.TestCase.__init__(self, methodName = methodName)
         ThreadableTest.__init__(self)
 
     def setUp(self):
         self.srv = socket.socket(socket.AF_TIPC, socket.SOCK_STREAM)
         self.addCleanup(self.srv.close)
         self.srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         srvaddr = (socket.TIPC_ADDR_NAMESEQ, TIPC_STYPE,
@@ skipping 33 matching lines @@
         # base test
         with socket.socket() as sock:
             self.assertFalse(sock._closed)
         self.assertTrue(sock._closed)
         # close inside with block
         with socket.socket() as sock:
             sock.close()
         self.assertTrue(sock._closed)
         # exception inside with block
         with socket.socket() as sock:
-            self.assertRaises(socket.error, sock.sendall, b'foo')
+            self.assertRaises(OSError, sock.sendall, b'foo')
         self.assertTrue(sock._closed)
 
     def testCreateConnectionBase(self):
         conn, addr = self.serv.accept()
         self.addCleanup(conn.close)
         data = conn.recv(1024)
         conn.sendall(data)
 
     def _testCreateConnectionBase(self):
         address = self.serv.getsockname()
         with socket.create_connection(address) as sock:
             self.assertFalse(sock._closed)
             sock.sendall(b'foo')
             self.assertEqual(sock.recv(1024), b'foo')
         self.assertTrue(sock._closed)
 
     def testCreateConnectionClose(self):
         conn, addr = self.serv.accept()
         self.addCleanup(conn.close)
         data = conn.recv(1024)
         conn.sendall(data)
 
     def _testCreateConnectionClose(self):
         address = self.serv.getsockname()
         with socket.create_connection(address) as sock:
             sock.close()
         self.assertTrue(sock._closed)
-        self.assertRaises(socket.error, sock.sendall, b'foo')
-
-
-@unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"),
-                     "SOCK_CLOEXEC not defined")
-@unittest.skipUnless(fcntl, "module fcntl not available")
-class CloexecConstantTest(unittest.TestCase):
+        self.assertRaises(OSError, sock.sendall, b'foo')
+
+
+class InheritanceTest(unittest.TestCase):
+    @unittest.skipUnless(hasattr(socket, "SOCK_CLOEXEC"),
+                         "SOCK_CLOEXEC not defined")
     @support.requires_linux_version(2, 6, 28)
     def test_SOCK_CLOEXEC(self):
         with socket.socket(socket.AF_INET,
                            socket.SOCK_STREAM | socket.SOCK_CLOEXEC) as s:
             self.assertTrue(s.type & socket.SOCK_CLOEXEC)
-            self.assertTrue(fcntl.fcntl(s, fcntl.F_GETFD) & fcntl.FD_CLOEXEC)
+            self.assertFalse(s.get_inheritable())
+
+    def test_default_inheritable(self):
+        sock = socket.socket()
+        with sock:
+            self.assertEqual(sock.get_inheritable(), False)
+
+    def test_dup(self):
+        sock = socket.socket()
+        with sock:
+            newsock = sock.dup()
+            sock.close()
+            with newsock:
+                self.assertEqual(newsock.get_inheritable(), False)
+
+    def test_set_inheritable(self):
+        sock = socket.socket()
+        with sock:
+            sock.set_inheritable(True)
+            self.assertEqual(sock.get_inheritable(), True)
+
+            sock.set_inheritable(False)
+            self.assertEqual(sock.get_inheritable(), False)
+
+    @unittest.skipIf(fcntl is None, "need fcntl")
+    def test_get_inheritable_cloexec(self):
+        sock = socket.socket()
+        with sock:
+            fd = sock.fileno()
+            self.assertEqual(sock.get_inheritable(), False)
+
+            # clear FD_CLOEXEC flag
+            flags = fcntl.fcntl(fd, fcntl.F_GETFD)
+            flags &= ~fcntl.FD_CLOEXEC
+            fcntl.fcntl(fd, fcntl.F_SETFD, flags)
+
+            self.assertEqual(sock.get_inheritable(), True)
+
+    @unittest.skipIf(fcntl is None, "need fcntl")
+    def test_set_inheritable_cloexec(self):
+        sock = socket.socket()
+        with sock:
+            fd = sock.fileno()
+            self.assertEqual(fcntl.fcntl(fd, fcntl.F_GETFD) & fcntl.FD_CLOEXEC,
+                             fcntl.FD_CLOEXEC)
+
+            sock.set_inheritable(True)
+            self.assertEqual(fcntl.fcntl(fd, fcntl.F_GETFD) & fcntl.FD_CLOEXEC,
+                             0)
+
+
+    @unittest.skipUnless(hasattr(socket, "socketpair"),
+                         "need socket.socketpair()")
+    def test_socketpair(self):
+        s1, s2 = socket.socketpair()
+        self.addCleanup(s1.close)
+        self.addCleanup(s2.close)
+        self.assertEqual(s1.get_inheritable(), False)
+        self.assertEqual(s2.get_inheritable(), False)
 
 
 @unittest.skipUnless(hasattr(socket, "SOCK_NONBLOCK"),
                      "SOCK_NONBLOCK not defined")
 class NonblockConstantTest(unittest.TestCase):
     def checkNonblock(self, s, nonblock=True, timeout=0.0):
         if nonblock:
             self.assertTrue(s.type & socket.SOCK_NONBLOCK)
             self.assertEqual(s.gettimeout(), timeout)
         else:
@@ skipping 148 matching lines @@
         UnbufferedFileObjectClassTestCase,
         LineBufferedFileObjectClassTestCase,
         SmallBufferedFileObjectClassTestCase,
         UnicodeReadFileObjectClassTestCase,
         UnicodeWriteFileObjectClassTestCase,
         UnicodeReadWriteFileObjectClassTestCase,
         NetworkConnectionNoServer,
         NetworkConnectionAttributesTest,
         NetworkConnectionBehaviourTest,
         ContextManagersTest,
-        CloexecConstantTest,
+        InheritanceTest,
         NonblockConstantTest
     ])
-    if hasattr(socket, "socketpair"):
-        tests.append(BasicSocketPairTest)
-    if hasattr(socket, "AF_UNIX"):
-        tests.append(TestUnixDomain)
-    if sys.platform == 'linux':
-        tests.append(TestLinuxAbstractNamespace)
-    if isTipcAvailable():
-        tests.append(TIPCTest)
-        tests.append(TIPCThreadableTest)
+    tests.append(BasicSocketPairTest)
+    tests.append(TestUnixDomain)
+    tests.append(TestLinuxAbstractNamespace)
+    tests.extend([TIPCTest, TIPCThreadableTest])
     tests.extend([BasicCANTest, CANTest])
     tests.extend([BasicRDSTest, RDSTest])
     tests.extend([
         CmsgMacroTests,
         SendmsgUDPTest,
         RecvmsgUDPTest,
         RecvmsgIntoUDPTest,
         SendmsgUDP6Test,
         RecvmsgUDP6Test,
         RecvmsgRFC3542AncillaryUDP6Test,
@@ skipping 15 matching lines @@
         InterruptedSendTimeoutTest,
         TestSocketSharing,
     ])
 
     thread_info = support.threading_setup()
     support.run_unittest(*tests)
     support.threading_cleanup(*thread_info)
 
 if __name__ == "__main__":
     test_main()