PageRenderTime 62ms CodeModel.GetById 21ms RepoModel.GetById 1ms app.codeStats 0ms

/lib-python/2.7/test/test_socket.py

https://bitbucket.org/SeanTater/pypy-bugfix-st
Python | 1631 lines | 1437 code | 97 blank | 97 comment | 67 complexity | 7b9b0fda3585ca1c0490be649aae2dd4 MD5 | raw file

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

  1. #!/usr/bin/env python
  2. import unittest
  3. from test import test_support
  4. import errno
  5. import socket
  6. import select
  7. import time
  8. import traceback
  9. import Queue
  10. import sys
  11. import os
  12. import array
  13. import contextlib
  14. from weakref import proxy
  15. import signal
  16. import math
  17. def try_address(host, port=0, family=socket.AF_INET):
  18. """Try to bind a socket on the given host:port and return True
  19. if that has been possible."""
  20. try:
  21. sock = socket.socket(family, socket.SOCK_STREAM)
  22. sock.bind((host, port))
  23. except (socket.error, socket.gaierror):
  24. return False
  25. else:
  26. sock.close()
  27. return True
  28. HOST = test_support.HOST
  29. MSG = b'Michael Gilfix was here\n'
  30. SUPPORTS_IPV6 = socket.has_ipv6 and try_address('::1', family=socket.AF_INET6)
  31. try:
  32. import thread
  33. import threading
  34. except ImportError:
  35. thread = None
  36. threading = None
  37. HOST = test_support.HOST
  38. MSG = 'Michael Gilfix was here\n'
  39. class SocketTCPTest(unittest.TestCase):
  40. def setUp(self):
  41. self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  42. self.port = test_support.bind_port(self.serv)
  43. self.serv.listen(1)
  44. def tearDown(self):
  45. self.serv.close()
  46. self.serv = None
  47. class SocketUDPTest(unittest.TestCase):
  48. def setUp(self):
  49. self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  50. self.port = test_support.bind_port(self.serv)
  51. def tearDown(self):
  52. self.serv.close()
  53. self.serv = None
  54. class ThreadableTest:
  55. """Threadable Test class
  56. The ThreadableTest class makes it easy to create a threaded
  57. client/server pair from an existing unit test. To create a
  58. new threaded class from an existing unit test, use multiple
  59. inheritance:
  60. class NewClass (OldClass, ThreadableTest):
  61. pass
  62. This class defines two new fixture functions with obvious
  63. purposes for overriding:
  64. clientSetUp ()
  65. clientTearDown ()
  66. Any new test functions within the class must then define
  67. tests in pairs, where the test name is preceeded with a
  68. '_' to indicate the client portion of the test. Ex:
  69. def testFoo(self):
  70. # Server portion
  71. def _testFoo(self):
  72. # Client portion
  73. Any exceptions raised by the clients during their tests
  74. are caught and transferred to the main thread to alert
  75. the testing framework.
  76. Note, the server setup function cannot call any blocking
  77. functions that rely on the client thread during setup,
  78. unless serverExplicitReady() is called just before
  79. the blocking call (such as in setting up a client/server
  80. connection and performing the accept() in setUp().
  81. """
  82. def __init__(self):
  83. # Swap the true setup function
  84. self.__setUp = self.setUp
  85. self.__tearDown = self.tearDown
  86. self.setUp = self._setUp
  87. self.tearDown = self._tearDown
  88. def serverExplicitReady(self):
  89. """This method allows the server to explicitly indicate that
  90. it wants the client thread to proceed. This is useful if the
  91. server is about to execute a blocking routine that is
  92. dependent upon the client thread during its setup routine."""
  93. self.server_ready.set()
  94. def _setUp(self):
  95. self.server_ready = threading.Event()
  96. self.client_ready = threading.Event()
  97. self.done = threading.Event()
  98. self.queue = Queue.Queue(1)
  99. # Do some munging to start the client test.
  100. methodname = self.id()
  101. i = methodname.rfind('.')
  102. methodname = methodname[i+1:]
  103. test_method = getattr(self, '_' + methodname)
  104. self.client_thread = thread.start_new_thread(
  105. self.clientRun, (test_method,))
  106. self.__setUp()
  107. if not self.server_ready.is_set():
  108. self.server_ready.set()
  109. self.client_ready.wait()
  110. def _tearDown(self):
  111. self.__tearDown()
  112. self.done.wait()
  113. if not self.queue.empty():
  114. msg = self.queue.get()
  115. self.fail(msg)
  116. def clientRun(self, test_func):
  117. self.server_ready.wait()
  118. self.clientSetUp()
  119. self.client_ready.set()
  120. if not callable(test_func):
  121. raise TypeError("test_func must be a callable function.")
  122. try:
  123. test_func()
  124. except Exception, strerror:
  125. self.queue.put(strerror)
  126. self.clientTearDown()
  127. def clientSetUp(self):
  128. raise NotImplementedError("clientSetUp must be implemented.")
  129. def clientTearDown(self):
  130. self.done.set()
  131. thread.exit()
  132. class ThreadedTCPSocketTest(SocketTCPTest, ThreadableTest):
  133. def __init__(self, methodName='runTest'):
  134. SocketTCPTest.__init__(self, methodName=methodName)
  135. ThreadableTest.__init__(self)
  136. def clientSetUp(self):
  137. self.cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  138. def clientTearDown(self):
  139. self.cli.close()
  140. self.cli = None
  141. ThreadableTest.clientTearDown(self)
  142. class ThreadedUDPSocketTest(SocketUDPTest, ThreadableTest):
  143. def __init__(self, methodName='runTest'):
  144. SocketUDPTest.__init__(self, methodName=methodName)
  145. ThreadableTest.__init__(self)
  146. def clientSetUp(self):
  147. self.cli = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  148. def clientTearDown(self):
  149. self.cli.close()
  150. self.cli = None
  151. ThreadableTest.clientTearDown(self)
  152. class SocketConnectedTest(ThreadedTCPSocketTest):
  153. def __init__(self, methodName='runTest'):
  154. ThreadedTCPSocketTest.__init__(self, methodName=methodName)
  155. def setUp(self):
  156. ThreadedTCPSocketTest.setUp(self)
  157. # Indicate explicitly we're ready for the client thread to
  158. # proceed and then perform the blocking call to accept
  159. self.serverExplicitReady()
  160. conn, addr = self.serv.accept()
  161. self.cli_conn = conn
  162. def tearDown(self):
  163. self.cli_conn.close()
  164. self.cli_conn = None
  165. ThreadedTCPSocketTest.tearDown(self)
  166. def clientSetUp(self):
  167. ThreadedTCPSocketTest.clientSetUp(self)
  168. self.cli.connect((HOST, self.port))
  169. self.serv_conn = self.cli
  170. def clientTearDown(self):
  171. self.serv_conn.close()
  172. self.serv_conn = None
  173. ThreadedTCPSocketTest.clientTearDown(self)
  174. class SocketPairTest(unittest.TestCase, ThreadableTest):
  175. def __init__(self, methodName='runTest'):
  176. unittest.TestCase.__init__(self, methodName=methodName)
  177. ThreadableTest.__init__(self)
  178. def setUp(self):
  179. self.serv, self.cli = socket.socketpair()
  180. def tearDown(self):
  181. self.serv.close()
  182. self.serv = None
  183. def clientSetUp(self):
  184. pass
  185. def clientTearDown(self):
  186. self.cli.close()
  187. self.cli = None
  188. ThreadableTest.clientTearDown(self)
  189. #######################################################################
  190. ## Begin Tests
  191. class GeneralModuleTests(unittest.TestCase):
  192. def test_weakref(self):
  193. s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  194. p = proxy(s)
  195. self.assertEqual(p.fileno(), s.fileno())
  196. s.close()
  197. s = None
  198. test_support.gc_collect()
  199. try:
  200. p.fileno()
  201. except ReferenceError:
  202. pass
  203. else:
  204. self.fail('Socket proxy still exists')
  205. def testSocketError(self):
  206. # Testing socket module exceptions
  207. def raise_error(*args, **kwargs):
  208. raise socket.error
  209. def raise_herror(*args, **kwargs):
  210. raise socket.herror
  211. def raise_gaierror(*args, **kwargs):
  212. raise socket.gaierror
  213. self.assertRaises(socket.error, raise_error,
  214. "Error raising socket exception.")
  215. self.assertRaises(socket.error, raise_herror,
  216. "Error raising socket exception.")
  217. self.assertRaises(socket.error, raise_gaierror,
  218. "Error raising socket exception.")
  219. def testSendtoErrors(self):
  220. # Testing that sendto doens't masks failures. See #10169.
  221. s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  222. self.addCleanup(s.close)
  223. s.bind(('', 0))
  224. sockname = s.getsockname()
  225. # 2 args
  226. with self.assertRaises(UnicodeEncodeError):
  227. s.sendto(u'\u2620', sockname)
  228. with self.assertRaises(TypeError) as cm:
  229. s.sendto(5j, sockname)
  230. self.assertIn('complex', str(cm.exception))
  231. with self.assertRaises(TypeError) as cm:
  232. s.sendto('foo', None)
  233. self.assertIn('NoneType', str(cm.exception))
  234. # 3 args
  235. with self.assertRaises(UnicodeEncodeError):
  236. s.sendto(u'\u2620', 0, sockname)
  237. with self.assertRaises(TypeError) as cm:
  238. s.sendto(5j, 0, sockname)
  239. self.assertIn('complex', str(cm.exception))
  240. with self.assertRaises(TypeError) as cm:
  241. s.sendto('foo', 0, None)
  242. if test_support.check_impl_detail():
  243. self.assertIn('not NoneType', str(cm.exception))
  244. with self.assertRaises(TypeError) as cm:
  245. s.sendto('foo', 'bar', sockname)
  246. self.assertIn('integer', str(cm.exception))
  247. with self.assertRaises(TypeError) as cm:
  248. s.sendto('foo', None, None)
  249. if test_support.check_impl_detail():
  250. self.assertIn('an integer is required', str(cm.exception))
  251. # wrong number of args
  252. with self.assertRaises(TypeError) as cm:
  253. s.sendto('foo')
  254. self.assertIn(' given)', str(cm.exception))
  255. with self.assertRaises(TypeError) as cm:
  256. s.sendto('foo', 0, sockname, 4)
  257. self.assertIn(' given)', str(cm.exception))
  258. def testCrucialConstants(self):
  259. # Testing for mission critical constants
  260. socket.AF_INET
  261. socket.SOCK_STREAM
  262. socket.SOCK_DGRAM
  263. socket.SOCK_RAW
  264. socket.SOCK_RDM
  265. socket.SOCK_SEQPACKET
  266. socket.SOL_SOCKET
  267. socket.SO_REUSEADDR
  268. def testHostnameRes(self):
  269. # Testing hostname resolution mechanisms
  270. hostname = socket.gethostname()
  271. try:
  272. ip = socket.gethostbyname(hostname)
  273. except socket.error:
  274. # Probably name lookup wasn't set up right; skip this test
  275. return
  276. self.assertTrue(ip.find('.') >= 0, "Error resolving host to ip.")
  277. try:
  278. hname, aliases, ipaddrs = socket.gethostbyaddr(ip)
  279. except socket.error:
  280. # Probably a similar problem as above; skip this test
  281. return
  282. all_host_names = [hostname, hname] + aliases
  283. fqhn = socket.getfqdn(ip)
  284. if not fqhn in all_host_names:
  285. self.fail("Error testing host resolution mechanisms. (fqdn: %s, all: %s)" % (fqhn, repr(all_host_names)))
  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. self.assertEqual(sys.getrefcount(__name__), orig,
  295. "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 = (1L<<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, 1L<<34)
  315. def testNtoHErrors(self):
  316. good_values = [ 1, 2, 3, 1L, 2L, 3L ]
  317. bad_values = [ -1, -2, -3, -1L, -2L, -3L ]
  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, ValueError), socket.ntohl, k)
  325. self.assertRaises((OverflowError, ValueError), socket.ntohs, k)
  326. self.assertRaises((OverflowError, ValueError), socket.htonl, k)
  327. self.assertRaises((OverflowError, ValueError), 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, ValueError), socket.getservbyport, -1)
  367. self.assertRaises((OverflowError, ValueError), 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('\x00'*4, socket.inet_aton('0.0.0.0'))
  397. self.assertEqual('\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('\x00\x00\x00\x00', f('0.0.0.0'))
  404. self.assertEqual('\xff\x00\xff\x00', f('255.0.255.0'))
  405. self.assertEqual('\xaa\xaa\xaa\xaa', f('170.170.170.170'))
  406. self.assertEqual('\x01\x02\x03\x04', f('1.2.3.4'))
  407. self.assertEqual('\xff\xff\xff\xff', f('255.255.255.255'))
  408. self.assertEqual('\x00\x00\x00\x00', g('0.0.0.0'))
  409. self.assertEqual('\xff\x00\xff\x00', g('255.0.255.0'))
  410. self.assertEqual('\xaa\xaa\xaa\xaa', g('170.170.170.170'))
  411. self.assertEqual('\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('\x00' * 16, f('::'))
  423. self.assertEqual('\x00' * 16, f('0::0'))
  424. self.assertEqual('\x00\x01' + '\x00' * 14, f('1::'))
  425. self.assertEqual(
  426. '\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('\x01\x00\x01\x00'))
  435. self.assertEqual('170.85.170.85', f('\xaa\x55\xaa\x55'))
  436. self.assertEqual('255.255.255.255', f('\xff\xff\xff\xff'))
  437. self.assertEqual('1.2.3.4', f('\x01\x02\x03\x04'))
  438. self.assertEqual('1.0.1.0', g('\x01\x00\x01\x00'))
  439. self.assertEqual('170.85.170.85', g('\xaa\x55\xaa\x55'))
  440. self.assertEqual('255.255.255.255', g('\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('\x00' * 16))
  452. self.assertEqual('::1', f('\x00' * 15 + '\x01'))
  453. self.assertEqual(
  454. 'aef:b01:506:1001:ffff:9997:55:170',
  455. f('\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, "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, ValueError), sock.bind, (host, big_port))
  521. self.assertRaises((OverflowError, ValueError), 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. def check_sendall_interrupted(self, with_timeout):
  574. # socketpair() is not stricly required, but it makes things easier.
  575. if not hasattr(signal, 'alarm') or not hasattr(socket, 'socketpair'):
  576. self.skipTest("signal.alarm and socket.socketpair required for this test")
  577. # Our signal handlers clobber the C errno by calling a math function
  578. # with an invalid domain value.
  579. def ok_handler(*args):
  580. self.assertRaises(ValueError, math.acosh, 0)
  581. def raising_handler(*args):
  582. self.assertRaises(ValueError, math.acosh, 0)
  583. 1 // 0
  584. c, s = socket.socketpair()
  585. old_alarm = signal.signal(signal.SIGALRM, raising_handler)
  586. try:
  587. if with_timeout:
  588. # Just above the one second minimum for signal.alarm
  589. c.settimeout(1.5)
  590. with self.assertRaises(ZeroDivisionError):
  591. signal.alarm(1)
  592. c.sendall(b"x" * (1024**2))
  593. if with_timeout:
  594. signal.signal(signal.SIGALRM, ok_handler)
  595. signal.alarm(1)
  596. self.assertRaises(socket.timeout, c.sendall, b"x" * (1024**2))
  597. finally:
  598. signal.signal(signal.SIGALRM, old_alarm)
  599. c.close()
  600. s.close()
  601. def test_sendall_interrupted(self):
  602. self.check_sendall_interrupted(False)
  603. def test_sendall_interrupted_with_timeout(self):
  604. self.check_sendall_interrupted(True)
  605. def testListenBacklog0(self):
  606. srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  607. srv.bind((HOST, 0))
  608. # backlog = 0
  609. srv.listen(0)
  610. srv.close()
  611. @unittest.skipUnless(SUPPORTS_IPV6, 'IPv6 required for this test.')
  612. def test_flowinfo(self):
  613. self.assertRaises(OverflowError, socket.getnameinfo,
  614. ('::1',0, 0xffffffff), 0)
  615. s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
  616. try:
  617. self.assertRaises(OverflowError, s.bind, ('::1', 0, -10))
  618. finally:
  619. s.close()
  620. @unittest.skipUnless(thread, 'Threading required for this test.')
  621. class BasicTCPTest(SocketConnectedTest):
  622. def __init__(self, methodName='runTest'):
  623. SocketConnectedTest.__init__(self, methodName=methodName)
  624. def testRecv(self):
  625. # Testing large receive over TCP
  626. msg = self.cli_conn.recv(1024)
  627. self.assertEqual(msg, MSG)
  628. def _testRecv(self):
  629. self.serv_conn.send(MSG)
  630. def testOverFlowRecv(self):
  631. # Testing receive in chunks over TCP
  632. seg1 = self.cli_conn.recv(len(MSG) - 3)
  633. seg2 = self.cli_conn.recv(1024)
  634. msg = seg1 + seg2
  635. self.assertEqual(msg, MSG)
  636. def _testOverFlowRecv(self):
  637. self.serv_conn.send(MSG)
  638. def testRecvFrom(self):
  639. # Testing large recvfrom() over TCP
  640. msg, addr = self.cli_conn.recvfrom(1024)
  641. self.assertEqual(msg, MSG)
  642. def _testRecvFrom(self):
  643. self.serv_conn.send(MSG)
  644. def testOverFlowRecvFrom(self):
  645. # Testing recvfrom() in chunks over TCP
  646. seg1, addr = self.cli_conn.recvfrom(len(MSG)-3)
  647. seg2, addr = self.cli_conn.recvfrom(1024)
  648. msg = seg1 + seg2
  649. self.assertEqual(msg, MSG)
  650. def _testOverFlowRecvFrom(self):
  651. self.serv_conn.send(MSG)
  652. def testSendAll(self):
  653. # Testing sendall() with a 2048 byte string over TCP
  654. msg = ''
  655. while 1:
  656. read = self.cli_conn.recv(1024)
  657. if not read:
  658. break
  659. msg += read
  660. self.assertEqual(msg, 'f' * 2048)
  661. def _testSendAll(self):
  662. big_chunk = 'f' * 2048
  663. self.serv_conn.sendall(big_chunk)
  664. def testFromFd(self):
  665. # Testing fromfd()
  666. if not hasattr(socket, "fromfd"):
  667. return # On Windows, this doesn't exist
  668. fd = self.cli_conn.fileno()
  669. sock = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
  670. self.addCleanup(sock.close)
  671. msg = sock.recv(1024)
  672. self.assertEqual(msg, MSG)
  673. def _testFromFd(self):
  674. self.serv_conn.send(MSG)
  675. def testDup(self):
  676. # Testing dup()
  677. sock = self.cli_conn.dup()
  678. self.addCleanup(sock.close)
  679. msg = sock.recv(1024)
  680. self.assertEqual(msg, MSG)
  681. def _testDup(self):
  682. self.serv_conn.send(MSG)
  683. def testShutdown(self):
  684. # Testing shutdown()
  685. msg = self.cli_conn.recv(1024)
  686. self.assertEqual(msg, MSG)
  687. # wait for _testShutdown to finish: on OS X, when the server
  688. # closes the connection the client also becomes disconnected,
  689. # and the client's shutdown call will fail. (Issue #4397.)
  690. self.done.wait()
  691. def _testShutdown(self):
  692. self.serv_conn.send(MSG)
  693. self.serv_conn.shutdown(2)
  694. @unittest.skipUnless(thread, 'Threading required for this test.')
  695. class BasicUDPTest(ThreadedUDPSocketTest):
  696. def __init__(self, methodName='runTest'):
  697. ThreadedUDPSocketTest.__init__(self, methodName=methodName)
  698. def testSendtoAndRecv(self):
  699. # Testing sendto() and Recv() over UDP
  700. msg = self.serv.recv(len(MSG))
  701. self.assertEqual(msg, MSG)
  702. def _testSendtoAndRecv(self):
  703. self.cli.sendto(MSG, 0, (HOST, self.port))
  704. def testRecvFrom(self):
  705. # Testing recvfrom() over UDP
  706. msg, addr = self.serv.recvfrom(len(MSG))
  707. self.assertEqual(msg, MSG)
  708. def _testRecvFrom(self):
  709. self.cli.sendto(MSG, 0, (HOST, self.port))
  710. def testRecvFromNegative(self):
  711. # Negative lengths passed to recvfrom should give ValueError.
  712. self.assertRaises(ValueError, self.serv.recvfrom, -1)
  713. def _testRecvFromNegative(self):
  714. self.cli.sendto(MSG, 0, (HOST, self.port))
  715. @unittest.skipUnless(thread, 'Threading required for this test.')
  716. class TCPCloserTest(ThreadedTCPSocketTest):
  717. def testClose(self):
  718. conn, addr = self.serv.accept()
  719. conn.close()
  720. sd = self.cli
  721. read, write, err = select.select([sd], [], [], 1.0)
  722. self.assertEqual(read, [sd])
  723. self.assertEqual(sd.recv(1), '')
  724. def _testClose(self):
  725. self.cli.connect((HOST, self.port))
  726. time.sleep(1.0)
  727. @unittest.skipUnless(thread, 'Threading required for this test.')
  728. class BasicSocketPairTest(SocketPairTest):
  729. def __init__(self, methodName='runTest'):
  730. SocketPairTest.__init__(self, methodName=methodName)
  731. def testRecv(self):
  732. msg = self.serv.recv(1024)
  733. self.assertEqual(msg, MSG)
  734. def _testRecv(self):
  735. self.cli.send(MSG)
  736. def testSend(self):
  737. self.serv.send(MSG)
  738. def _testSend(self):
  739. msg = self.cli.recv(1024)
  740. self.assertEqual(msg, MSG)
  741. @unittest.skipUnless(thread, 'Threading required for this test.')
  742. class NonBlockingTCPTests(ThreadedTCPSocketTest):
  743. def __init__(self, methodName='runTest'):
  744. ThreadedTCPSocketTest.__init__(self, methodName=methodName)
  745. def testSetBlocking(self):
  746. # Testing whether set blocking works
  747. self.serv.setblocking(0)
  748. start = time.time()
  749. try:
  750. self.serv.accept()
  751. except socket.error:
  752. pass
  753. end = time.time()
  754. self.assertTrue((end - start) < 1.0, "Error setting non-blocking mode.")
  755. def _testSetBlocking(self):
  756. pass
  757. def testAccept(self):
  758. # Testing non-blocking accept
  759. self.serv.setblocking(0)
  760. try:
  761. conn, addr = self.serv.accept()
  762. except socket.error:
  763. pass
  764. else:
  765. self.fail("Error trying to do non-blocking accept.")
  766. read, write, err = select.select([self.serv], [], [])
  767. if self.serv in read:
  768. conn, addr = self.serv.accept()
  769. conn.close()
  770. else:
  771. self.fail("Error trying to do accept after select.")
  772. def _testAccept(self):
  773. time.sleep(0.1)
  774. self.cli.connect((HOST, self.port))
  775. def testConnect(self):
  776. # Testing non-blocking connect
  777. conn, addr = self.serv.accept()
  778. conn.close()
  779. def _testConnect(self):
  780. self.cli.settimeout(10)
  781. self.cli.connect((HOST, self.port))
  782. def testRecv(self):
  783. # Testing non-blocking recv
  784. conn, addr = self.serv.accept()
  785. conn.setblocking(0)
  786. try:
  787. msg = conn.recv(len(MSG))
  788. except socket.error:
  789. pass
  790. else:
  791. self.fail("Error trying to do non-blocking recv.")
  792. read, write, err = select.select([conn], [], [])
  793. if conn in read:
  794. msg = conn.recv(len(MSG))
  795. conn.close()
  796. self.assertEqual(msg, MSG)
  797. else:
  798. self.fail("Error during select call to non-blocking socket.")
  799. def _testRecv(self):
  800. self.cli.connect((HOST, self.port))
  801. time.sleep(0.1)
  802. self.cli.send(MSG)
  803. @unittest.skipUnless(thread, 'Threading required for this test.')
  804. class FileObjectClassTestCase(SocketConnectedTest):
  805. bufsize = -1 # Use default buffer size
  806. def __init__(self, methodName='runTest'):
  807. SocketConnectedTest.__init__(self, methodName=methodName)
  808. def setUp(self):
  809. SocketConnectedTest.setUp(self)
  810. self.serv_file = self.cli_conn.makefile('rb', self.bufsize)
  811. def tearDown(self):
  812. self.serv_file.close()
  813. self.assertTrue(self.serv_file.closed)
  814. self.serv_file = None
  815. SocketConnectedTest.tearDown(self)
  816. def clientSetUp(self):
  817. SocketConnectedTest.clientSetUp(self)
  818. self.cli_file = self.serv_conn.makefile('wb')
  819. def clientTearDown(self):
  820. self.cli_file.close()
  821. self.assertTrue(self.cli_file.closed)
  822. self.cli_file = None
  823. SocketConnectedTest.clientTearDown(self)
  824. def testSmallRead(self):
  825. # Performing small file read test
  826. first_seg = self.serv_file.read(len(MSG)-3)
  827. second_seg = self.serv_file.read(3)
  828. msg = first_seg + second_seg
  829. self.assertEqual(msg, MSG)
  830. def _testSmallRead(self):
  831. self.cli_file.write(MSG)
  832. self.cli_file.flush()
  833. def testFullRead(self):
  834. # read until EOF
  835. msg = self.serv_file.read()
  836. self.assertEqual(msg, MSG)
  837. def _testFullRead(self):
  838. self.cli_file.write(MSG)
  839. self.cli_file.close()
  840. def testUnbufferedRead(self):
  841. # Performing unbuffered file read test
  842. buf = ''
  843. while 1:
  844. char = self.serv_file.read(1)
  845. if not char:
  846. break
  847. buf += char
  848. self.assertEqual(buf, MSG)
  849. def _testUnbufferedRead(self):
  850. self.cli_file.write(MSG)
  851. self.cli_file.flush()
  852. def testReadline(self):
  853. # Performing file readline test
  854. line = self.serv_file.readline()
  855. self.assertEqual(line, MSG)
  856. def _testReadline(self):
  857. self.cli_file.write(MSG)
  858. self.cli_file.flush()
  859. def testReadlineAfterRead(self):
  860. a_baloo_is = self.serv_file.read(len("A baloo is"))
  861. self.assertEqual("A baloo is", a_baloo_is)
  862. _a_bear = self.serv_file.read(len(" a bear"))
  863. self.assertEqual(" a bear", _a_bear)
  864. line = self.serv_file.readline()
  865. self.assertEqual("\n", line)
  866. line = self.serv_file.readline()
  867. self.assertEqual("A BALOO IS A BEAR.\n", line)
  868. line = self.serv_file.readline()
  869. self.assertEqual(MSG, line)
  870. def _testReadlineAfterRead(self):
  871. self.cli_file.write("A baloo is a bear\n")
  872. self.cli_file.write("A BALOO IS A BEAR.\n")
  873. self.cli_file.write(MSG)
  874. self.cli_file.flush()
  875. def testReadlineAfterReadNoNewline(self):
  876. end_of_ = self.serv_file.read(len("End Of "))
  877. self.assertEqual("End Of ", end_of_)
  878. line = self.serv_file.readline()
  879. self.assertEqual("Line", line)
  880. def _testReadlineAfterReadNoNewline(self):
  881. self.cli_file.write("End Of Line")
  882. def testClosedAttr(self):
  883. self.assertTrue(not self.serv_file.closed)
  884. def _testClosedAttr(self):
  885. self.assertTrue(not self.cli_file.closed)
  886. class FileObjectInterruptedTestCase(unittest.TestCase):
  887. """Test that the file object correctly handles EINTR internally."""
  888. class MockSocket(object):
  889. def __init__(self, recv_funcs=()):
  890. # A generator that returns callables that we'll call for each
  891. # call to recv().
  892. self._recv_step = iter(recv_funcs)
  893. def recv(self, size):
  894. return self._recv_step.next()()
  895. @staticmethod
  896. def _raise_eintr():
  897. raise socket.error(errno.EINTR)
  898. def _test_readline(self, size=-1, **kwargs):
  899. mock_sock = self.MockSocket(recv_funcs=[
  900. lambda : "This is the first line\nAnd the sec",
  901. self._raise_eintr,
  902. lambda : "ond line is here\n",
  903. lambda : "",
  904. ])
  905. fo = socket._fileobject(mock_sock, **kwargs)
  906. self.assertEqual(fo.readline(size), "This is the first line\n")
  907. self.assertEqual(fo.readline(size), "And the second line is here\n")
  908. def _test_read(self, size=-1, **kwargs):
  909. mock_sock = self.MockSocket(recv_funcs=[
  910. lambda : "This is the first line\nAnd the sec",
  911. self._raise_eintr,
  912. lambda : "ond line is here\n",
  913. lambda : "",
  914. ])
  915. fo = socket._fileobject(mock_sock, **kwargs)
  916. self.assertEqual(fo.read(size), "This is the first line\n"
  917. "And the second line is here\n")
  918. def test_default(self):
  919. self._test_readline()
  920. self._test_readline(size=100)
  921. self._test_read()
  922. self._test_read(size=100)
  923. def test_with_1k_buffer(self):
  924. self._test_readline(bufsize=1024)
  925. self._test_readline(size=100, bufsize=1024)
  926. self._test_read(bufsize=1024)
  927. self._test_read(size=100, bufsize=1024)
  928. def _test_readline_no_buffer(self, size=-1):
  929. mock_sock = self.MockSocket(recv_funcs=[
  930. lambda : "aa",
  931. lambda : "\n",
  932. lambda : "BB",
  933. self._raise_eintr,
  934. lambda : "bb",
  935. lambda : "",
  936. ])
  937. fo = socket._fileobject(mock_sock, bufsize=0)
  938. self.assertEqual(fo.readline(size), "aa\n")
  939. self.assertEqual(fo.readline(size), "BBbb")
  940. def test_no_buffer(self):
  941. self._test_readline_no_buffer()
  942. self._test_readline_no_buffer(size=4)
  943. self._test_read(bufsize=0)
  944. self._test_read(size=100, bufsize=0)
  945. class UnbufferedFileObjectClassTestCase(FileObjectClassTestCase):
  946. """Repeat the tests from FileObjectClassTestCase with bufsize==0.
  947. In this case (and in this case only), it should be possible to
  948. create a file object, read a line from it, create another file
  949. object, read another line from it, without loss of data in the
  950. first file object's buffer. Note that httplib relies on this
  951. when reading multiple requests from the same socket."""
  952. bufsize = 0 # Use unbuffered mode
  953. def testUnbufferedReadline(self):
  954. # Read a line, create a new file object, read another line with it
  955. line = self.serv_file.readline() # first line
  956. self.assertEqual(line, "A. " + MSG) # first line
  957. self.serv_file = self.cli_conn.makefile('rb', 0)
  958. line = self.serv_file.readline() # second line
  959. self.assertEqual(line, "B. " + MSG) # second line
  960. def _testUnbufferedReadline(self):
  961. self.cli_file.write("A. " + MSG)
  962. self.cli_file.write("B. " + MSG)
  963. self.cli_file.flush()
  964. class LineBufferedFileObjectClassTestCase(FileObjectClassTestCase):
  965. bufsize = 1 # Default-buffered for reading; line-buffered for writing
  966. class SmallBufferedFileObjectClassTestCase(FileObjectClassTestCase):
  967. bufsize = 2 # Exercise the buffering code
  968. class NetworkConnectionTest(object):
  969. """Prove network connection."""
  970. def clientSetUp(self):
  971. # We're inherited below by BasicTCPTest2, which also inherits
  972. # BasicTCPTest, which defines self.port referenced below.
  973. self.cli = socket.create_connection((HOST, self.port))
  974. self.serv_conn = self.cli
  975. class BasicTCPTest2(NetworkConnectionTest, BasicTCPTest):
  976. """Tests that NetworkConnection does not break existing TCP functionality.
  977. """
  978. class NetworkConnectionNoServer(unittest.TestCase):
  979. class MockSocket(socket.socket):
  980. def connect(self, *args):
  981. raise socket.timeout('timed out')
  982. @contextlib.contextmanager
  983. def mocked_socket_module(self):
  984. """Return a socket which times out on connect"""
  985. old_socket = socket.socket
  986. socket.socket = self.MockSocket
  987. try:
  988. yield
  989. finally:
  990. socket.socket = old_socket
  991. def test_connect(self):
  992. port = test_support.find_unused_port()
  993. cli = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  994. self.addCleanup(cli.close)
  995. with self.assertRaises(socket.error) as cm:
  996. cli.connect((HOST, port))
  997. self.assertEqual(cm.exception.errno, errno.ECONNREFUSED)
  998. def test_create_connection(self):
  999. # Issue #9792: errors raised by create_connection() should have
  1000. # a proper errno attribute.
  1001. port = test_support.find_unused_port()
  1002. with self.assertRaises(socket.error) as cm:
  1003. socket.create_connection((HOST, port))
  1004. self.assertEqual(cm.exception.errno, errno.ECONNREFUSED)
  1005. def test_create_connection_timeout(self):
  1006. # Issue #9792: create_connection() should not recast timeout errors
  1007. # as generic socket errors.
  1008. with self.mocked_socket_module():
  1009. with self.assertRaises(socket.timeout):
  1010. socket.create_connection((HOST, 1234))
  1011. @unittest.skipUnless(thread, 'Threading required for this test.')
  1012. class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest):
  1013. def __init__(self, methodName='runTest'):
  1014. SocketTCPTest.__init__(self, methodName=methodName)
  1015. ThreadableTest.__init__(self)
  1016. def clientSetUp(self):
  1017. self.source_port = test_support.find_unused_port()
  1018. def clientTearDown(self):
  1019. self.cli.close()
  1020. self.cli = None
  1021. ThreadableTest.clientTearDown(self)
  1022. def _justAccept(self):
  1023. conn, addr = self.serv.accept()
  1024. conn.close()
  1025. testFamily = _justAccept
  1026. def _testFamily(self):
  1027. self.cli = socket.create_connection((HOST, self.port), timeout=30)
  1028. self.addCleanup(self.cli.close)
  1029. self.assertEqual(self.cli.family, 2)
  1030. testSourceAddress = _justAccept
  1031. def _testSourceAddress(self):
  1032. self.cli = socket.create_connection((HOST, self.port), timeout=30,
  1033. source_address=('', self.source_port))
  1034. self.addCleanup(self.cli.close)
  1035. self.assertEqual(self.cli.getsockname()[1], self.source_port)
  1036. # The port number being used is sufficient to show that the bind()
  1037. # call happened.
  1038. testTimeoutDefault = _justAccept
  1039. def _testTimeoutDefault(self):
  1040. # passing no explicit timeout uses socket's global default
  1041. self.assertTrue(socket.getdefaulttimeout() is None)
  1042. socket.setdefaulttimeout(42)
  1043. try:
  1044. self.cli = socket.create_connection((HOST, self.port))
  1045. self.addCleanup(self.cli.close)
  1046. finally:
  1047. socket.setdefaulttimeout(None)
  1048. self.assertEqual(self.cli.gettimeout(), 42)
  1049. testTimeoutNone = _justAccept
  1050. def _testTimeoutNone(self):
  1051. # None timeout means the same as sock.settimeout(None)
  1052. self.assertTrue(socket.getdefaulttimeout() is None)
  1053. socket.setdefaulttimeout(30)
  1054. try:
  1055. self.cli = socket.create_connection((HOST, self.port), timeout=None)
  1056. self.addCleanup(self.cli.close)
  1057. finally:
  1058. socket.setdefaulttimeout(None)
  1059. self.assertEqual(self.cli.gettimeout(), None)
  1060. testTimeoutValueNamed = _justAccept
  1061. def _testTimeoutValueNamed(self):
  1062. self.cli = socket.create_connection((HOST, self.port), timeout=30)
  1063. self.assertEqual(self.cli.gettimeout(), 30)
  1064. testTimeoutValueNonamed = _justAccept
  1065. def _testTimeoutValueNonamed(self):
  1066. self.cli = socket.create_connection((HOST, self.port), 30)
  1067. self.addCleanup(self.cli.close)
  1068. self.assertEqual(self.cli.gettimeout(), 30)
  1069. @unittest.skipUnless(thread, 'Threading required for this test.')
  1070. class NetworkConnectionBehaviourTest(SocketTCPTest, ThreadableTest):
  1071. def __init__(self, methodName='runTest'):
  1072. SocketTCPTest.__init__(self, methodName=methodName)
  1073. ThreadableTest.__init__(self)
  1074. def clientSetUp(self):
  1075. pass
  1076. def clientTearDown(self):
  1077. self.cli.close()
  1078. self.cli = None
  1079. ThreadableTest.clientTearDown(self)
  1080. def testInsideTimeout(self):
  1081. conn, addr = self.serv.accept()
  1082. self.addCleanup(conn.close)
  1083. time.sleep(3)
  1084. conn.send("done!")
  1085. testOutsideTimeout = testInsideTimeout
  1086. def _testInsideTimeout(self):
  1087. self.cli = sock = socket.create_connection((HOST, self.port))
  1088. data = sock.recv(5)
  1089. self.assertEqual(data, "done!")
  1090. def _testOutsideTimeout(self):
  1091. self.cli = sock = socket.create_connection((HOST, self.port), timeout=1)
  1092. self.assertRaises(socket.timeout, lambda: sock.recv(5))
  1093. class Urllib2FileobjectTest(unittest.TestCase):
  1094. # urllib2.HTTPHandler has "borrowed" socket._fileobject, and requires that
  1095. # it close the socket if the close c'tor argument is true
  1096. def testClose(self):
  1097. class MockSocket:
  1098. closed = False
  1099. def flush(self): pass
  1100. def close(self): self.closed = True
  1101. def _decref_socketios(self): pass
  1102. # must not close unless we request it: the original use of _fileobject
  1103. # by module socket requires that the underlying socket not be closed until
  1104. # the _socketobject that created the _fileobject is closed
  1105. s = MockSocket()
  1106. f = socket._fileobject(s)
  1107. f.close()
  1108. self.assertTrue(not s.closed)
  1109. s = MockSocket()
  1110. f = socket._fileobject(s, close=True)
  1111. f.close()
  1112. self.assertTrue(s.closed)
  1113. class TCPTimeoutTest(SocketTCPTest):
  1114. def testTCPTimeout(self):
  1115. def raise_timeout(*args, **kwargs):
  1116. self.serv.settimeout(1.0)
  1117. self.serv.accept()
  1118. self.assertRaises(socket.timeout, raise_timeout,
  1119. "Error generating a timeout exception (TCP)")
  1120. def testTimeoutZero(self):
  1121. ok = False
  1122. try:
  1123. self.serv.settimeout(0.0)
  1124. foo = self.serv.accept()
  1125. except socket.timeout:
  1126. self.fail("caught timeout instead of error (TCP)")
  1127. except socket.error:
  1128. ok = True
  1129. except:
  1130. self.fail("caught unexpected exception (TCP)")
  1131. if not ok:
  1132. self.fail("accept() returned success when we did not expect it")
  1133. def testInterruptedTimeout(self):
  1134. # XXX I don't know how to do this test on MSWindows or any other
  1135. # plaform that doesn't support signal.alarm() or os.kill(), though
  1136. # the bug should have existed on all platforms.
  1137. if not hasattr(signal, "alarm"):
  1138. return # can only test on *nix
  1139. self.serv.settimeout(5.0) # must be longer than alarm
  1140. class Alarm(Exception):
  1141. pass
  1142. def alarm_handler(signal, frame):
  1143. raise Alarm
  1144. old_alarm = signal.signal(signal.SIGALRM, alarm_handler)
  1145. try:
  1146. signal.alarm(2) # POSIX allows alarm to be up to 1 second early
  1147. try:
  1148. foo = self.serv.accept()
  1149. except socket.timeout:
  1150. self.fail("caught timeout instead of Alarm")
  1151. except Alarm:
  1152. pass
  1153. except:
  1154. self.fail("caught other exception instead of Alarm:"
  1155. " %s(%s):\n%s" %
  1156. (sys.exc_info()[:2] + (traceback.format_exc(),)))
  1157. else:
  1158. self.fail("nothing caught")
  1159. finally:
  1160. signal.alarm(0) # shut off alarm
  1161. except Alarm:
  1162. self.fail("got Alarm in wrong place")
  1163. finally:
  1164. # no alarm can be pending. Safe to restore old handler.
  1165. signal.signal(signal.SIGALRM, old_alarm)
  1166. class UDPTimeoutTest(SocketUDPTest):
  1167. def testUDPTimeout(self):
  1168. def raise_timeout(*args, **kwargs):
  1169. self.serv.settimeout(1.0)
  1170. self.serv.recv(1024)
  1171. self.assertRaises(socket.timeout, raise_timeout,
  1172. "Error generating a timeout exception (UDP)")
  1173. def testTimeoutZero(self):
  1174. ok = False
  1175. try:
  1176. self.serv.settimeout(0.0)
  1177. foo = self.serv.recv(1024)
  1178. except socket.timeout:
  1179. self.fail("caught timeout instead of error (UDP)")
  1180. except socket.error:
  1181. ok = True
  1182. except:
  1183. self.fail("caught unexpected exception (UDP)")
  1184. if not ok:
  1185. self.fail("recv() returned success when we did not expect it")
  1186. class TestExceptions(unittest.TestCase):
  1187. def testExceptionTree(self):
  1188. self.assertTrue(issubclass(socket.error, Exception))
  1189. self.assertTrue(issubclass(socket.herror, socket.error))
  1190. self.assertTrue(issubclass(socket.gaierror, socket.error))
  1191. self.assertTrue(issubclass(socket.timeout, socket.error))
  1192. class TestLinuxAbstractNamespace(unittest.TestCase):
  1193. UNIX_PATH_MAX = 10

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