6 from io import DEFAULT_BUFFER_SIZE
9 import socket as _orig_sock
13 from nose.tools import eq_
16 from eventlet import event, greenio, debug
17 from eventlet.hubs import get_hub
18 from eventlet.green import select, socket, time, ssl
19 from eventlet.support import capture_stderr, get_errno, six
23 def bufsized(sock, size=1):
24 """ Resize both send and receive buffers on a socket.
25 Useful for testing trampoline. Returns the socket.
28 >>> sock = bufsized(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
30 sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, size)
31 sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, size)
35 def expect_socket_timeout(function, *args):
38 raise AssertionError("socket.timeout not raised")
39 except socket.timeout as e:
40 assert hasattr(e, 'args')
41 eq_(e.args[0], 'timed out')
45 """Return the minimum buffer size that the platform supports."""
46 test_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
47 test_sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1)
48 return test_sock.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)
51 def using_epoll_hub(_f):
53 return 'epolls' in type(get_hub()).__module__
58 def using_kqueue_hub(_f):
60 return 'kqueue' in type(get_hub()).__module__
65 class TestGreenSocket(tests.LimitedTestCase):
66 def assertWriteToClosedFileRaises(self, fd):
67 if sys.version_info[0] < 3:
68 # 2.x socket._fileobjects are odd: writes don't check
69 # whether the socket is closed or not, and you get an
70 # AttributeError during flush if it is closed
72 self.assertRaises(Exception, fd.flush)
74 # 3.x io write to closed file-like pbject raises ValueError
75 self.assertRaises(ValueError, fd.write, b'a')
77 def test_connect_timeout(self):
78 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
80 gs = greenio.GreenSocket(s)
83 expect_socket_timeout(gs.connect, ('192.0.2.1', 80))
84 except socket.error as e:
85 # unreachable is also a valid outcome
86 if not get_errno(e) in (errno.EHOSTUNREACH, errno.ENETUNREACH):
89 def test_accept_timeout(self):
90 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
95 gs = greenio.GreenSocket(s)
96 expect_socket_timeout(gs.accept)
98 def test_connect_ex_timeout(self):
99 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
101 gs = greenio.GreenSocket(s)
102 e = gs.connect_ex(('192.0.2.1', 80))
103 if e not in (errno.EHOSTUNREACH, errno.ENETUNREACH):
104 self.assertEqual(e, errno.EAGAIN)
106 def test_recv_timeout(self):
107 listener = greenio.GreenSocket(socket.socket())
108 listener.bind(('', 0))
114 # accept the connection in another greenlet
115 sock, addr = listener.accept()
118 gt = eventlet.spawn(server)
120 addr = listener.getsockname()
122 client = greenio.GreenSocket(socket.socket())
123 client.settimeout(0.1)
127 expect_socket_timeout(client.recv, 0)
128 expect_socket_timeout(client.recv, 8192)
133 def test_recvfrom_timeout(self):
134 gs = greenio.GreenSocket(
135 socket.socket(socket.AF_INET, socket.SOCK_DGRAM))
139 expect_socket_timeout(gs.recvfrom, 0)
140 expect_socket_timeout(gs.recvfrom, 8192)
142 def test_recvfrom_into_timeout(self):
143 buf = array.array('B')
145 gs = greenio.GreenSocket(
146 socket.socket(socket.AF_INET, socket.SOCK_DGRAM))
150 expect_socket_timeout(gs.recvfrom_into, buf)
152 def test_recv_into_timeout(self):
153 buf = array.array('B')
155 listener = greenio.GreenSocket(socket.socket())
156 listener.bind(('', 0))
162 # accept the connection in another greenlet
163 sock, addr = listener.accept()
166 gt = eventlet.spawn(server)
168 addr = listener.getsockname()
170 client = greenio.GreenSocket(socket.socket())
171 client.settimeout(0.1)
175 expect_socket_timeout(client.recv_into, buf)
180 def test_send_timeout(self):
181 self.reset_timeout(2)
182 listener = bufsized(eventlet.listen(('', 0)))
187 # accept the connection in another greenlet
188 sock, addr = listener.accept()
189 sock = bufsized(sock)
192 gt = eventlet.spawn(server)
194 addr = listener.getsockname()
196 client = bufsized(greenio.GreenSocket(socket.socket()))
199 client.settimeout(0.00001)
200 msg = b"A" * 100000 # large enough number to overwhelm most buffers
202 # want to exceed the size of the OS buffer so it'll block in a
208 expect_socket_timeout(send)
213 def test_sendall_timeout(self):
214 listener = greenio.GreenSocket(socket.socket())
215 listener.bind(('', 0))
221 # accept the connection in another greenlet
222 sock, addr = listener.accept()
225 gt = eventlet.spawn(server)
227 addr = listener.getsockname()
229 client = greenio.GreenSocket(socket.socket())
230 client.settimeout(0.1)
233 # want to exceed the size of the OS buffer so it'll block
234 msg = b"A" * (8 << 20)
235 expect_socket_timeout(client.sendall, msg)
240 def test_close_with_makefile(self):
241 def accept_close_early(listener):
242 # verify that the makefile and the socket are truly independent
243 # by closing the socket prior to using the made file
245 conn, addr = listener.accept()
246 fd = conn.makefile('wb')
250 self.assertWriteToClosedFileRaises(fd)
251 self.assertRaises(socket.error, conn.send, b'b')
255 def accept_close_late(listener):
256 # verify that the makefile and the socket are truly independent
257 # by closing the made file and then sending a character
259 conn, addr = listener.accept()
260 fd = conn.makefile('wb')
265 self.assertWriteToClosedFileRaises(fd)
266 self.assertRaises(socket.error, conn.send, b'b')
270 def did_it_work(server):
271 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
272 client.connect(('127.0.0.1', server.getsockname()[1]))
273 fd = client.makefile('rb')
275 assert fd.readline() == b'hello\n'
276 assert fd.read() == b''
279 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
280 server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
281 server.bind(('0.0.0.0', 0))
283 killer = eventlet.spawn(accept_close_early, server)
287 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
288 server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
289 server.bind(('0.0.0.0', 0))
291 killer = eventlet.spawn(accept_close_late, server)
295 def test_del_closes_socket(self):
296 def accept_once(listener):
297 # delete/overwrite the original conn
298 # object, only keeping the file object around
299 # closing the file object should close everything
301 conn, addr = listener.accept()
302 conn = conn.makefile('wb')
303 conn.write(b'hello\n')
306 self.assertWriteToClosedFileRaises(conn)
310 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
311 server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
312 server.bind(('127.0.0.1', 0))
314 killer = eventlet.spawn(accept_once, server)
315 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
316 client.connect(('127.0.0.1', server.getsockname()[1]))
317 fd = client.makefile('rb')
319 assert fd.read() == b'hello\n'
320 assert fd.read() == b''
324 def test_full_duplex(self):
325 large_data = b'*' * 10 * min_buf_size()
326 listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
327 listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
328 listener.bind(('127.0.0.1', 0))
332 def send_large(sock):
333 sock.sendall(large_data)
335 def read_large(sock):
336 result = sock.recv(len(large_data))
337 while len(result) < len(large_data):
338 result += sock.recv(len(large_data))
339 self.assertEqual(result, large_data)
342 (sock, addr) = listener.accept()
343 sock = bufsized(sock)
344 send_large_coro = eventlet.spawn(send_large, sock)
346 result = sock.recv(10)
347 expected = b'hello world'
348 while len(result) < len(expected):
349 result += sock.recv(10)
350 self.assertEqual(result, expected)
351 send_large_coro.wait()
353 server_evt = eventlet.spawn(server)
354 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
355 client.connect(('127.0.0.1', listener.getsockname()[1]))
357 large_evt = eventlet.spawn(read_large, client)
359 client.sendall(b'hello world')
364 def test_sendall(self):
365 # test adapted from Marcus Cavanaugh's email
366 # it may legitimately take a while, but will eventually complete
370 def test_sendall_impl(many_bytes):
371 bufsize = max(many_bytes // 15, 2)
373 def sender(listener):
374 (sock, addr) = listener.accept()
375 sock = bufsized(sock, size=bufsize)
376 sock.sendall(b'x' * many_bytes)
377 sock.sendall(b'y' * second_bytes)
379 listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
380 listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
381 listener.bind(("", 0))
383 sender_coro = eventlet.spawn(sender, listener)
384 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
385 client.connect(('127.0.0.1', listener.getsockname()[1]))
386 bufsized(client, size=bufsize)
388 while total < many_bytes:
389 data = client.recv(min(many_bytes - total, many_bytes // 10))
395 while total < second_bytes:
396 data = client.recv(second_bytes)
404 for how_many in (1000, 10000, 100000, 1000000):
405 test_sendall_impl(how_many)
407 def test_wrap_socket(self):
408 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
409 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
410 sock.bind(('127.0.0.1', 0))
412 ssl.wrap_socket(sock)
414 def test_timeout_and_final_write(self):
415 # This test verifies that a write on a socket that we've
416 # stopped listening for doesn't result in an incorrect switch
417 server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
418 server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
419 server.bind(('127.0.0.1', 0))
421 bound_port = server.getsockname()[1]
424 s2, addr = server.accept()
425 wrap_wfile = s2.makefile('wb')
428 wrap_wfile.write(b'hi')
430 evt.send(b'sent via event')
433 eventlet.spawn(sender, evt)
434 # lets the socket enter accept mode, which
435 # is necessary for connect to succeed on windows
438 # try and get some data off of this pipe
439 # but bail before any is sent
440 eventlet.Timeout(0.01)
441 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
442 client.connect(('127.0.0.1', bound_port))
443 wrap_rfile = client.makefile()
446 except eventlet.TimeoutError:
450 self.assertEqual(result, b'sent via event')
454 @tests.skip_with_pyevent
455 def test_raised_multiple_readers(self):
456 debug.hub_prevent_multiple_readers(True)
458 def handle(sock, addr):
461 raise eventlet.StopServe()
463 listener = eventlet.listen(('127.0.0.1', 0))
464 eventlet.spawn(eventlet.serve, listener, handle)
469 s = eventlet.connect(('127.0.0.1', listener.getsockname()[1]))
470 a = eventlet.spawn(reader, s)
472 self.assertRaises(RuntimeError, s.recv, 1)
476 @tests.skip_with_pyevent
477 @tests.skip_if(using_epoll_hub)
478 @tests.skip_if(using_kqueue_hub)
479 def test_closure(self):
480 def spam_to_me(address):
481 sock = eventlet.connect(address)
484 sock.sendall(b'hello world')
485 # Arbitrary delay to not use all available CPU, keeps the test
486 # running quickly and reliably under a second
488 except socket.error as e:
489 if get_errno(e) == errno.EPIPE:
493 server = eventlet.listen(('127.0.0.1', 0))
494 sender = eventlet.spawn(spam_to_me, server.getsockname())
495 client, address = server.accept()
501 data = client.recv(1024)
503 # Arbitrary delay to not use all available CPU, keeps the test
504 # running quickly and reliably under a second
506 except socket.error as e:
507 # we get an EBADF because client is closed in the same process
508 # (but a different greenthread)
509 if get_errno(e) != errno.EBADF:
515 reader = eventlet.spawn(reader)
516 eventlet.spawn_n(closer)
520 def test_invalid_connection(self):
521 # find an unused port by creating a socket then closing it
522 listening_socket = eventlet.listen(('127.0.0.1', 0))
523 port = listening_socket.getsockname()[1]
524 listening_socket.close()
525 self.assertRaises(socket.error, eventlet.connect, ('127.0.0.1', port))
527 def test_zero_timeout_and_back(self):
528 listen = eventlet.listen(('', 0))
529 # Keep reference to server side of socket
530 server = eventlet.spawn(listen.accept)
531 client = eventlet.connect(listen.getsockname())
533 client.settimeout(0.05)
534 # Now must raise socket.timeout
535 self.assertRaises(socket.timeout, client.recv, 1)
538 # Now must raise socket.error with EAGAIN
542 except socket.error as e:
543 assert get_errno(e) == errno.EAGAIN
545 client.settimeout(0.05)
546 # Now socket.timeout again
547 self.assertRaises(socket.timeout, client.recv, 1)
550 def test_default_nonblocking(self):
551 sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
552 flags = fcntl.fcntl(sock1.fd.fileno(), fcntl.F_GETFL)
553 assert flags & os.O_NONBLOCK
555 sock2 = socket.socket(sock1.fd)
556 flags = fcntl.fcntl(sock2.fd.fileno(), fcntl.F_GETFL)
557 assert flags & os.O_NONBLOCK
559 def test_dup_nonblocking(self):
560 sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
561 flags = fcntl.fcntl(sock1.fd.fileno(), fcntl.F_GETFL)
562 assert flags & os.O_NONBLOCK
565 flags = fcntl.fcntl(sock2.fd.fileno(), fcntl.F_GETFL)
566 assert flags & os.O_NONBLOCK
568 def test_skip_nonblocking(self):
569 sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
570 fd = sock1.fd.fileno()
571 flags = fcntl.fcntl(fd, fcntl.F_GETFL)
572 flags = fcntl.fcntl(fd, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
573 assert flags & os.O_NONBLOCK == 0
575 sock2 = socket.socket(sock1.fd, set_nonblocking=False)
576 flags = fcntl.fcntl(sock2.fd.fileno(), fcntl.F_GETFL)
577 assert flags & os.O_NONBLOCK == 0
579 def test_sockopt_interface(self):
580 sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
581 assert sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) == 0
582 assert sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) == b'\000'
583 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
585 def test_socketpair_select(self):
586 # https://github.com/eventlet/eventlet/pull/25
587 s1, s2 = socket.socketpair()
588 assert select.select([], [s1], [], 0) == ([], [s1], [])
589 assert select.select([], [s1], [], 0) == ([], [s1], [])
591 def test_shutdown_safe(self):
592 sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
595 greenio.shutdown_safe(sock)
597 def test_datagram_socket_operations_work(self):
598 receiver = greenio.GreenSocket(socket.AF_INET, socket.SOCK_DGRAM)
599 receiver.bind(('127.0.0.1', 0))
600 address = receiver.getsockname()
602 sender = greenio.GreenSocket(socket.AF_INET, socket.SOCK_DGRAM)
604 # Two ways sendto can be called
605 sender.sendto(b'first', address)
606 sender.sendto(b'second', 0, address)
608 sender_address = ('127.0.0.1', sender.getsockname()[1])
609 eq_(receiver.recvfrom(1024), (b'first', sender_address))
610 eq_(receiver.recvfrom(1024), (b'second', sender_address))
613 def test_get_fileno_of_a_socket_works():
614 class DummySocket(object):
617 assert select.get_fileno(DummySocket()) == 123
620 def test_get_fileno_of_an_int_works():
621 assert select.get_fileno(123) == 123
624 expected_get_fileno_type_error_message = (
625 'Expected int or long, got <%s \'str\'>' % ('type' if six.PY2 else 'class'))
628 def test_get_fileno_of_wrong_type_fails():
630 select.get_fileno('foo')
631 except TypeError as ex:
632 assert str(ex) == expected_get_fileno_type_error_message
634 assert False, 'Expected TypeError not raised'
637 def test_get_fileno_of_a_socket_with_fileno_returning_wrong_type_fails():
638 class DummySocket(object):
642 select.get_fileno(DummySocket())
643 except TypeError as ex:
644 assert str(ex) == expected_get_fileno_type_error_message
646 assert False, 'Expected TypeError not raised'
649 class TestGreenPipe(tests.LimitedTestCase):
650 @tests.skip_on_windows
652 super(self.__class__, self).setUp()
653 self.tempdir = tempfile.mkdtemp('_green_pipe_test')
656 shutil.rmtree(self.tempdir)
657 super(self.__class__, self).tearDown()
661 rf = greenio.GreenPipe(r, 'rb')
662 wf = greenio.GreenPipe(w, 'wb', 0)
664 def sender(f, content):
665 for ch in map(six.int2byte, six.iterbytes(content)):
666 eventlet.sleep(0.0001)
670 one_line = b"12345\n"
671 eventlet.spawn(sender, wf, one_line * 5)
675 self.assertEqual(line, one_line)
676 self.assertEqual(rf.readline(), b'')
678 def test_pipe_read(self):
679 # ensure that 'readline' works properly on GreenPipes when data is not
680 # immediately available (fd is nonblocking, was raising EAGAIN)
681 # also ensures that readline() terminates on '\n' and '\r\n'
684 r = greenio.GreenPipe(r, 'rb')
685 w = greenio.GreenPipe(w, 'wb')
696 gt = eventlet.spawn(writer)
701 self.assertEqual(line, b'line\n')
704 self.assertEqual(line, b'line\r\n')
708 def test_pip_read_until_end(self):
709 # similar to test_pip_read above but reading until eof
712 r = greenio.GreenPipe(r, 'rb')
713 w = greenio.GreenPipe(w, 'wb')
715 w.write(b'c' * DEFAULT_BUFFER_SIZE * 2)
718 buf = r.read() # no chunk size specified; read until end
719 self.assertEqual(len(buf), 2 * DEFAULT_BUFFER_SIZE)
720 self.assertEqual(buf[:3], b'ccc')
722 def test_pipe_read_unbuffered(self):
723 # Ensure that seting the buffer size works properly on GreenPipes,
724 # it used to be ignored on Python 2 and the test would hang on r.readline()
728 r = greenio.GreenPipe(r, 'rb', 0)
729 w = greenio.GreenPipe(w, 'wb', 0)
734 self.assertEqual(line, b'line\n')
738 def test_pipe_writes_large_messages(self):
741 r = greenio.GreenPipe(r, 'rb')
742 w = greenio.GreenPipe(w, 'wb')
744 large_message = b"".join([1024 * six.int2byte(i) for i in range(65)])
747 w.write(large_message)
750 gt = eventlet.spawn(writer)
754 expected = 1024 * six.int2byte(i)
757 "expected=%r..%r, found=%r..%r iter=%d"
758 % (expected[:4], expected[-4:], buf[:4], buf[-4:], i))
761 def test_seek_on_buffered_pipe(self):
762 f = greenio.GreenPipe(self.tempdir + "/TestFile", 'wb+', 1024)
763 self.assertEqual(f.tell(), 0)
765 self.assertEqual(f.tell(), 0)
766 f.write(b'1234567890')
768 self.assertEqual(f.tell(), 10)
771 self.assertEqual(value, b'1')
772 self.assertEqual(f.tell(), 1)
774 self.assertEqual(value, b'2')
775 self.assertEqual(f.tell(), 2)
777 self.assertEqual(f.readline(), b'34567890')
779 self.assertEqual(f.readline(), b'67890')
781 self.assertEqual(f.readline(), b'1234567890')
783 self.assertEqual(f.readline(), b'')
785 def test_truncate(self):
786 f = greenio.GreenPipe(self.tempdir + "/TestFile", 'wb+', 1024)
787 f.write(b'1234567890')
789 self.assertEqual(f.tell(), 9)
792 class TestGreenIoLong(tests.LimitedTestCase):
793 TEST_TIMEOUT = 10 # the test here might take a while depending on the OS
795 @tests.skip_with_pyevent
796 def test_multiple_readers(self):
797 debug.hub_prevent_multiple_readers(False)
798 recvsize = 2 * min_buf_size()
799 sendsize = 10 * recvsize
801 # test that we can have multiple coroutines reading
802 # from the same fd. We make no guarantees about which one gets which
803 # bytes, but they should both get at least some
804 def reader(sock, results):
806 data = sock.recv(recvsize)
813 listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
814 listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
815 listener.bind(('127.0.0.1', 0))
819 (sock, addr) = listener.accept()
820 sock = bufsized(sock)
822 c1 = eventlet.spawn(reader, sock, results1)
823 c2 = eventlet.spawn(reader, sock, results2)
833 server_coro = eventlet.spawn(server)
834 client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
835 client.connect(('127.0.0.1', listener.getsockname()[1]))
836 bufsized(client, size=sendsize)
838 # Split into multiple chunks so that we can wait a little
839 # every iteration which allows both readers to queue and
840 # recv some data when we actually send it.
842 eventlet.sleep(0.001)
843 client.sendall(b'*' * (sendsize // 20))
848 assert len(results1) > 0
849 assert len(results2) > 0
850 debug.hub_prevent_multiple_readers()
853 def test_set_nonblocking():
854 sock = _orig_sock.socket(socket.AF_INET, socket.SOCK_DGRAM)
855 fileno = sock.fileno()
856 orig_flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
857 assert orig_flags & os.O_NONBLOCK == 0
858 greenio.set_nonblocking(sock)
859 new_flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
860 assert new_flags == (orig_flags | os.O_NONBLOCK)
863 def test_socket_del_fails_gracefully_when_not_fully_initialized():
864 # Regression introduced in da87716714689894f23d0db7b003f26d97031e83, reported in:
865 # * GH #137 https://github.com/eventlet/eventlet/issues/137
866 # * https://bugs.launchpad.net/oslo.messaging/+bug/1369999
868 class SocketSubclass(socket.socket):
873 with capture_stderr() as err:
876 assert err.getvalue() == ''
879 def test_double_close_219():
880 tests.run_isolated('greenio_double_close_219.py')
883 def test_partial_write_295():
884 # https://github.com/eventlet/eventlet/issues/295
885 # `socket.makefile('w').writelines()` must send all
886 # despite partial writes by underlying socket
887 listen_socket = eventlet.listen(('localhost', 0))
888 original_accept = listen_socket.accept
891 f = conn.makefile('wb')
893 f.writelines([line] * 10000)
897 connection, address = original_accept()
898 original_send = connection.send
900 def slow_send(b, *args):
902 return original_send(b, *args)
904 connection.send = slow_send
905 eventlet.spawn(talk, connection)
906 return connection, address
908 listen_socket.accept = accept
910 eventlet.spawn(listen_socket.accept)
911 sock = eventlet.connect(listen_socket.getsockname())
912 with eventlet.Timeout(10):
913 bs = sock.makefile('rb').read()
914 assert len(bs) == 21400000
915 assert bs == (b'*' * 21400000)
918 def test_socket_file_read_non_int():
919 listen_socket = eventlet.listen(('localhost', 0))
922 conn, _ = listen_socket.accept()
924 conn.sendall('response')
927 eventlet.spawn(server)
928 sock = eventlet.connect(listen_socket.getsockname())
930 fd = sock.makefile('rwb')
933 with eventlet.Timeout(1):
935 fd.read("This shouldn't work")
941 def test_pipe_context():
942 # ensure using a pipe as a context actually closes it.
944 r = greenio.GreenPipe(r)
945 w = greenio.GreenPipe(w, 'w')
949 assert r.closed and not w.closed
953 assert r.closed and w.closed