/Lib/test/test_socket.py
Python | 4829 lines | 4536 code | 149 blank | 144 comment | 37 complexity | 9e016c0bc485e5fbc02c9ee76fcfcc9a MD5 | raw file
Possible License(s): 0BSD
Large files files are truncated, but you can click here to view the full file
- #!/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
- 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):
- 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):
- return False
- else:
- s.close()
- return True
- HAVE_SOCKET_CAN = _have_socket_can()
- HAVE_SOCKET_RDS = _have_socket_rds()
- # Size in bytes of the int type
- SIZEOF_INT = array.array("i").itemsize
- class SocketTCPTest(unittest.TestCase):
- def setUp(self):
- self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- self.port = support.bind_port(self.serv)
- self.serv.listen(1)
- def tearDown(self):
- self.serv.close()
- self.serv = None
- class SocketUDPTest(unittest.TestCase):
- def setUp(self):
- self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- self.port = support.bind_port(self.serv)
- def tearDown(self):
- self.serv.close()
- self.serv = None
- class ThreadSafeCleanupTestCase(unittest.TestCase):
- """Subclass of unittest.TestCase with thread-safe cleanup methods.
- This subclass protects the addCleanup() and doCleanups() methods
- with a recursive lock.
- """
- if threading:
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self._cleanup_lock = threading.RLock()
- def addCleanup(self, *args, **kwargs):
- with self._cleanup_lock:
- return super().addCleanup(*args, **kwargs)
- def doCleanups(self, *args, **kwargs):
- with self._cleanup_lock:
- return super().doCleanups(*args, **kwargs)
- class SocketCANTest(unittest.TestCase):
- """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
- 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:
- 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
- def setUp(self):
- self.serv = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
- self.addCleanup(self.serv.close)
- try:
- self.port = support.bind_port(self.serv)
- except OSError:
- self.skipTest('unable to bind RDS socket')
- class ThreadableTest:
- """Threadable Test class
- The ThreadableTest class makes it easy to create a threaded
- client/server pair from an existing unit test. To create a
- new threaded class from an existing unit test, use multiple
- inheritance:
- class NewClass (OldClass, ThreadableTest):
- pass
- This class defines two new fixture functions with obvious
- purposes for overriding:
- clientSetUp ()
- clientTearDown ()
- Any new test functions within the class must then define
- tests in pairs, where the test name is preceeded with a
- '_' to indicate the client portion of the test. Ex:
- def testFoo(self):
- # Server portion
- def _testFoo(self):
- # Client portion
- Any exceptions raised by the clients during their tests
- are caught and transferred to the main thread to alert
- the testing framework.
- Note, the server setup function cannot call any blocking
- functions that rely on the client thread during setup,
- unless serverExplicitReady() is called just before
- the blocking call (such as in setting up a client/server
- connection and performing the accept() in setUp().
- """
- def __init__(self):
- # Swap the true setup function
- self.__setUp = self.setUp
- self.__tearDown = self.tearDown
- self.setUp = self._setUp
- self.tearDown = self._tearDown
- def serverExplicitReady(self):
- """This method allows the server to explicitly indicate that
- it wants the client thread to proceed. This is useful if the
- server is about to execute a blocking routine that is
- dependent upon the client thread during its setup routine."""
- self.server_ready.set()
- def _setUp(self):
- self.server_ready = threading.Event()
- self.client_ready = threading.Event()
- self.done = threading.Event()
- self.queue = queue.Queue(1)
- self.server_crashed = False
- # Do some munging to start the client test.
- methodname = self.id()
- i = methodname.rfind('.')
- methodname = methodname[i+1:]
- test_method = getattr(self, '_' + methodname)
- self.client_thread = thread.start_new_thread(
- self.clientRun, (test_method,))
- try:
- self.__setUp()
- except:
- self.server_crashed = True
- raise
- finally:
- self.server_ready.set()
- self.client_ready.wait()
- def _tearDown(self):
- self.__tearDown()
- self.done.wait()
- if self.queue.qsize():
- exc = self.queue.get()
- raise exc
- def clientRun(self, test_func):
- 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()
- thread.exit()
- class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest):
- def __init__(self, methodName='runTest'):
- SocketTCPTest.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest):
- def __init__(self, methodName='runTest'):
- SocketUDPTest.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- 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:
- # 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):
- def __init__(self, methodName='runTest'):
- SocketRDSTest.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = socket.socket(socket.PF_RDS, socket.SOCK_SEQPACKET, 0)
- try:
- # RDS sockets must be bound explicitly to send or receive data
- self.cli.bind((HOST, 0))
- self.cli_addr = self.cli.getsockname()
- 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 SocketConnectedTest(ThreadedTCPSocketTest):
- """Socket tests for client-server connection.
- self.cli_conn is a client socket connected to the server. The
- setUp() method guarantees that it is connected to the server.
- """
- def __init__(self, methodName='runTest'):
- ThreadedTCPSocketTest.__init__(self, methodName=methodName)
- def setUp(self):
- ThreadedTCPSocketTest.setUp(self)
- # Indicate explicitly we're ready for the client thread to
- # proceed and then perform the blocking call to accept
- self.serverExplicitReady()
- conn, addr = self.serv.accept()
- self.cli_conn = conn
- def tearDown(self):
- self.cli_conn.close()
- self.cli_conn = None
- ThreadedTCPSocketTest.tearDown(self)
- def clientSetUp(self):
- ThreadedTCPSocketTest.clientSetUp(self)
- self.cli.connect((HOST, self.port))
- self.serv_conn = self.cli
- def clientTearDown(self):
- self.serv_conn.close()
- self.serv_conn = None
- ThreadedTCPSocketTest.clientTearDown(self)
- class SocketPairTest(unittest.TestCase, ThreadableTest):
- def __init__(self, methodName='runTest'):
- unittest.TestCase.__init__(self, methodName=methodName)
- ThreadableTest.__init__(self)
- def setUp(self):
- self.serv, self.cli = socket.socketpair()
- def tearDown(self):
- self.serv.close()
- self.serv = None
- def clientSetUp(self):
- pass
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- # The following classes are used by the sendmsg()/recvmsg() tests.
- # Combining, for instance, ConnectedStreamTestMixin and TCPTestBase
- # gives a drop-in replacement for SocketConnectedTest, but different
- # address families can be used, and the attributes serv_addr and
- # cli_addr will be set to the addresses of the endpoints.
- class SocketTestBase(unittest.TestCase):
- """A base class for socket tests.
- Subclasses must provide methods newSocket() to return a new socket
- and bindSock(sock) to bind it to an unused address.
- Creates a socket self.serv and sets self.serv_addr to its address.
- """
- def setUp(self):
- self.serv = self.newSocket()
- self.bindServer()
- def bindServer(self):
- """Bind server socket and set self.serv_addr to its address."""
- self.bindSock(self.serv)
- self.serv_addr = self.serv.getsockname()
- def tearDown(self):
- self.serv.close()
- self.serv = None
- class SocketListeningTestMixin(SocketTestBase):
- """Mixin to listen on the server socket."""
- def setUp(self):
- super().setUp()
- self.serv.listen(1)
- class ThreadedSocketTestMixin(ThreadSafeCleanupTestCase, SocketTestBase,
- ThreadableTest):
- """Mixin to add client socket and allow client/server tests.
- Client socket is self.cli and its address is self.cli_addr. See
- ThreadableTest for usage information.
- """
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- ThreadableTest.__init__(self)
- def clientSetUp(self):
- self.cli = self.newClientSocket()
- self.bindClient()
- def newClientSocket(self):
- """Return a new socket for use as client."""
- return self.newSocket()
- def bindClient(self):
- """Bind client socket and set self.cli_addr to its address."""
- self.bindSock(self.cli)
- self.cli_addr = self.cli.getsockname()
- def clientTearDown(self):
- self.cli.close()
- self.cli = None
- ThreadableTest.clientTearDown(self)
- class ConnectedStreamTestMixin(SocketListeningTestMixin,
- ThreadedSocketTestMixin):
- """Mixin to allow client/server stream tests with connected client.
- Server's socket representing connection to client is self.cli_conn
- and client's connection to server is self.serv_conn. (Based on
- SocketConnectedTest.)
- """
- def setUp(self):
- super().setUp()
- # Indicate explicitly we're ready for the client thread to
- # proceed and then perform the blocking call to accept
- self.serverExplicitReady()
- conn, addr = self.serv.accept()
- self.cli_conn = conn
- def tearDown(self):
- self.cli_conn.close()
- self.cli_conn = None
- super().tearDown()
- def clientSetUp(self):
- super().clientSetUp()
- self.cli.connect(self.serv_addr)
- self.serv_conn = self.cli
- def clientTearDown(self):
- self.serv_conn.close()
- self.serv_conn = None
- super().clientTearDown()
- class UnixSocketTestBase(SocketTestBase):
- """Base class for Unix-domain socket tests."""
- # This class is used for file descriptor passing tests, so we
- # create the sockets in a private directory so that other users
- # can't send anything that might be problematic for a privileged
- # user running the tests.
- def setUp(self):
- self.dir_path = tempfile.mkdtemp()
- self.addCleanup(os.rmdir, self.dir_path)
- super().setUp()
- def bindSock(self, sock):
- path = tempfile.mktemp(dir=self.dir_path)
- sock.bind(path)
- self.addCleanup(support.unlink, path)
- class UnixStreamBase(UnixSocketTestBase):
- """Base class for Unix-domain SOCK_STREAM tests."""
- def newSocket(self):
- return socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
- class InetTestBase(SocketTestBase):
- """Base class for IPv4 socket tests."""
- host = HOST
- def setUp(self):
- super().setUp()
- self.port = self.serv_addr[1]
- def bindSock(self, sock):
- support.bind_port(sock, host=self.host)
- class TCPTestBase(InetTestBase):
- """Base class for TCP-over-IPv4 tests."""
- def newSocket(self):
- return socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- class UDPTestBase(InetTestBase):
- """Base class for UDP-over-IPv4 tests."""
- def newSocket(self):
- return socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
- class SCTPStreamBase(InetTestBase):
- """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"
- 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.
- def skipWithClientIf(condition, reason):
- """Skip decorated test if condition is true, add client_skip decorator.
- If the decorated object is not a class, sets its attribute
- "client_skip" to a decorator which will return an empty function
- if the test is to be skipped, or the original function if it is
- not. This can be used to avoid running the client part of a
- skipped test when using ThreadableTest.
- """
- def client_pass(*args, **kwargs):
- pass
- def skipdec(obj):
- retval = unittest.skip(reason)(obj)
- if not isinstance(obj, type):
- retval.client_skip = lambda f: client_pass
- return retval
- def noskipdec(obj):
- if not (isinstance(obj, type) or hasattr(obj, "client_skip")):
- obj.client_skip = lambda f: f
- return obj
- return skipdec if condition else noskipdec
- def requireAttrs(obj, *attributes):
- """Skip decorated test if obj is missing any of the given attributes.
- Sets client_skip attribute as skipWithClientIf() does.
- """
- missing = [name for name in attributes if not hasattr(obj, name)]
- return skipWithClientIf(
- missing, "don't have " + ", ".join(name for name in missing))
- def requireSocket(*args):
- """Skip decorated test if a socket cannot be created with given arguments.
- When an argument is given as a string, will use the value of that
- attribute of the socket module, or skip the test if it doesn't
- exist. Sets client_skip attribute as skipWithClientIf() does.
- """
- 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:
- # 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"))
- 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'):
- raise socket.herror
- with self.assertRaises(socket.error, 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:
- s.sendto('\u2620', sockname)
- self.assertEqual(str(cm.exception),
- "'str' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(5j, sockname)
- self.assertEqual(str(cm.exception),
- "'complex' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', None)
- self.assertIn('not NoneType',str(cm.exception))
- # 3 args
- with self.assertRaises(TypeError) as cm:
- s.sendto('\u2620', 0, sockname)
- self.assertEqual(str(cm.exception),
- "'str' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(5j, 0, sockname)
- self.assertEqual(str(cm.exception),
- "'complex' does not support the buffer interface")
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', 0, None)
- self.assertIn('not NoneType', str(cm.exception))
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', 'bar', sockname)
- self.assertIn('an integer is required', str(cm.exception))
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', None, None)
- self.assertIn('an integer is required', str(cm.exception))
- # wrong number of args
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo')
- self.assertIn('(1 given)', str(cm.exception))
- with self.assertRaises(TypeError) as cm:
- s.sendto(b'foo', 0, sockname, 4)
- self.assertIn('(4 given)', str(cm.exception))
- def testCrucialConstants(self):
- # Testing for mission critical constants
- socket.AF_INET
- socket.SOCK_STREAM
- socket.SOCK_DGRAM
- socket.SOCK_RAW
- 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:
- # Probably name lookup wasn't set up right; skip this test
- return
- self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.")
- try:
- hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
- except socket.error:
- # Probably a similar problem as above; skip this test
- return
- 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)))
- @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:
- 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')
- finally:
- socket.sethostname(oldhn)
- @unittest.skipUnless(hasattr(socket, 'if_nameindex'),
- 'socket.if_nameindex() not available.')
- def testInterfaceNameIndex(self):
- interfaces = socket.if_nameindex()
- for index, name in interfaces:
- self.assertIsInstance(index, int)
- self.assertIsInstance(name, str)
- # interface indices are non-zero integers
- self.assertGreater(index, 0)
- _index = socket.if_nametoindex(name)
- 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')
- # test with invalid values
- self.assertRaises(TypeError, socket.if_nametoindex, 0)
- self.assertRaises(TypeError, socket.if_indextoname, '_DEADBEEF')
- 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")
- 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:
- 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):
- self.assertEqual(i & mask, func(func(i&mask)) & mask)
- swapped = func(mask)
- self.assertEqual(swapped & mask, mask)
- self.assertRaises(OverflowError, func, 1<<34)
- def testNtoHErrors(self):
- good_values = [ 1, 2, 3, 1, 2, 3 ]
- bad_values = [ -1, -2, -3, -1, -2, -3 ]
- for k in good_values:
- socket.ntohl(k)
- socket.ntohs(k)
- socket.htonl(k)
- socket.htons(k)
- for k in bad_values:
- self.assertRaises(OverflowError, socket.ntohl, k)
- self.assertRaises(OverflowError, socket.ntohs, k)
- self.assertRaises(OverflowError, socket.htonl, k)
- self.assertRaises(OverflowError, socket.htons, k)
- def testGetServBy(self):
- eq = self.assertEqual
- # Find one service that exists, then check all the related interfaces.
- # I've ordered this by protocols that have both a tcp and udp
- # protocol, at least for modern Linuxes.
- if (sys.platform.startswith(('freebsd', 'netbsd'))
- 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:
- pass
- else:
- raise socket.error
- # 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:
- udpport = socket.getservbyname(service, 'udp')
- except socket.error:
- 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)
- self.assertRaises(OverflowError, socket.getservbyport, 65536)
- def testDefaultTimeout(self):
- # Testing default timeout
- # The default timeout should initially be None
- self.assertEqual(socket.getdefaulttimeout(), None)
- s = socket.socket()
- self.assertEqual(s.gettimeout(), None)
- s.close()
- # Set the default timeout to 10, and see if it propagates
- socket.setdefaulttimeout(10)
- self.assertEqual(socket.getdefaulttimeout(), 10)
- s = socket.socket()
- self.assertEqual(s.gettimeout(), 10)
- s.close()
- # Reset the default timeout to None, and see if it propagates
- socket.setdefaulttimeout(None)
- self.assertEqual(socket.getdefaulttimeout(), None)
- 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")
- 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'))
- 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
- )
- 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')
- 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
- except ImportError:
- return
- f = lambda a: inet_pton(AF_INET6, a)
- assertInvalid = lambda a: self.assertRaises(
- (socket.error, 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(
- b'\xad\x42\x0a\xbc' + b'\x00' * 4 + b'\x01\x27\x00\x00\x02\x54\x00\x02',
- f('ad42:abc::127:0:254:2')
- )
- self.assertEqual(b'\x00\x12\x00\x0a' + b'\x00' * 12, f('12:a::'))
- assertInvalid('0x20::')
- assertInvalid(':::')
- assertInvalid('::0::')
- assertInvalid('1::abc::')
- assertInvalid('1::abc::def')
- assertInvalid('1:2:3:4:5:6:')
- assertInvalid('1:2:3:4:5:6')
- assertInvalid('1:2:3:4:5:6:7:8:')
- assertInvalid('1:2:3:4:5:6:7:8:0')
- self.assertEqual(b'\x00' * 12 + b'\xfe\x2a\x17\x40',
- f('::254.42.23.64')
- )
- self.assertEqual(
- b'\x00\x42' + b'\x00' * 8 + b'\xa2\x9b\xfe\x2a\x17\x40',
- f('42::a29b:254.42.23.64')
- )
- self.assertEqual(
- 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')
- 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
- )
- 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)
- 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
- except ImportError:
- return
- f = lambda a: inet_ntop(AF_INET6, a)
- assertInvalid = lambda a: self.assertRaises(
- (socket.error, 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:
- # Probably name lookup wasn't set up right; skip this test
- return
- 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.assertFalse(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.assertFalse(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")
- 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)
- 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:
- self.assertRaises(OverflowError, sock.bind, (host, big_port))
- self.assertRaises(OverflowError, sock.bind, (host, neg_port))
- sock.bind((host, port))
- finally:
- sock.close()
- @unittest.skipUnless(os.name == "nt", "Windows specific")
- def test_sock_ioctl(self):
- self.assertTrue(hasattr(socket.socket, 'ioctl'))
- self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
- self.assertTrue(hasattr(socket, 'RCVALL_ON'))
- self.assertTrue(hasattr(socket, 'RCVALL_OFF'))
- self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS'))
- s = socket.socket()
- self.addCleanup(s.close)
- self.assertRaises(ValueError, s.ioctl, -1, None)
- s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 100, 100))
- def testGetaddrinfo(self):
- try:
- socket.getaddrinfo('localhost', 80)
- except socket.gaierror as err:
- if err.errno == socket.EAI_SERVICE:
- # see http://bugs.python.org/issue1282647
- self.skipTest("buggy libc version")
- raise
- # len of every sequence is supposed to be == 5
- for info in socket.getaddrinfo(HOST, None):
- self.assertEqual(len(info), 5)
- # host can be a domain name, a string representation of an
- # IPv4/v6 address or None
- socket.getaddrinfo('localhost', 80)
- 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:
- self.assertEqual(family, socket.AF_INET)
- 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)
- # test keyword arguments
- a = socket.getaddrinfo(HOST, None)
- b = socket.getaddrinfo(host=HOST, port=None)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, socket.AF_INET)
- b = socket.getaddrinfo(HOST, None, family=socket.AF_INET)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
- b = socket.getaddrinfo(HOST, None, type=socket.SOCK_STREAM)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
- b = socket.getaddrinfo(HOST, None, proto=socket.SOL_TCP)
- self.assertEqual(a, b)
- a = socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
- b = socket.getaddrinfo(HOST, None, flags=socket.AI_PASSIVE)
- 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')
- def test_getnameinfo(self):
- # only IP addresses are allowed
- self.assertRaises(socket.error, 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')
- # these should all be successful
- socket.gethostbyname('испытание.python.org')
- socket.gethostbyname_ex('испытание.python.org')
- socket.getaddrinfo('испытание.python.org',0,socket.AF_UNSPEC,socket.SOCK_STREAM)
- # this may not work if the forward lookup choses the IPv6 address, as that doesn't
- # have a reverse entry yet
- # socket.gethostbyaddr('испытание.python.org')
- def check_sendall_interrupted(self, with_timeout):
- # socketpair() is not stricly required, but it makes things easier.
- if not hasattr(signal, 'alarm') or not hasattr(socket, 'socketpair'):
- self.skipTest("signal.alarm and socket.socketpair required for this test")
- # Our signal handlers clobber the C errno by calling a math function
- # with an invalid domain value.
- def ok_handler(*args):
- self.assertRaises(ValueError, math.acosh, 0)
- def raising_handler(*args):
- 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))
- if with_timeout:
- signal.signal(signal.SIGALRM, ok_handler)
- signal.alarm(1)
- self.assertRaises(socket.timeout, c.sendall, b"x" * (1024**2))
- finally:
- 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)
- def test_dealloc_warn(self):
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- r = repr(sock)
- with self.assertWarns(ResourceWarning) as cm:
- sock = None
- support.gc_collect()
- self.assertIn(r, str(cm.warning.args[0]))
- # An open socket file object gets dereferenced after the socket
- sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- f = sock.makefile('rb')
- r = repr(sock)
- sock = None
- support.gc_collect()
- with self.assertWarns(ResourceWarning):
- f = None
- support.gc_collect()
- def test_name_closed_socketio(self):
- with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
- fp = sock.makefile("rb")
- fp.close()
- self.assertEqual(repr(fp), "<_io.BufferedReader name=-1>")
- def test_unusable_closed_socketio(self):
- with socket.socket() as sock:
- fp = sock.makefile("rb", buffering=0)
- self.assertTrue(fp.readable())
- self.assertFalse(fp.writable())
- self.assertFalse(fp.seekable())
- fp.close()
- 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):
- srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
- srv.bind((HOST, 0))
- # backlog = 0
- srv.listen(0)
- 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)
- with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
- self.assertRaises(OverflowError, s.bind, ('::1', 0, -10))
- @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
- def testCreateSocket(self):
- with socket.socket(socket.PF_CAN, socket.SOCK_RAW, socket.CAN_RAW) 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',
- 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)
- @classmethod
- def dissect_can_frame(cls, frame):
- """Dissect a CAN frame."""
- can_id, can_dlc, data = struct.unpack(cls.can_frame_fmt, frame)
- return (can_id, can_dlc, data[:can_dlc])
- def testSendFrame(self):
- cf, addr = self.s.recvfrom(self.bufsize)
- self.assertEqual(self.cf, cf)
- self.assertEqual(addr[0], self.interface)
- self.assertEqual(addr[1], socket.AF_CAN)
- def _testSendFrame(self):
- self.cf = self.build_can_frame(0x00, b'\x01\x02\x03\x04\x05')
- self.cli.send(self.cf)
- def testSendMaxFrame(self):
- cf, addr = self.s.recvfrom(self.bufsize)
- self.assertEqual(self.cf, cf)
- def _testSendMaxFrame(self):
- self.cf = self.build_can_frame(0x00, b'\x07' * 8)
- self.cli.send(self.cf)
- def testSendMultiFrames(self):
- cf, addr = self.s.recvfrom(self.bufsize)
- self.assertEqual(self.cf1, cf)
- 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(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):
- with socket.sock…
Large files files are truncated, but you can click here to view the full file