def sender (listener):
                (sock, addr) = listener.accept()
                sock = bufsized(sock, size = bufsize)
                sock.sendall(s2b('x') * many_bytes)
                sock.sendall(s2b('y') * second_bytes)

                received.wait()

 def accept_close_late(listener):
     # verify that the makefile and the socket are truly independent
     # by closing the made file and then sending a character
     try:
         conn, addr = listener.accept()
         fd = conn.makefile('w')
         fd.write('hello')
         fd.close()
         conn.send(s2b('\n'))
         conn.close()
         self.assertWriteToClosedFileRaises(fd)
         self.assertRaises(socket.error, conn.send, s2b('b'))
     finally:
         listener.close()

    def test_sendall_timeout(self):
        listener = greenio.GreenSocket(socket.socket())
        listener.bind(('', 0))
        listener.listen(50)

        evt = event.Event()

        def server():
            # accept the connection in another greenlet
            sock, addr = listener.accept()
            evt.wait()

        gt = eventlet.spawn(server)

        addr = listener.getsockname()

        client = greenio.GreenSocket(socket.socket())
        client.settimeout(0.1)
        client.connect(addr)

        try:
            msg = s2b("A") * (8 << 20)

            # want to exceed the size of the OS buffer so it'll block
            client.sendall(msg)
            self.fail("socket.timeout not raised")
        except socket.timeout, e:
            self.assert_(hasattr(e, 'args'))
            self.assertEqual(e.args[0], 'timed out')

    def test_send_timeout(self):
        self.reset_timeout(2)
        listener = bufsized(eventlet.listen(('', 0)))

        evt = event.Event()

        def server():
            # accept the connection in another greenlet
            sock, addr = listener.accept()
            sock = bufsized(sock)
            evt.wait()

        gt = eventlet.spawn(server)

        addr = listener.getsockname()

        client = bufsized(greenio.GreenSocket(socket.socket()))
        client.connect(addr)
        try:
            client.settimeout(0.00001)
            msg = s2b("A") * 100000  # large enough number to overwhelm most buffers

            total_sent = 0
            # want to exceed the size of the OS buffer so it'll block in a
            # single send
            for x in range(10):
                total_sent += client.send(msg)
            self.fail("socket.timeout not raised")
        except socket.timeout, e:
            self.assert_(hasattr(e, 'args'))
            self.assertEqual(e.args[0], 'timed out')

    def test_hub_exceptions (self):
        debug.hub_exceptions(True)
        server = convenience.listen(('0.0.0.0', 0))
        client = convenience.connect(('127.0.0.1', server.getsockname()[1]))
        client_2, addr = server.accept()

        def hurl (s):
            s.recv(1)
            {}[1]  # keyerror

        fake = StringIO()
        orig = sys.stderr
        sys.stderr = fake
        try:
            gt = evy.spawn(hurl, client_2)
            sleep(0)
            client.send(s2b(' '))
            sleep(0)
            # allow the "hurl" greenlet to trigger the KeyError
            # not sure why the extra context switch is needed
            sleep(0)
        finally:
            sys.stderr = orig
            self.assertRaises(KeyError, gt.wait)
            debug.hub_exceptions(False)
            # look for the KeyError exception in the traceback
        self.assert_('KeyError: 1' in fake.getvalue(),
                     "Traceback not in:\n" + fake.getvalue())

        def client ():
            client = sockets.GreenSocket()
            client.connect(('127.0.0.1', listener_port))
            msg = s2b("A") * (10000)  # large enough number to overwhelm most buffers

            # want to exceed the size of the OS buffer so it'll block in a single send
            total_sent = 0
            for x in range(10):
                total_sent += client.send(msg)
            return total_sent

 def server():
     (sock, addr) = listener.accept()
     sock = bufsized(sock)
     send_large_coro = eventlet.spawn(send_large, sock)
     eventlet.sleep(0)
     result = sock.recv(10)
     expected = s2b('hello world')
     while len(result) < len(expected):
         result += sock.recv(10)
     self.assertEquals(result, expected)
     send_large_coro.wait()

 def test_exiting_server(self):
     # tests that the server closes the client sock on handle() exit
     def closer(sock,addr):
         pass
         
     l = eventlet.listen(('localhost', 0))
     gt = eventlet.spawn(eventlet.serve, l, closer)
     client = eventlet.connect(('localhost', l.getsockname()[1]))
     client.sendall(s2b('a'))
     self.assertFalse(client.recv(100))
     gt.kill()

    def test_full_duplex (self):
        large_data = s2b('*') * 10 * min_buf_size()
        listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        listener.bind(('127.0.0.1', 0))
        listener.listen(50)

        def send_large (sock):
            sock.sendall(large_data)

        def read_large (sock):
            result = sock.recv(len(large_data))
            while len(result) < len(large_data):
                result += sock.recv(len(large_data))
                if result == '':
                    break
            self.assertEquals(result, large_data)

        def server ():
            (sock, addr) = listener.accept()
            sock = bufsized(sock)
            send_large_coro = spawn(send_large, sock)
            sleep(0)
            result = sock.recv(10)
            expected = s2b('hello world')
            while len(result) < len(expected) and result is not '':
                result += sock.recv(10)
            self.assertEquals(result, expected)
            send_large_coro.wait()

        server_evt = spawn(server)
        client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client.connect(('127.0.0.1', listener.getsockname()[1]))
        bufsized(client)
        large_evt = spawn(read_large, client)
        sleep(0)
        client.sendall(s2b('hello world'))

        server_evt.wait()
        large_evt.wait()
        client.close()

 def test_excepting_server(self):
     # tests that the server closes the client sock on handle() exception
     def crasher(sock,addr):
         sock.recv(1024)
         0//0
         
     l = eventlet.listen(('localhost', 0))
     gt = eventlet.spawn(eventlet.serve, l, crasher)
     client = eventlet.connect(('localhost', l.getsockname()[1]))
     client.sendall(s2b('a'))
     self.assertRaises(ZeroDivisionError, gt.wait)
     self.assertFalse(client.recv(100))

 def test_excepting_server_already_closed(self):
     # same as above but with explicit clsoe before crash
     def crasher(sock,addr):
         sock.recv(1024)
         sock.close()
         0//0
         
     l = eventlet.listen(('localhost', 0))
     gt = eventlet.spawn(eventlet.serve, l, crasher)
     client = eventlet.connect(('localhost', l.getsockname()[1]))
     client.sendall(s2b('a'))
     self.assertRaises(ZeroDivisionError, gt.wait)
     self.assertFalse(client.recv(100))

    def test_multiple_readers(self, clibufsize=False):
        debug.hub_prevent_multiple_readers(False)
        recvsize = 2 * min_buf_size()
        sendsize = 10 * recvsize

        # test that we can have multiple coroutines reading
        # from the same fd.  We make no guarantees about which one gets which
        # bytes, but they should both get at least some
        def reader(sock, results):
            while True:
                data = sock.recv(recvsize)
                if not data:
                    break
                results.append(data)

        results1 = []
        results2 = []
        listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        listener.bind(('127.0.0.1', 0))
        listener.listen(50)

        def server():
            (sock, addr) = listener.accept()
            sock = bufsized(sock)
            try:
                c1 = eventlet.spawn(reader, sock, results1)
                c2 = eventlet.spawn(reader, sock, results2)
                try:
                    c1.wait()
                    c2.wait()
                finally:
                    c1.kill()
                    c2.kill()
            finally:
                sock.close()

        server_coro = eventlet.spawn(server)
        client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client.connect(('127.0.0.1', listener.getsockname()[1]))
        if clibufsize:
            bufsized(client, size=sendsize)
        else:
            bufsized(client)
        client.sendall(s2b('*') * sendsize)
        client.close()
        server_coro.wait()
        listener.close()
        self.assert_(len(results1) > 0)
        self.assert_(len(results2) > 0)
        debug.hub_prevent_multiple_readers()

        def client():
            pid = os.fork()
            if pid:
                return pid

            client = _orig_sock.socket(socket.AF_INET, socket.SOCK_STREAM)
            client.connect(('127.0.0.1', port))

            bufsized(client, size=sendsize)

            for i in range(sendloops):
                client.sendall(s2b('*') * sendsize)
            client.close()
            os._exit(0)

 def test_client():
     c = eventlet.connect(('localhost', l.getsockname()[1]))
     # verify the client is connected by getting data
     self.assertEquals(s2b('hi'), c.recv(2))
     return c

 def waiter(sock, addr):
     sock.sendall(s2b('hi'))
     evt.wait()