Index: Lib/test/test_timeout.py
===================================================================
RCS file: /cvsroot/python/python/dist/src/Lib/test/test_timeout.py,v
retrieving revision 1.13
diff -u -r1.13 test_timeout.py
--- Lib/test/test_timeout.py	11 Apr 2003 15:14:05 -0000	1.13
+++ Lib/test/test_timeout.py	28 Apr 2003 10:06:38 -0000
@@ -7,6 +7,7 @@
 skip_expected = not test_support.is_resource_enabled('network')
 
 import time
+import errno
 import socket
 
 
@@ -100,88 +101,101 @@
 
     def setUp(self):
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.addr_remote = ('www.google.com', 80)
-        self.addr_local  = ('127.0.0.1', 25339)
+        self.client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.addr_bad_remote = ('www.google.com', 21)
+        self.addr_local = ('127.0.0.1', 0)
 
     def tearDown(self):
         self.sock.close()
+        self.client_sock.close()
+        if not hasattr(self, "time1") or not hasattr(self, "time2"):
+            self.fail("no right exception has been raised")
+        else:
+            delta = abs(self.time1 - self.time2)
+            self.assert_(delta < self.timeout + self.fuzz,
+                         "timeout (%g) is %g seconds more than expected (%g)"
+                         %(delta, self.fuzz, self.timeout))
+
+    def sockOperation(self, count, method, *args):
+        for i in range(count):
+            self.time1 = time.time()
+            try:
+                method(*args)
+            except socket.error, args:
+                # FIXME: 0 raised on Win (see BUG #708927)
+                if args[0] not in [0, errno.EAGAIN, errno.EWOULDBLOCK,
+                    errno.EALREADY]:
+                    raise
+                self.time2 = time.time()
+                break
 
     def testConnectTimeout(self):
         # Test connect() timeout
-        _timeout = 0.001
-        self.sock.settimeout(_timeout)
-
-        _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.sock.connect,
-                self.addr_remote)
-        _t2 = time.time()
-
-        _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + self.fuzz,
-                     "timeout (%g) is %g seconds more than expected (%g)"
-                     %(_delta, self.fuzz, _timeout))
+        self.timeout = 4
+        self.sock.settimeout(self.timeout)
+        self.sockOperation(1, self.sock.connect, self.addr_bad_remote)
 
     def testRecvTimeout(self):
         # Test recv() timeout
-        _timeout = 0.02
-        self.sock.connect(self.addr_remote)
-        self.sock.settimeout(_timeout)
-
-        _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.sock.recv, 1024)
-        _t2 = time.time()
-
-        _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + self.fuzz,
-                     "timeout (%g) is %g seconds more than expected (%g)"
-                     %(_delta, self.fuzz, _timeout))
+        self.timeout = 4
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.settimeout(self.timeout)
+        self.sock.bind(self.addr_local)
+
+        self.sockOperation(1, self.sock.recv, 1024)
 
     def testAcceptTimeout(self):
         # Test accept() timeout
-        _timeout = 2
-        self.sock.settimeout(_timeout)
+        self.timeout = 4
+        self.sock.settimeout(self.timeout)
         self.sock.bind(self.addr_local)
-        self.sock.listen(5)
+        self.sock.listen(1)
 
-        _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.sock.accept)
-        _t2 = time.time()
-
-        _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + self.fuzz,
-                     "timeout (%g) is %g seconds more than expected (%g)"
-                     %(_delta, self.fuzz, _timeout))
+        self.sockOperation(1, self.sock.accept)
 
     def testRecvfromTimeout(self):
         # Test recvfrom() timeout
-        _timeout = 2
+        self.timeout = 4
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self.sock.settimeout(_timeout)
+        self.sock.settimeout(self.timeout)
         self.sock.bind(self.addr_local)
 
-        _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.sock.recvfrom, 8192)
-        _t2 = time.time()
-
-        _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + self.fuzz,
-                     "timeout (%g) is %g seconds more than expected (%g)"
-                     %(_delta, self.fuzz, _timeout))
+        self.sockOperation(1, self.sock.recvfrom, 1024)
 
     def testSend(self):
         # Test send() timeout
-        # couldn't figure out how to test it
-        pass
+        self.timeout = 4
+        self.sock.bind(self.addr_local)
+        self.sock.listen(1)
+
+        self.client_sock.connect(self.sock.getsockname())
+        self.client_sock.settimeout(self.timeout)
+
+        self.sockOperation(100, self.client_sock.send, "X" * 200000)
 
     def testSendto(self):
         # Test sendto() timeout
-        # couldn't figure out how to test it
-        pass
+        self.timeout = 4
+        self.sock.bind(self.addr_local)
+        self.sock.listen(1)
+
+        self.client_sock.connect(self.sock.getsockname())
+        self.client_sock.settimeout(self.timeout)
+
+        # The address argument is ignored since we already connected
+        self.sockOperation(100, self.client_sock.sendto, "X" * 200000,
+            self.sock.getsockname())
 
     def testSendall(self):
         # Test sendall() timeout
-        # couldn't figure out how to test it
-        pass
+        self.timeout = 4
+        self.sock.bind(self.addr_local)
+        self.sock.listen(1)
+
+        self.client_sock.connect(self.sock.getsockname())
+        self.client_sock.settimeout(self.timeout)
+
+        self.sockOperation(100, self.client_sock.sendall, "X" * 200000)
 
 
 def test_main():