PageRenderTime 48ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 0ms

/Lib/test/test_socket.py

https://bitbucket.org/python_mirrors/sandbox-guido
Python | 2056 lines | 1845 code | 103 blank | 108 comment | 89 complexity | fe9c7ab96b978b282c29429f935ed60b MD5 | raw file
Possible License(s): BSD-3-Clause, 0BSD

Large files files are truncated, but you can click here to view the full file

  1. #!/usr/bin/env python3
  2. import unittest
  3. from test import support
  4. import errno
  5. import io
  6. import socket
  7. import select
  8. import time
  9. import traceback
  10. import queue
  11. import sys
  12. import os
  13. import array
  14. import platform
  15. import contextlib
  16. from weakref import proxy
  17. import signal
  18. import math
  19. import pickle
  20. try:
  21. import fcntl
  22. except ImportError:
  23. fcntl = False
  24. def try_address(host, port=0, family=socket.AF_INET):
  25. """Try to bind a socket on the given host:port and return True
  26. if that has been possible."""
  27. try:
  28. sock = socket.socket(family, socket.SOCK_STREAM)
  29. sock.bind((host, port))
  30. except (socket.error, socket.gaierror):
  31. return False
  32. else:
  33. sock.close()
  34. return True
  35. def linux_version():
  36. try:
  37. # platform.release() is something like '2.6.33.7-desktop-2mnb'
  38. version_string = platform.release().split('-')[0]
  39. return tuple(map(int, version_string.split('.')))
  40. except ValueError:
  41. return 0, 0, 0
  42. HOST = support.HOST
  43. MSG = 'Michael Gilfix was here\u1234\r\n'.encode('utf-8') ## test unicode string and carriage return
  44. SUPPORTS_IPV6 = socket.has_ipv6 and try_address('::1', family=socket.AF_INET6)
  45. try:
  46. import _thread as thread
  47. import threading
  48. except ImportError:
  49. thread = None
  50. threading = None
  51. class SocketTCPTest(unittest.TestCase):
  52. def setUp(self):
  53. self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  54. self.port = support.bind_port(self.serv)
  55. self.serv.listen(1)
  56. def tearDown(self):
  57. self.serv.close()
  58. self.serv = None
  59. class SocketUDPTest(unittest.TestCase):
  60. def setUp(self):
  61. self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  62. self.port = support.bind_port(self.serv)
  63. def tearDown(self):
  64. self.serv.close()
  65. self.serv = None
  66. class ThreadableTest:
  67. """Threadable Test class
  68. The ThreadableTest class makes it easy to create a threaded
  69. client/server pair from an existing unit test. To create a
  70. new threaded class from an existing unit test, use multiple
  71. inheritance:
  72. class NewClass (OldClass, ThreadableTest):
  73. pass
  74. This class defines two new fixture functions with obvious
  75. purposes for overriding:
  76. clientSetUp ()
  77. clientTearDown ()
  78. Any new test functions within the class must then define
  79. tests in pairs, where the test name is preceeded with a
  80. '_' to indicate the client portion of the test. Ex:
  81. def testFoo(self):
  82. # Server portion
  83. def _testFoo(self):
  84. # Client portion
  85. Any exceptions raised by the clients during their tests
  86. are caught and transferred to the main thread to alert
  87. the testing framework.
  88. Note, the server setup function cannot call any blocking
  89. functions that rely on the client thread during setup,
  90. unless serverExplicitReady() is called just before
  91. the blocking call (such as in setting up a client/server
  92. connection and performing the accept() in setUp().
  93. """
  94. def __init__(self):
  95. # Swap the true setup function
  96. self.__setUp = self.setUp
  97. self.__tearDown = self.tearDown
  98. self.setUp = self._setUp
  99. self.tearDown = self._tearDown
  100. def serverExplicitReady(self):
  101. """This method allows the server to explicitly indicate that
  102. it wants the client thread to proceed. This is useful if the
  103. server is about to execute a blocking routine that is
  104. dependent upon the client thread during its setup routine."""
  105. self.server_ready.set()
  106. def _setUp(self):
  107. self.server_ready = threading.Event()
  108. self.client_ready = threading.Event()
  109. self.done = threading.Event()
  110. self.queue = queue.Queue(1)
  111. # Do some munging to start the client test.
  112. methodname = self.id()
  113. i = methodname.rfind('.')
  114. methodname = methodname[i+1:]
  115. test_method = getattr(self, '_' + methodname)
  116. self.client_thread = thread.start_new_thread(
  117. self.clientRun, (test_method,))
  118. self.__setUp()
  119. if not self.server_ready.is_set():
  120. self.server_ready.set()
  121. self.client_ready.wait()
  122. def _tearDown(self):
  123. self.__tearDown()
  124. self.done.wait()
  125. if self.queue.qsize():
  126. exc = self.queue.get()
  127. raise exc
  128. def clientRun(self, test_func):
  129. self.server_ready.wait()
  130. self.client_ready.set()
  131. self.clientSetUp()
  132. if not hasattr(test_func, '__call__'):
  133. raise TypeError("test_func must be a callable function")
  134. try:
  135. test_func()
  136. except BaseException as e:
  137. self.queue.put(e)
  138. finally:
  139. self.clientTearDown()
  140. def clientSetUp(self):
  141. raise NotImplementedError("clientSetUp must be implemented.")
  142. def clientTearDown(self):
  143. self.done.set()
  144. thread.exit()
  145. class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest):
  146. def __init__(self, methodName='runTest'):
  147. SocketTCPTest.__init__(self, methodName=methodName)
  148. ThreadableTest.__init__(self)
  149. def clientSetUp(self):
  150. self.cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  151. def clientTearDown(self):
  152. self.cli.close()
  153. self.cli = None
  154. ThreadableTest.clientTearDown(self)
  155. class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest):
  156. def __init__(self, methodName='runTest'):
  157. SocketUDPTest.__init__(self, methodName=methodName)
  158. ThreadableTest.__init__(self)
  159. def clientSetUp(self):
  160. self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  161. def clientTearDown(self):
  162. self.cli.close()
  163. self.cli = None
  164. ThreadableTest.clientTearDown(self)
  165. class SocketConnectedTest(ThreadedTCPSocketTest):
  166. """Socket tests for client-server connection.
  167. self.cli_conn is a client socket connected to the server. The
  168. setUp() method guarantees that it is connected to the server.
  169. """
  170. def __init__(self, methodName='runTest'):
  171. ThreadedTCPSocketTest.__init__(self, methodName=methodName)
  172. def setUp(self):
  173. ThreadedTCPSocketTest.setUp(self)
  174. # Indicate explicitly we're ready for the client thread to
  175. # proceed and then perform the blocking call to accept
  176. self.serverExplicitReady()
  177. conn, addr = self.serv.accept()
  178. self.cli_conn = conn
  179. def tearDown(self):
  180. self.cli_conn.close()
  181. self.cli_conn = None
  182. ThreadedTCPSocketTest.tearDown(self)
  183. def clientSetUp(self):
  184. ThreadedTCPSocketTest.clientSetUp(self)
  185. self.cli.connect((HOST, self.port))
  186. self.serv_conn = self.cli
  187. def clientTearDown(self):
  188. self.serv_conn.close()
  189. self.serv_conn = None
  190. ThreadedTCPSocketTest.clientTearDown(self)
  191. class SocketPairTest(unittest.TestCase, ThreadableTest):
  192. def __init__(self, methodName='runTest'):
  193. unittest.TestCase.__init__(self, methodName=methodName)
  194. ThreadableTest.__init__(self)
  195. def setUp(self):
  196. self.serv, self.cli = socket.socketpair()
  197. def tearDown(self):
  198. self.serv.close()
  199. self.serv = None
  200. def clientSetUp(self):
  201. pass
  202. def clientTearDown(self):
  203. self.cli.close()
  204. self.cli = None
  205. ThreadableTest.clientTearDown(self)
  206. #######################################################################
  207. ## Begin Tests
  208. class GeneralModuleTests(unittest.TestCase):
  209. def test_repr(self):
  210. s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  211. self.addCleanup(s.close)
  212. self.assertTrue(repr(s).startswith("<socket.socket object"))
  213. def test_weakref(self):
  214. s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  215. p = proxy(s)
  216. self.assertEqual(p.fileno(), s.fileno())
  217. s.close()
  218. s = None
  219. try:
  220. p.fileno()
  221. except ReferenceError:
  222. pass
  223. else:
  224. self.fail('Socket proxy still exists')
  225. def testSocketError(self):
  226. # Testing socket module exceptions
  227. def raise_error(*args, **kwargs):
  228. raise socket.error
  229. def raise_herror(*args, **kwargs):
  230. raise socket.herror
  231. def raise_gaierror(*args, **kwargs):
  232. raise socket.gaierror
  233. self.assertRaises(socket.error, raise_error,
  234. "Error raising socket exception.")
  235. self.assertRaises(socket.error, raise_herror,
  236. "Error raising socket exception.")
  237. self.assertRaises(socket.error, raise_gaierror,
  238. "Error raising socket exception.")
  239. def testCrucialConstants(self):
  240. # Testing for mission critical constants
  241. socket.AF_INET
  242. socket.SOCK_STREAM
  243. socket.SOCK_DGRAM
  244. socket.SOCK_RAW
  245. socket.SOCK_RDM
  246. socket.SOCK_SEQPACKET
  247. socket.SOL_SOCKET
  248. socket.SO_REUSEADDR
  249. def testHostnameRes(self):
  250. # Testing hostname resolution mechanisms
  251. hostname = socket.gethostname()
  252. try:
  253. ip = socket.gethostbyname(hostname)
  254. except socket.error:
  255. # Probably name lookup wasn't set up right; skip this test
  256. return
  257. self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.")
  258. try:
  259. hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
  260. except socket.error:
  261. # Probably a similar problem as above; skip this test
  262. return
  263. all_host_names = [hostname, hname] + aliases
  264. fqhn = socket.getfqdn(ip)
  265. if not fqhn in all_host_names:
  266. self.fail("Error testing host resolution mechanisms. (fqdn: %s, all: %s)" % (fqhn, repr(all_host_names)))
  267. @unittest.skipUnless(hasattr(socket, 'sethostname'), "test needs socket.sethostname()")
  268. @unittest.skipUnless(hasattr(socket, 'gethostname'), "test needs socket.gethostname()")
  269. def test_sethostname(self):
  270. oldhn = socket.gethostname()
  271. try:
  272. socket.sethostname('new')
  273. except socket.error as e:
  274. if e.errno == errno.EPERM:
  275. self.skipTest("test should be run as root")
  276. else:
  277. raise
  278. try:
  279. # running test as root!
  280. self.assertEqual(socket.gethostname(), 'new')
  281. # Should work with bytes objects too
  282. socket.sethostname(b'bar')
  283. self.assertEqual(socket.gethostname(), 'bar')
  284. finally:
  285. socket.sethostname(oldhn)
  286. def testRefCountGetNameInfo(self):
  287. # Testing reference count for getnameinfo
  288. if hasattr(sys, "getrefcount"):
  289. try:
  290. # On some versions, this loses a reference
  291. orig = sys.getrefcount(__name__)
  292. socket.getnameinfo(__name__,0)
  293. except TypeError:
  294. if sys.getrefcount(__name__) != orig:
  295. self.fail("socket.getnameinfo loses a reference")
  296. def testInterpreterCrash(self):
  297. # Making sure getnameinfo doesn't crash the interpreter
  298. try:
  299. # On some versions, this crashes the interpreter.
  300. socket.getnameinfo(('x', 0, 0, 0), 0)
  301. except socket.error:
  302. pass
  303. def testNtoH(self):
  304. # This just checks that htons etc. are their own inverse,
  305. # when looking at the lower 16 or 32 bits.
  306. sizes = {socket.htonl: 32, socket.ntohl: 32,
  307. socket.htons: 16, socket.ntohs: 16}
  308. for func, size in sizes.items():
  309. mask = (1<<size) - 1
  310. for i in (0, 1, 0xffff, ~0xffff, 2, 0x01234567, 0x76543210):
  311. self.assertEqual(i & mask, func(func(i&mask)) & mask)
  312. swapped = func(mask)
  313. self.assertEqual(swapped & mask, mask)
  314. self.assertRaises(OverflowError, func, 1<<34)
  315. def testNtoHErrors(self):
  316. good_values = [ 1, 2, 3, 1, 2, 3 ]
  317. bad_values = [ -1, -2, -3, -1, -2, -3 ]
  318. for k in good_values:
  319. socket.ntohl(k)
  320. socket.ntohs(k)
  321. socket.htonl(k)
  322. socket.htons(k)
  323. for k in bad_values:
  324. self.assertRaises(OverflowError, socket.ntohl, k)
  325. self.assertRaises(OverflowError, socket.ntohs, k)
  326. self.assertRaises(OverflowError, socket.htonl, k)
  327. self.assertRaises(OverflowError, socket.htons, k)
  328. def testGetServBy(self):
  329. eq = self.assertEqual
  330. # Find one service that exists, then check all the related interfaces.
  331. # I've ordered this by protocols that have both a tcp and udp
  332. # protocol, at least for modern Linuxes.
  333. if (sys.platform.startswith('linux') or
  334. sys.platform.startswith('freebsd') or
  335. sys.platform.startswith('netbsd') or
  336. sys.platform == 'darwin'):
  337. # avoid the 'echo' service on this platform, as there is an
  338. # assumption breaking non-standard port/protocol entry
  339. services = ('daytime', 'qotd', 'domain')
  340. else:
  341. services = ('echo', 'daytime', 'domain')
  342. for service in services:
  343. try:
  344. port = socket.getservbyname(service, 'tcp')
  345. break
  346. except socket.error:
  347. pass
  348. else:
  349. raise socket.error
  350. # Try same call with optional protocol omitted
  351. port2 = socket.getservbyname(service)
  352. eq(port, port2)
  353. # Try udp, but don't barf it it doesn't exist
  354. try:
  355. udpport = socket.getservbyname(service, 'udp')
  356. except socket.error:
  357. udpport = None
  358. else:
  359. eq(udpport, port)
  360. # Now make sure the lookup by port returns the same service name
  361. eq(socket.getservbyport(port2), service)
  362. eq(socket.getservbyport(port, 'tcp'), service)
  363. if udpport is not None:
  364. eq(socket.getservbyport(udpport, 'udp'), service)
  365. # Make sure getservbyport does not accept out of range ports.
  366. self.assertRaises(OverflowError, socket.getservbyport, -1)
  367. self.assertRaises(OverflowError, socket.getservbyport, 65536)
  368. def testDefaultTimeout(self):
  369. # Testing default timeout
  370. # The default timeout should initially be None
  371. self.assertEqual(socket.getdefaulttimeout(), None)
  372. s = socket.socket()
  373. self.assertEqual(s.gettimeout(), None)
  374. s.close()
  375. # Set the default timeout to 10, and see if it propagates
  376. socket.setdefaulttimeout(10)
  377. self.assertEqual(socket.getdefaulttimeout(), 10)
  378. s = socket.socket()
  379. self.assertEqual(s.gettimeout(), 10)
  380. s.close()
  381. # Reset the default timeout to None, and see if it propagates
  382. socket.setdefaulttimeout(None)
  383. self.assertEqual(socket.getdefaulttimeout(), None)
  384. s = socket.socket()
  385. self.assertEqual(s.gettimeout(), None)
  386. s.close()
  387. # Check that setting it to an invalid value raises ValueError
  388. self.assertRaises(ValueError, socket.setdefaulttimeout, -1)
  389. # Check that setting it to an invalid type raises TypeError
  390. self.assertRaises(TypeError, socket.setdefaulttimeout, "spam")
  391. def testIPv4_inet_aton_fourbytes(self):
  392. if not hasattr(socket, 'inet_aton'):
  393. return # No inet_aton, nothing to check
  394. # Test that issue1008086 and issue767150 are fixed.
  395. # It must return 4 bytes.
  396. self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0'))
  397. self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255'))
  398. def testIPv4toString(self):
  399. if not hasattr(socket, 'inet_pton'):
  400. return # No inet_pton() on this platform
  401. from socket import inet_aton as f, inet_pton, AF_INET
  402. g = lambda a: inet_pton(AF_INET, a)
  403. self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0'))
  404. self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0'))
  405. self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170'))
  406. self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4'))
  407. self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255'))
  408. self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0'))
  409. self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0'))
  410. self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170'))
  411. self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255'))
  412. def testIPv6toString(self):
  413. if not hasattr(socket, 'inet_pton'):
  414. return # No inet_pton() on this platform
  415. try:
  416. from socket import inet_pton, AF_INET6, has_ipv6
  417. if not has_ipv6:
  418. return
  419. except ImportError:
  420. return
  421. f = lambda a: inet_pton(AF_INET6, a)
  422. self.assertEqual(b'\x00' * 16, f('::'))
  423. self.assertEqual(b'\x00' * 16, f('0::0'))
  424. self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::'))
  425. self.assertEqual(
  426. b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae',
  427. f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae')
  428. )
  429. def testStringToIPv4(self):
  430. if not hasattr(socket, 'inet_ntop'):
  431. return # No inet_ntop() on this platform
  432. from socket import inet_ntoa as f, inet_ntop, AF_INET
  433. g = lambda a: inet_ntop(AF_INET, a)
  434. self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00'))
  435. self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55'))
  436. self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff'))
  437. self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04'))
  438. self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00'))
  439. self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55'))
  440. self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff'))
  441. def testStringToIPv6(self):
  442. if not hasattr(socket, 'inet_ntop'):
  443. return # No inet_ntop() on this platform
  444. try:
  445. from socket import inet_ntop, AF_INET6, has_ipv6
  446. if not has_ipv6:
  447. return
  448. except ImportError:
  449. return
  450. f = lambda a: inet_ntop(AF_INET6, a)
  451. self.assertEqual('::', f(b'\x00' * 16))
  452. self.assertEqual('::1', f(b'\x00' * 15 + b'\x01'))
  453. self.assertEqual(
  454. 'aef:b01:506:1001:ffff:9997:55:170',
  455. f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70')
  456. )
  457. # XXX The following don't test module-level functionality...
  458. def _get_unused_port(self, bind_address='0.0.0.0'):
  459. """Use a temporary socket to elicit an unused ephemeral port.
  460. Args:
  461. bind_address: Hostname or IP address to search for a port on.
  462. Returns: A most likely to be unused port.
  463. """
  464. tempsock = socket.socket()
  465. tempsock.bind((bind_address, 0))
  466. host, port = tempsock.getsockname()
  467. tempsock.close()
  468. return port
  469. def testSockName(self):
  470. # Testing getsockname()
  471. port = self._get_unused_port()
  472. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  473. self.addCleanup(sock.close)
  474. sock.bind(("0.0.0.0", port))
  475. name = sock.getsockname()
  476. # XXX(nnorwitz): http://tinyurl.com/os5jz seems to indicate
  477. # it reasonable to get the host's addr in addition to 0.0.0.0.
  478. # At least for eCos. This is required for the S/390 to pass.
  479. try:
  480. my_ip_addr = socket.gethostbyname(socket.gethostname())
  481. except socket.error:
  482. # Probably name lookup wasn't set up right; skip this test
  483. return
  484. self.assertIn(name[0], ("0.0.0.0", my_ip_addr), '%s invalid' % name[0])
  485. self.assertEqual(name[1], port)
  486. def testGetSockOpt(self):
  487. # Testing getsockopt()
  488. # We know a socket should start without reuse==0
  489. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  490. self.addCleanup(sock.close)
  491. reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
  492. self.assertFalse(reuse != 0, "initial mode is reuse")
  493. def testSetSockOpt(self):
  494. # Testing setsockopt()
  495. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  496. self.addCleanup(sock.close)
  497. sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  498. reuse = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR)
  499. self.assertFalse(reuse == 0, "failed to set reuse mode")
  500. def testSendAfterClose(self):
  501. # testing send() after close() with timeout
  502. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  503. sock.settimeout(1)
  504. sock.close()
  505. self.assertRaises(socket.error, sock.send, b"spam")
  506. def testNewAttributes(self):
  507. # testing .family, .type and .protocol
  508. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  509. self.assertEqual(sock.family, socket.AF_INET)
  510. self.assertEqual(sock.type, socket.SOCK_STREAM)
  511. self.assertEqual(sock.proto, 0)
  512. sock.close()
  513. def test_getsockaddrarg(self):
  514. host = '0.0.0.0'
  515. port = self._get_unused_port(bind_address=host)
  516. big_port = port + 65536
  517. neg_port = port - 65536
  518. sock = socket.socket()
  519. try:
  520. self.assertRaises(OverflowError, sock.bind, (host, big_port))
  521. self.assertRaises(OverflowError, sock.bind, (host, neg_port))
  522. sock.bind((host, port))
  523. finally:
  524. sock.close()
  525. @unittest.skipUnless(os.name == "nt", "Windows specific")
  526. def test_sock_ioctl(self):
  527. self.assertTrue(hasattr(socket.socket, 'ioctl'))
  528. self.assertTrue(hasattr(socket, 'SIO_RCVALL'))
  529. self.assertTrue(hasattr(socket, 'RCVALL_ON'))
  530. self.assertTrue(hasattr(socket, 'RCVALL_OFF'))
  531. self.assertTrue(hasattr(socket, 'SIO_KEEPALIVE_VALS'))
  532. s = socket.socket()
  533. self.addCleanup(s.close)
  534. self.assertRaises(ValueError, s.ioctl, -1, None)
  535. s.ioctl(socket.SIO_KEEPALIVE_VALS, (1, 100, 100))
  536. def testGetaddrinfo(self):
  537. try:
  538. socket.getaddrinfo('localhost', 80)
  539. except socket.gaierror as err:
  540. if err.errno == socket.EAI_SERVICE:
  541. # see http://bugs.python.org/issue1282647
  542. self.skipTest("buggy libc version")
  543. raise
  544. # len of every sequence is supposed to be == 5
  545. for info in socket.getaddrinfo(HOST, None):
  546. self.assertEqual(len(info), 5)
  547. # host can be a domain name, a string representation of an
  548. # IPv4/v6 address or None
  549. socket.getaddrinfo('localhost', 80)
  550. socket.getaddrinfo('127.0.0.1', 80)
  551. socket.getaddrinfo(None, 80)
  552. if SUPPORTS_IPV6:
  553. socket.getaddrinfo('::1', 80)
  554. # port can be a string service name such as "http", a numeric
  555. # port number or None
  556. socket.getaddrinfo(HOST, "http")
  557. socket.getaddrinfo(HOST, 80)
  558. socket.getaddrinfo(HOST, None)
  559. # test family and socktype filters
  560. infos = socket.getaddrinfo(HOST, None, socket.AF_INET)
  561. for family, _, _, _, _ in infos:
  562. self.assertEqual(family, socket.AF_INET)
  563. infos = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
  564. for _, socktype, _, _, _ in infos:
  565. self.assertEqual(socktype, socket.SOCK_STREAM)
  566. # test proto and flags arguments
  567. socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
  568. socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
  569. # a server willing to support both IPv4 and IPv6 will
  570. # usually do this
  571. socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
  572. socket.AI_PASSIVE)
  573. # test keyword arguments
  574. a = socket.getaddrinfo(HOST, None)
  575. b = socket.getaddrinfo(host=HOST, port=None)
  576. self.assertEqual(a, b)
  577. a = socket.getaddrinfo(HOST, None, socket.AF_INET)
  578. b = socket.getaddrinfo(HOST, None, family=socket.AF_INET)
  579. self.assertEqual(a, b)
  580. a = socket.getaddrinfo(HOST, None, 0, socket.SOCK_STREAM)
  581. b = socket.getaddrinfo(HOST, None, type=socket.SOCK_STREAM)
  582. self.assertEqual(a, b)
  583. a = socket.getaddrinfo(HOST, None, 0, 0, socket.SOL_TCP)
  584. b = socket.getaddrinfo(HOST, None, proto=socket.SOL_TCP)
  585. self.assertEqual(a, b)
  586. a = socket.getaddrinfo(HOST, None, 0, 0, 0, socket.AI_PASSIVE)
  587. b = socket.getaddrinfo(HOST, None, flags=socket.AI_PASSIVE)
  588. self.assertEqual(a, b)
  589. a = socket.getaddrinfo(None, 0, socket.AF_UNSPEC, socket.SOCK_STREAM, 0,
  590. socket.AI_PASSIVE)
  591. b = socket.getaddrinfo(host=None, port=0, family=socket.AF_UNSPEC,
  592. type=socket.SOCK_STREAM, proto=0,
  593. flags=socket.AI_PASSIVE)
  594. self.assertEqual(a, b)
  595. # Issue #6697.
  596. self.assertRaises(UnicodeEncodeError, socket.getaddrinfo, 'localhost', '\uD800')
  597. def test_getnameinfo(self):
  598. # only IP addresses are allowed
  599. self.assertRaises(socket.error, socket.getnameinfo, ('mail.python.org',0), 0)
  600. @unittest.skipUnless(support.is_resource_enabled('network'),
  601. 'network is not enabled')
  602. def test_idna(self):
  603. support.requires('network')
  604. # these should all be successful
  605. socket.gethostbyname('испытание.python.org')
  606. socket.gethostbyname_ex('испытание.python.org')
  607. socket.getaddrinfo('испытание.python.org',0,socket.AF_UNSPEC,socket.SOCK_STREAM)
  608. # this may not work if the forward lookup choses the IPv6 address, as that doesn't
  609. # have a reverse entry yet
  610. # socket.gethostbyaddr('испытание.python.org')
  611. def check_sendall_interrupted(self, with_timeout):
  612. # socketpair() is not stricly required, but it makes things easier.
  613. if not hasattr(signal, 'alarm') or not hasattr(socket, 'socketpair'):
  614. self.skipTest("signal.alarm and socket.socketpair required for this test")
  615. # Our signal handlers clobber the C errno by calling a math function
  616. # with an invalid domain value.
  617. def ok_handler(*args):
  618. self.assertRaises(ValueError, math.acosh, 0)
  619. def raising_handler(*args):
  620. self.assertRaises(ValueError, math.acosh, 0)
  621. 1 // 0
  622. c, s = socket.socketpair()
  623. old_alarm = signal.signal(signal.SIGALRM, raising_handler)
  624. try:
  625. if with_timeout:
  626. # Just above the one second minimum for signal.alarm
  627. c.settimeout(1.5)
  628. with self.assertRaises(ZeroDivisionError):
  629. signal.alarm(1)
  630. c.sendall(b"x" * (1024**2))
  631. if with_timeout:
  632. signal.signal(signal.SIGALRM, ok_handler)
  633. signal.alarm(1)
  634. self.assertRaises(socket.timeout, c.sendall, b"x" * (1024**2))
  635. finally:
  636. signal.signal(signal.SIGALRM, old_alarm)
  637. c.close()
  638. s.close()
  639. def test_sendall_interrupted(self):
  640. self.check_sendall_interrupted(False)
  641. def test_sendall_interrupted_with_timeout(self):
  642. self.check_sendall_interrupted(True)
  643. def test_dealloc_warn(self):
  644. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  645. r = repr(sock)
  646. with self.assertWarns(ResourceWarning) as cm:
  647. sock = None
  648. support.gc_collect()
  649. self.assertIn(r, str(cm.warning.args[0]))
  650. # An open socket file object gets dereferenced after the socket
  651. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  652. f = sock.makefile('rb')
  653. r = repr(sock)
  654. sock = None
  655. support.gc_collect()
  656. with self.assertWarns(ResourceWarning):
  657. f = None
  658. support.gc_collect()
  659. def test_name_closed_socketio(self):
  660. with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
  661. fp = sock.makefile("rb")
  662. fp.close()
  663. self.assertEqual(repr(fp), "<_io.BufferedReader name=-1>")
  664. def test_pickle(self):
  665. sock = socket.socket()
  666. with sock:
  667. for protocol in range(pickle.HIGHEST_PROTOCOL + 1):
  668. self.assertRaises(TypeError, pickle.dumps, sock, protocol)
  669. @unittest.skipUnless(thread, 'Threading required for this test.')
  670. class BasicTCPTest(SocketConnectedTest):
  671. def __init__(self, methodName='runTest'):
  672. SocketConnectedTest.__init__(self, methodName=methodName)
  673. def testRecv(self):
  674. # Testing large receive over TCP
  675. msg = self.cli_conn.recv(1024)
  676. self.assertEqual(msg, MSG)
  677. def _testRecv(self):
  678. self.serv_conn.send(MSG)
  679. def testOverFlowRecv(self):
  680. # Testing receive in chunks over TCP
  681. seg1 = self.cli_conn.recv(len(MSG) - 3)
  682. seg2 = self.cli_conn.recv(1024)
  683. msg = seg1 + seg2
  684. self.assertEqual(msg, MSG)
  685. def _testOverFlowRecv(self):
  686. self.serv_conn.send(MSG)
  687. def testRecvFrom(self):
  688. # Testing large recvfrom() over TCP
  689. msg, addr = self.cli_conn.recvfrom(1024)
  690. self.assertEqual(msg, MSG)
  691. def _testRecvFrom(self):
  692. self.serv_conn.send(MSG)
  693. def testOverFlowRecvFrom(self):
  694. # Testing recvfrom() in chunks over TCP
  695. seg1, addr = self.cli_conn.recvfrom(len(MSG)-3)
  696. seg2, addr = self.cli_conn.recvfrom(1024)
  697. msg = seg1 + seg2
  698. self.assertEqual(msg, MSG)
  699. def _testOverFlowRecvFrom(self):
  700. self.serv_conn.send(MSG)
  701. def testSendAll(self):
  702. # Testing sendall() with a 2048 byte string over TCP
  703. msg = b''
  704. while 1:
  705. read = self.cli_conn.recv(1024)
  706. if not read:
  707. break
  708. msg += read
  709. self.assertEqual(msg, b'f' * 2048)
  710. def _testSendAll(self):
  711. big_chunk = b'f' * 2048
  712. self.serv_conn.sendall(big_chunk)
  713. def testFromFd(self):
  714. # Testing fromfd()
  715. fd = self.cli_conn.fileno()
  716. sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
  717. self.addCleanup(sock.close)
  718. self.assertIsInstance(sock, socket.socket)
  719. msg = sock.recv(1024)
  720. self.assertEqual(msg, MSG)
  721. def _testFromFd(self):
  722. self.serv_conn.send(MSG)
  723. def testDup(self):
  724. # Testing dup()
  725. sock = self.cli_conn.dup()
  726. self.addCleanup(sock.close)
  727. msg = sock.recv(1024)
  728. self.assertEqual(msg, MSG)
  729. def _testDup(self):
  730. self.serv_conn.send(MSG)
  731. def testShutdown(self):
  732. # Testing shutdown()
  733. msg = self.cli_conn.recv(1024)
  734. self.assertEqual(msg, MSG)
  735. # wait for _testShutdown to finish: on OS X, when the server
  736. # closes the connection the client also becomes disconnected,
  737. # and the client's shutdown call will fail. (Issue #4397.)
  738. self.done.wait()
  739. def _testShutdown(self):
  740. self.serv_conn.send(MSG)
  741. self.serv_conn.shutdown(2)
  742. def testDetach(self):
  743. # Testing detach()
  744. fileno = self.cli_conn.fileno()
  745. f = self.cli_conn.detach()
  746. self.assertEqual(f, fileno)
  747. # cli_conn cannot be used anymore...
  748. self.assertRaises(socket.error, self.cli_conn.recv, 1024)
  749. self.cli_conn.close()
  750. # ...but we can create another socket using the (still open)
  751. # file descriptor
  752. sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, fileno=f)
  753. self.addCleanup(sock.close)
  754. msg = sock.recv(1024)
  755. self.assertEqual(msg, MSG)
  756. def _testDetach(self):
  757. self.serv_conn.send(MSG)
  758. @unittest.skipUnless(thread, 'Threading required for this test.')
  759. class BasicUDPTest(ThreadedUDPSocketTest):
  760. def __init__(self, methodName='runTest'):
  761. ThreadedUDPSocketTest.__init__(self, methodName=methodName)
  762. def testSendtoAndRecv(self):
  763. # Testing sendto() and Recv() over UDP
  764. msg = self.serv.recv(len(MSG))
  765. self.assertEqual(msg, MSG)
  766. def _testSendtoAndRecv(self):
  767. self.cli.sendto(MSG, 0, (HOST, self.port))
  768. def testRecvFrom(self):
  769. # Testing recvfrom() over UDP
  770. msg, addr = self.serv.recvfrom(len(MSG))
  771. self.assertEqual(msg, MSG)
  772. def _testRecvFrom(self):
  773. self.cli.sendto(MSG, 0, (HOST, self.port))
  774. def testRecvFromNegative(self):
  775. # Negative lengths passed to recvfrom should give ValueError.
  776. self.assertRaises(ValueError, self.serv.recvfrom, -1)
  777. def _testRecvFromNegative(self):
  778. self.cli.sendto(MSG, 0, (HOST, self.port))
  779. @unittest.skipUnless(thread, 'Threading required for this test.')
  780. class TCPCloserTest(ThreadedTCPSocketTest):
  781. def testClose(self):
  782. conn, addr = self.serv.accept()
  783. conn.close()
  784. sd = self.cli
  785. read, write, err = select.select([sd], [], [], 1.0)
  786. self.assertEqual(read, [sd])
  787. self.assertEqual(sd.recv(1), b'')
  788. # Calling close() many times should be safe.
  789. conn.close()
  790. conn.close()
  791. def _testClose(self):
  792. self.cli.connect((HOST, self.port))
  793. time.sleep(1.0)
  794. @unittest.skipUnless(thread, 'Threading required for this test.')
  795. class BasicSocketPairTest(SocketPairTest):
  796. def __init__(self, methodName='runTest'):
  797. SocketPairTest.__init__(self, methodName=methodName)
  798. def _check_defaults(self, sock):
  799. self.assertIsInstance(sock, socket.socket)
  800. if hasattr(socket, 'AF_UNIX'):
  801. self.assertEqual(sock.family, socket.AF_UNIX)
  802. else:
  803. self.assertEqual(sock.family, socket.AF_INET)
  804. self.assertEqual(sock.type, socket.SOCK_STREAM)
  805. self.assertEqual(sock.proto, 0)
  806. def _testDefaults(self):
  807. self._check_defaults(self.cli)
  808. def testDefaults(self):
  809. self._check_defaults(self.serv)
  810. def testRecv(self):
  811. msg = self.serv.recv(1024)
  812. self.assertEqual(msg, MSG)
  813. def _testRecv(self):
  814. self.cli.send(MSG)
  815. def testSend(self):
  816. self.serv.send(MSG)
  817. def _testSend(self):
  818. msg = self.cli.recv(1024)
  819. self.assertEqual(msg, MSG)
  820. @unittest.skipUnless(thread, 'Threading required for this test.')
  821. class NonBlockingTCPTests(ThreadedTCPSocketTest):
  822. def __init__(self, methodName='runTest'):
  823. ThreadedTCPSocketTest.__init__(self, methodName=methodName)
  824. def testSetBlocking(self):
  825. # Testing whether set blocking works
  826. self.serv.setblocking(0)
  827. start = time.time()
  828. try:
  829. self.serv.accept()
  830. except socket.error:
  831. pass
  832. end = time.time()
  833. self.assertTrue((end - start) < 1.0, "Error setting non-blocking mode.")
  834. def _testSetBlocking(self):
  835. pass
  836. if hasattr(socket, "SOCK_NONBLOCK"):
  837. def testInitNonBlocking(self):
  838. v = linux_version()
  839. if v < (2, 6, 28):
  840. self.skipTest("Linux kernel 2.6.28 or higher required, not %s"
  841. % ".".join(map(str, v)))
  842. # reinit server socket
  843. self.serv.close()
  844. self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM |
  845. socket.SOCK_NONBLOCK)
  846. self.port = support.bind_port(self.serv)
  847. self.serv.listen(1)
  848. # actual testing
  849. start = time.time()
  850. try:
  851. self.serv.accept()
  852. except socket.error:
  853. pass
  854. end = time.time()
  855. self.assertTrue((end - start) < 1.0, "Error creating with non-blocking mode.")
  856. def _testInitNonBlocking(self):
  857. pass
  858. def testInheritFlags(self):
  859. # Issue #7995: when calling accept() on a listening socket with a
  860. # timeout, the resulting socket should not be non-blocking.
  861. self.serv.settimeout(10)
  862. try:
  863. conn, addr = self.serv.accept()
  864. message = conn.recv(len(MSG))
  865. finally:
  866. conn.close()
  867. self.serv.settimeout(None)
  868. def _testInheritFlags(self):
  869. time.sleep(0.1)
  870. self.cli.connect((HOST, self.port))
  871. time.sleep(0.5)
  872. self.cli.send(MSG)
  873. def testAccept(self):
  874. # Testing non-blocking accept
  875. self.serv.setblocking(0)
  876. try:
  877. conn, addr = self.serv.accept()
  878. except socket.error:
  879. pass
  880. else:
  881. self.fail("Error trying to do non-blocking accept.")
  882. read, write, err = select.select([self.serv], [], [])
  883. if self.serv in read:
  884. conn, addr = self.serv.accept()
  885. conn.close()
  886. else:
  887. self.fail("Error trying to do accept after select.")
  888. def _testAccept(self):
  889. time.sleep(0.1)
  890. self.cli.connect((HOST, self.port))
  891. def testConnect(self):
  892. # Testing non-blocking connect
  893. conn, addr = self.serv.accept()
  894. conn.close()
  895. def _testConnect(self):
  896. self.cli.settimeout(10)
  897. self.cli.connect((HOST, self.port))
  898. def testRecv(self):
  899. # Testing non-blocking recv
  900. conn, addr = self.serv.accept()
  901. conn.setblocking(0)
  902. try:
  903. msg = conn.recv(len(MSG))
  904. except socket.error:
  905. pass
  906. else:
  907. self.fail("Error trying to do non-blocking recv.")
  908. read, write, err = select.select([conn], [], [])
  909. if conn in read:
  910. msg = conn.recv(len(MSG))
  911. conn.close()
  912. self.assertEqual(msg, MSG)
  913. else:
  914. self.fail("Error during select call to non-blocking socket.")
  915. def _testRecv(self):
  916. self.cli.connect((HOST, self.port))
  917. time.sleep(0.1)
  918. self.cli.send(MSG)
  919. @unittest.skipUnless(thread, 'Threading required for this test.')
  920. class FileObjectClassTestCase(SocketConnectedTest):
  921. """Unit tests for the object returned by socket.makefile()
  922. self.read_file is the io object returned by makefile() on
  923. the client connection. You can read from this file to
  924. get output from the server.
  925. self.write_file is the io object returned by makefile() on the
  926. server connection. You can write to this file to send output
  927. to the client.
  928. """
  929. bufsize = -1 # Use default buffer size
  930. encoding = 'utf-8'
  931. errors = 'strict'
  932. newline = None
  933. read_mode = 'rb'
  934. read_msg = MSG
  935. write_mode = 'wb'
  936. write_msg = MSG
  937. def __init__(self, methodName='runTest'):
  938. SocketConnectedTest.__init__(self, methodName=methodName)
  939. def setUp(self):
  940. self.evt1, self.evt2, self.serv_finished, self.cli_finished = [
  941. threading.Event() for i in range(4)]
  942. SocketConnectedTest.setUp(self)
  943. self.read_file = self.cli_conn.makefile(
  944. self.read_mode, self.bufsize,
  945. encoding = self.encoding,
  946. errors = self.errors,
  947. newline = self.newline)
  948. def tearDown(self):
  949. self.serv_finished.set()
  950. self.read_file.close()
  951. self.assertTrue(self.read_file.closed)
  952. self.read_file = None
  953. SocketConnectedTest.tearDown(self)
  954. def clientSetUp(self):
  955. SocketConnectedTest.clientSetUp(self)
  956. self.write_file = self.serv_conn.makefile(
  957. self.write_mode, self.bufsize,
  958. encoding = self.encoding,
  959. errors = self.errors,
  960. newline = self.newline)
  961. def clientTearDown(self):
  962. self.cli_finished.set()
  963. self.write_file.close()
  964. self.assertTrue(self.write_file.closed)
  965. self.write_file = None
  966. SocketConnectedTest.clientTearDown(self)
  967. def testReadAfterTimeout(self):
  968. # Issue #7322: A file object must disallow further reads
  969. # after a timeout has occurred.
  970. self.cli_conn.settimeout(1)
  971. self.read_file.read(3)
  972. # First read raises a timeout
  973. self.assertRaises(socket.timeout, self.read_file.read, 1)
  974. # Second read is disallowed
  975. with self.assertRaises(IOError) as ctx:
  976. self.read_file.read(1)
  977. self.assertIn("cannot read from timed out object", str(ctx.exception))
  978. def _testReadAfterTimeout(self):
  979. self.write_file.write(self.write_msg[0:3])
  980. self.write_file.flush()
  981. self.serv_finished.wait()
  982. def testSmallRead(self):
  983. # Performing small file read test
  984. first_seg = self.read_file.read(len(self.read_msg)-3)
  985. second_seg = self.read_file.read(3)
  986. msg = first_seg + second_seg
  987. self.assertEqual(msg, self.read_msg)
  988. def _testSmallRead(self):
  989. self.write_file.write(self.write_msg)
  990. self.write_file.flush()
  991. def testFullRead(self):
  992. # read until EOF
  993. msg = self.read_file.read()
  994. self.assertEqual(msg, self.read_msg)
  995. def _testFullRead(self):
  996. self.write_file.write(self.write_msg)
  997. self.write_file.close()
  998. def testUnbufferedRead(self):
  999. # Performing unbuffered file read test
  1000. buf = type(self.read_msg)()
  1001. while 1:
  1002. char = self.read_file.read(1)
  1003. if not char:
  1004. break
  1005. buf += char
  1006. self.assertEqual(buf, self.read_msg)
  1007. def _testUnbufferedRead(self):
  1008. self.write_file.write(self.write_msg)
  1009. self.write_file.flush()
  1010. def testReadline(self):
  1011. # Performing file readline test
  1012. line = self.read_file.readline()
  1013. self.assertEqual(line, self.read_msg)
  1014. def _testReadline(self):
  1015. self.write_file.write(self.write_msg)
  1016. self.write_file.flush()
  1017. def testCloseAfterMakefile(self):
  1018. # The file returned by makefile should keep the socket open.
  1019. self.cli_conn.close()
  1020. # read until EOF
  1021. msg = self.read_file.read()
  1022. self.assertEqual(msg, self.read_msg)
  1023. def _testCloseAfterMakefile(self):
  1024. self.write_file.write(self.write_msg)
  1025. self.write_file.flush()
  1026. def testMakefileAfterMakefileClose(self):
  1027. self.read_file.close()
  1028. msg = self.cli_conn.recv(len(MSG))
  1029. if isinstance(self.read_msg, str):
  1030. msg = msg.decode()
  1031. self.assertEqual(msg, self.read_msg)
  1032. def _testMakefileAfterMakefileClose(self):
  1033. self.write_file.write(self.write_msg)
  1034. self.write_file.flush()
  1035. def testClosedAttr(self):
  1036. self.assertTrue(not self.read_file.closed)
  1037. def _testClosedAttr(self):
  1038. self.assertTrue(not self.write_file.closed)
  1039. def testAttributes(self):
  1040. self.assertEqual(self.read_file.mode, self.read_mode)
  1041. self.assertEqual(self.read_file.name, self.cli_conn.fileno())
  1042. def _testAttributes(self):
  1043. self.assertEqual(self.write_file.mode, self.write_mode)
  1044. self.assertEqual(self.write_file.name, self.serv_conn.fileno())
  1045. def testRealClose(self):
  1046. self.read_file.close()
  1047. self.assertRaises(ValueError, self.read_file.fileno)
  1048. self.cli_conn.close()
  1049. self.assertRaises(socket.error, self.cli_conn.getsockname)
  1050. def _testRealClose(self):
  1051. pass
  1052. class FileObjectInterruptedTestCase(unittest.TestCase):
  1053. """Test that the file object correctly handles EINTR internally."""
  1054. class MockSocket(object):
  1055. def __init__(self, recv_funcs=()):
  1056. # A generator that returns callables that we'll call for each
  1057. # call to recv().
  1058. self._recv_step = iter(recv_funcs)
  1059. def recv_into(self, buffer):
  1060. data = next(self._recv_step)()
  1061. assert len(buffer) >= len(data)
  1062. buffer[:len(data)] = data
  1063. return len(data)
  1064. def _decref_socketios(self):
  1065. pass
  1066. def _textiowrap_for_test(self, buffering=-1):
  1067. raw = socket.SocketIO(self, "r")
  1068. if buffering < 0:
  1069. buffering = io.DEFAULT_BUFFER_SIZE
  1070. if buffering == 0:
  1071. return raw
  1072. buffer = io.BufferedReader(raw, buffering)
  1073. text = io.TextIOWrapper(buffer, None, None)
  1074. text.mode = "rb"
  1075. return text
  1076. @staticmethod
  1077. def _raise_eintr():
  1078. raise socket.error(errno.EINTR)
  1079. def _textiowrap_mock_socket(self, mock, buffering=-1):
  1080. raw = socket.SocketIO(mock, "r")
  1081. if buffering < 0:
  1082. buffering = io.DEFAULT_BUFFER_SIZE
  1083. if buffering == 0:
  1084. return raw
  1085. buffer = io.BufferedReader(raw, buffering)
  1086. text = io.TextIOWrapper(buffer, None, None)
  1087. text.mode = "rb"
  1088. return text
  1089. def _test_readline(self, size=-1, buffering=-1):
  1090. mock_sock = self.MockSocket(recv_funcs=[
  1091. lambda : b"This is the first line\nAnd the sec",
  1092. self._raise_eintr,
  1093. lambda : b"ond line is here\n",
  1094. lambda : b"",
  1095. lambda : b"", # XXX(gps): io library does an extra EOF read
  1096. ])
  1097. fo = mock_sock._textiowrap_for_test(buffering=buffering)
  1098. self.assertEqual(fo.readline(size), "This is the first line\n")
  1099. self.assertEqual(fo.readline(size), "And the second line is here\n")
  1100. def _test_read(self, size=-1, buffering=-1):
  1101. mock_sock = self.MockSocket(recv_funcs=[
  1102. lambda : b"This is the first line\nAnd the sec",
  1103. self._raise_eintr,
  1104. lambda : b"ond line is here\n",
  1105. lambda : b"",
  1106. lambda : b"", # XXX(gps): io library does an extra EOF read
  1107. ])
  1108. expecting = (b"This is the first line\n"
  1109. b"And the second line is here\n")
  1110. fo = mock_sock._textiowrap_for_test(buffering=buffering)
  1111. if buffering == 0:
  1112. data = b''
  1113. else:
  1114. data = ''
  1115. expecting = expecting.decode('utf-8')
  1116. while len(data) != len(expecting):
  1117. part = fo.read(size)
  1118. if not part:
  1119. break
  1120. data += part
  1121. self.assertEqual(data, expecting)
  1122. def test_default(self):
  1123. self._test_readline()
  1124. self._test_readline(size=100)
  1125. self._test_read()
  1126. self._test_read(size=100)
  1127. def test_with_1k_buffer(self):
  1128. self._test_readline(buffering=1024)
  1129. self._test_readline(size=100, buffering=1024)
  1130. self._test_read(buffering=1024)
  1131. self._test_read(size=100, buffering=1024)
  1132. def _test_readline_no_buffer(self, size=-1):
  1133. mock_sock = self.MockSocket(recv_funcs=[
  1134. lambda : b"a",
  1135. lambda : b"\n",
  1136. lambda : b"B",
  1137. self._raise_eintr,
  1138. lambda : b"b",
  1139. lambda : b"",
  1140. ])
  1141. fo = mock_sock._textiowrap_for_test(buffering=0)
  1142. self.assertEqual(fo.readline(size), b"a\n")
  1143. self.assertEqual(fo.readline(size), b"Bb")
  1144. def test_no_buffer(self):
  1145. self._test_readline_no_buffer()
  1146. self._test_readline_no_buffer(size=4)
  1147. self._test_read(buffering=0)
  1148. self._test_read(size=100, buffering=0)
  1149. class UnbufferedFileObjectClassTestCase(FileObjectClassTestCase):
  1150. """Repeat the tests from FileObjectClassTestCase with bufsize==0.
  1151. In this case (and in this case only), it should be possible to
  1152. create a file object, read a line from it, create another file
  1153. object, read another line from it, without loss of data in the
  1154. first file object's buffer. Note that http.client relies on this
  1155. when reading multiple requests from the same socket."""
  1156. bufsize = 0 # Use unbuffered mode
  1157. def testUnbufferedReadline(self):
  1158. # Read a line, create a new file object, read another line with it
  1159. line = self.read_file.readline() # first line
  1160. self.assertEqual(line, b"A. " + self.write_msg) # first line
  1161. self.read_file = self.cli_conn.makefile('rb', 0)
  1162. line = self.read_file.readline() # second line
  1163. self.assertEqual(line, b"B. " + self.write_msg) # second line
  1164. def _testUnbufferedReadline(self):
  1165. self.write_file.write(b"A. " + self.write_msg)
  1166. self.write_file.write(b"B. " + self.write_msg)
  1167. self.write_file.flush()
  1168. def testMakefileClose(self):
  1169. # The file returned by makefile should keep the socket open...
  1170. self.cli_conn.close()
  1171. msg = self.cli_conn.recv(1024)
  1172. self.assertEqual(msg, self.read_msg)
  1173. # ...until the file is itself closed
  1174. self.read_file.close()
  1175. self.assertRaises(socket.error, self.cli_conn.recv, 1024)
  1176. def _testMakefileClose(self):
  1177. self.write_file.write(self.write_msg)
  1178. self.write_file.flush()
  1179. def testMakefileCloseSocketDestroy(self):
  1180. refcount_before = sys.getrefcount(self.cli_conn)
  1181. self.read_file.close()
  1182. refcount_after = sys.getrefcount(self.cli_conn)
  1183. self.assertEqual(refcount_before - 1, refcount_after)
  1184. def _testMakefileCloseSocketDestroy(self):
  1185. pass
  1186. # Non-blocking ops
  1187. # NOTE: to set `read_file` as non-blocking, we must call
  1188. # `cli_conn.setblocking` and vice-versa (see setUp / clientSetUp).
  1189. def testSmallReadNonBlocking(self):
  1190. self.cli_conn.setblocking(False)
  1191. self.assertEqual(self.read_file.readinto(bytearray(10)), None)
  1192. self.assertEqual(self.read_file.read(len(self.read_msg) - 3), None)
  1193. self.evt1.set()
  1194. self.evt2.wait(1.0)
  1195. first_seg = self.read_file.read(len(self.read_msg) - 3)
  1196. buf = bytearray(10)
  1197. n = self.read_file.readinto(buf)
  1198. self.assertEqual(n, 3)
  1199. msg = first_seg + buf[:n]
  1200. self.assertEqual(msg, self.read_msg)
  1201. self.assertEqual(self.read_file.readinto(bytearray(16)), None)
  1202. self.assertEqual(self.read_

Large files files are truncated, but you can click here to view the full file