Accept mutable bytes-like objects

Lib/test/test_socket.py

 import unittest
 from test import support
 
 import errno
 import io
 import itertools
 import socket
 import select
 import tempfile
 import time
@@ skipping 1056 matching lines @@
             (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('170.85.170.85', f(bytearray(b'\xaa\x55\xaa\x55')))
 
         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)
+        self.assertEqual('170.85.170.85', g(bytearray(b'\xaa\x55\xaa\x55')))
 
     @unittest.skipUnless(hasattr(socket, 'inet_ntop'),
                          'test needs socket.inet_ntop()')
     def testStringToIPv6(self):
         try:
             from socket import inet_ntop, AF_INET6, has_ipv6
             if not has_ipv6:
                 self.skipTest('IPv6 not available')
         except ImportError:
             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(
             (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')
         )
+        self.assertEqual('::1', f(bytearray(b'\x00' * 15 + b'\x01')))
 
         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()
@@ skipping 367 matching lines @@
 
     @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))
+            s.setsockopt(socket.SOL_CAN_RAW, socket.CAN_RAW_FILTER, bytearray(can_filter))
 
 
 @unittest.skipUnless(HAVE_SOCKET_CAN, 'SocketCan required for this test.')
 @unittest.skipUnless(thread, 'Threading required for this test.')
 class CANTest(ThreadedCANSocketTest):
 
     def __init__(self, methodName='runTest'):
         ThreadedCANSocketTest.__init__(self, methodName=methodName)
 
     @classmethod
@@ skipping 2990 matching lines @@
             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()
+
+    def testBytearrayName(self):
+        # Check that an abstract name can be passed as a bytearray.
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+            s.bind(bytearray(b"\x00python\x00test\x00"))
+            self.assertEqual(s.getsockname(), b"\x00python\x00test\x00")
 
 @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()
 
@@ skipping 805 matching lines @@
         SendfileUsingSendTest,
         SendfileUsingSendfileTest,
     ])
 
     thread_info = support.threading_setup()
     support.run_unittest(*tests)
     support.threading_cleanup(*thread_info)
 
 if __name__ == "__main__":
     test_main()