def testRecvfromTimeout(self):
        # Test recvfrom() timeout
        _timeout = 2
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.settimeout(_timeout)
        # Prevent "Address already in use" socket exceptions
        test_support.bind_port(self.sock, self.localhost)

        _t1 = time.time()
        self.assertRaises(socket.error, self.sock.recvfrom, 8192)
        _t2 = time.time()

        _delta = abs(_t1 - _t2)
        self.assertTrue(_delta < _timeout + self.fuzz,
                     "timeout (%g) is %g seconds more than expected (%g)"
                     %(_delta, self.fuzz, _timeout))

    def test_send(self):
        self.evt = threading.Event()
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.settimeout(3)
        self.port = test_support.bind_port(self.sock)

        cap = StringIO()
        args = (self.evt, cap, self.sock)
        threading.Thread(target=capture_server, args=args).start()

        # wait a little longer for the server to initialize (it sometimes
        # refuses connections on slow machines without this wait)
        time.sleep(0.2)

        data = "Suppose there isn't a 16-ton weight?"
        d = dispatcherwithsend_noread()
        d.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        d.connect((HOST, self.port))

        # give time for socket to connect
        time.sleep(0.1)

        d.send(data)
        d.send(data)
        d.send("\n")

        n = 1000
        while d.out_buffer and n > 0:
            asyncore.poll()
            n -= 1

        self.evt.wait()

        self.assertEqual(cap.getvalue(), data * 2)

 def setUp(self):
     self.evt = threading.Event()
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.sock.settimeout(3)
     self.port = test_support.bind_port(self.sock)
     threading.Thread(target=self.server, args=(self.evt,self.sock)).start()
     time.sleep(.1)

        def test_handshake_timeout(self):
            # Issue #5103: SSL handshake must respect the socket timeout
            server = socket.socket(socket.AF_INET)
            host = "127.0.0.1"
            port = test_support.bind_port(server)
            started = threading.Event()
            finish = False

            def serve():
                server.listen(5)
                started.set()
                conns = []
                while not finish:
                    r, w, e = select.select([server], [], [], 0.1)
                    if server in r:
                        # Let the socket hang around rather than having
                        # it closed by garbage collection.
                        conns.append(server.accept()[0])

            t = threading.Thread(target=serve)
            t.start()
            started.wait()

            try:
                try:
                    c = socket.socket(socket.AF_INET)
                    c.settimeout(0.2)
                    c.connect((host, port))
                    # Will attempt handshake and time out
                    try:
                        ssl.wrap_socket(c)
                    except ssl.SSLError, e:
                        self.assertTrue("timed out" in str(e), str(e))
                    else:
                        self.fail("SSLError wasn't raised")

 def listener():
     s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     PORT[0] = test_support.bind_port(s, '', PORT[0])
     s.listen(5)
     s.accept()
     del s
     thread.exit()

    def testAcceptTimeout(self):
        # Test accept() timeout
        _timeout = 2
        self.sock.settimeout(_timeout)
        # Prevent "Address already in use" socket exceptions
        test_support.bind_port(self.sock, self.localhost)
        self.sock.listen(5)

        _t1 = time.time()
        self.assertRaises(socket.error, self.sock.accept)
        _t2 = time.time()

        _delta = abs(_t1 - _t2)
        self.assertTrue(_delta < _timeout + self.fuzz,
                     "timeout (%g) is %g seconds more than expected (%g)"
                     %(_delta, self.fuzz, _timeout))

        def __init__(self, certificate, ssl_version=None,
                     certreqs=None, cacerts=None, expect_bad_connects=False,
                     chatty=True, connectionchatty=False, starttls_server=False,
                     wrap_accepting_socket=False):

            if ssl_version is None:
                ssl_version = ssl.PROTOCOL_TLSv1
            if certreqs is None:
                certreqs = ssl.CERT_NONE
            self.certificate = certificate
            self.protocol = ssl_version
            self.certreqs = certreqs
            self.cacerts = cacerts
            self.expect_bad_connects = expect_bad_connects
            self.chatty = chatty
            self.connectionchatty = connectionchatty
            self.starttls_server = starttls_server
            self.sock = socket.socket()
            self.flag = None
            if wrap_accepting_socket:
                self.sock = ssl.wrap_socket(self.sock, server_side=True,
                                            certfile=self.certificate,
                                            cert_reqs = self.certreqs,
                                            ca_certs = self.cacerts,
                                            ssl_version = self.protocol)
                if test_support.verbose and self.chatty:
                    sys.stdout.write(' server:  wrapped server socket as %s\n' % str(self.sock))
            self.port = test_support.bind_port(self.sock)
            self.active = False
            threading.Thread.__init__(self)
            self.daemon = True

 def listener():
     s = socket.socket()
     PORT[0] = test_support.bind_port(s, '', PORT[0])
     s.listen(5)
     listener_ready.set()
     s1, addr = s.accept()
     s1.close()
     listener_gone.set()

 def __init__(self, event):
     threading.Thread.__init__(self)
     self.event = event
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.port = test_support.bind_port(self.sock)
     # This will be set if the client wants us to wait before echoing data
     # back.
     self.start_resend_event = None

def _read_setUp(self):
    self.evt = threading.Event()
    self.dataq = Queue.Queue()
    self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    self.sock.settimeout(10)
    self.port = test_support.bind_port(self.sock)
    self.thread = threading.Thread(target=server, args=(self.evt,self.sock, self.dataq))
    self.thread.start()
    self.evt.wait()

 def setUp(self):
     self.evt = threading.Event()
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.sock.settimeout(60)  # Safety net. Look issue 11812
     self.port = test_support.bind_port(self.sock)
     self.thread = threading.Thread(target=self.server, args=(self.evt, self.sock))
     self.thread.setDaemon(True)
     self.thread.start()
     self.evt.wait()

 def setUp(self):
     self.evt = threading.Event()
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.sock.settimeout(3)
     self.port = test_support.bind_port(self.sock)
     threading.Thread(target=self.server, args=(self.evt,self.sock)).start()
     # Wait for the server to be ready.
     self.evt.wait()
     self.evt.clear()
     ftplib.FTP.port = self.port

    def setUp(self):
        self.old_stdout = sys.stdout
        self.output = StringIO.StringIO()
        sys.stdout = self.output

        self.evt = threading.Event()
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.settimeout(15)
        self.port = test_support.bind_port(self.sock)
        servargs = (self.evt, self.respdata, self.sock)
        threading.Thread(target=server, args=servargs).start()
        self.evt.wait()
        self.evt.clear()

 def run(self):
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     global PORT
     PORT = test_support.bind_port(sock, HOST, PORT)
     sock.listen(1)
     conn, client = sock.accept()
     buffer = ""
     while "\n" not in buffer:
         data = conn.recv(1)
         if not data:
             break
         buffer = buffer + data
     while buffer:
         n = conn.send(buffer)
         buffer = buffer[n:]
     conn.close()
     sock.close()

        def test_rude_shutdown(self):
            """A brutal shutdown of an SSL server should raise an IOError
            in the client when attempting handshake.
            """
            listener_ready = threading.Event()
            listener_gone = threading.Event()

            s = socket.socket()
            port = test_support.bind_port(s, HOST)

            # `listener` runs in a thread.  It sits in an accept() until
            # the main thread connects.  Then it rudely closes the socket,
            # and sets Event `listener_gone` to let the main thread know
            # the socket is gone.
            def listener():
                s.listen(5)
                listener_ready.set()
                s.accept()
                s.close()
                listener_gone.set()

            def connector():
                listener_ready.wait()
                c = socket.socket()
                c.connect((HOST, port))
                listener_gone.wait()
                try:
                    ssl_sock = ssl.wrap_socket(c)
                except IOError:
                    pass
                else:
                    self.fail("connecting to closed SSL socket should have failed")

            t = threading.Thread(target=listener)
            t.start()
            try:
                connector()
            finally:
                t.join()

 def setUp(self):
     self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     self.serv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     global PORT
     PORT = test_support.bind_port(self.serv, HOST, PORT)

 def setUp(self):
     self.serv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     TimeoutTest.PORT = test_support.bind_port(self.serv)
     self.serv.listen(5)

 def setUp(self):
     self.serv = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     self.port = test_support.bind_port(self.serv)

 def __init__(self, event):
     threading.Thread.__init__(self)
     self.event = event
     self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     self.port = test_support.bind_port(self.sock)

 def __init__(self, certfile):
     self.certfile = certfile
     asyncore.dispatcher.__init__(self)
     self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
     self.port = test_support.bind_port(self.socket)
     self.listen(5)