Docstring, layout and style tweaking. Increase fuzz to 1 second.

1 files changed, 87 insertions, 90 deletions

diff --git a/Lib/test/test_timeout.py b/Lib/test/test_timeout.py
index db284c8..8a84258 100644
--- a/Lib/test/test_timeout.py
+++ b/Lib/test/test_timeout.py
@@ -8,159 +8,156 @@ import socket
 
 
 class CreationTestCase(unittest.TestCase):
-    """Test Case for socket.gettimeout() and socket.settimeout()"""
+    """Test case for socket.gettimeout() and socket.settimeout()"""
 
     def setUp(self):
-        self.__s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
     def tearDown(self):
-        self.__s.close()
+        self.sock.close()
 
     def testObjectCreation(self):
         "Test Socket creation"
-        self.assertEqual(self.__s.gettimeout(), None,
-            "Timeout socket not default to disable (None)")
+        self.assertEqual(self.sock.gettimeout(), None,
+                         "timeout not disabled by default")
 
     def testFloatReturnValue(self):
-        "Test return value of getter/setter"
-        self.__s.settimeout(7.345)
-        self.assertEqual(self.__s.gettimeout(), 7.345,
-            "settimeout() and gettimeout() return different result")
+        "Test return value of gettimeout()"
+        self.sock.settimeout(7.345)
+        self.assertEqual(self.sock.gettimeout(), 7.345)
 
-        self.__s.settimeout(3)
-        self.assertEqual(self.__s.gettimeout(), 3,
-            "settimeout() and gettimeout() return different result")
+        self.sock.settimeout(3)
+        self.assertEqual(self.sock.gettimeout(), 3)
 
-    def testReturnType(self):
-        "Test return type of getter/setter"
-        self.__s.settimeout(1)
-        self.assertEqual(type(self.__s.gettimeout()), type(1.0),
-            "return type of gettimeout() is not FloatType")
+        self.sock.settimeout(None)
+        self.assertEqual(self.sock.gettimeout(), None)
 
-        self.__s.settimeout(3.9)
-        self.assertEqual(type(self.__s.gettimeout()), type(1.0),
-            "return type of gettimeout() is not FloatType")
+    def testReturnType(self):
+        "Test return type of gettimeout()"
+        self.sock.settimeout(1)
+        self.assertEqual(type(self.sock.gettimeout()), type(1.0))
 
-        self.__s.settimeout(None)
-        self.assertEqual(type(self.__s.gettimeout()), type(None),
-            "return type of gettimeout() is not None")
+        self.sock.settimeout(3.9)
+        self.assertEqual(type(self.sock.gettimeout()), type(1.0))
 
     def testTypeCheck(self):
-        "Test type checking by settimeout"
-        self.__s.settimeout(0)
-        self.__s.settimeout(0L)
-        self.__s.settimeout(0.0)
-        self.__s.settimeout(None)
-        self.assertRaises(TypeError, self.__s.settimeout, "")
-        self.assertRaises(TypeError, self.__s.settimeout, u"")
-        self.assertRaises(TypeError, self.__s.settimeout, ())
-        self.assertRaises(TypeError, self.__s.settimeout, [])
-        self.assertRaises(TypeError, self.__s.settimeout, {})
-        self.assertRaises(TypeError, self.__s.settimeout, 0j)
+        "Test type checking by settimeout()"
+        self.sock.settimeout(0)
+        self.sock.settimeout(0L)
+        self.sock.settimeout(0.0)
+        self.sock.settimeout(None)
+        self.assertRaises(TypeError, self.sock.settimeout, "")
+        self.assertRaises(TypeError, self.sock.settimeout, u"")
+        self.assertRaises(TypeError, self.sock.settimeout, ())
+        self.assertRaises(TypeError, self.sock.settimeout, [])
+        self.assertRaises(TypeError, self.sock.settimeout, {})
+        self.assertRaises(TypeError, self.sock.settimeout, 0j)
 
     def testRangeCheck(self):
-        "Test range checking by settimeout"
-        self.assertRaises(ValueError, self.__s.settimeout, -1)
-        self.assertRaises(ValueError, self.__s.settimeout, -1L)
-        self.assertRaises(ValueError, self.__s.settimeout, -1.0)
+        "Test range checking by settimeout()"
+        self.assertRaises(ValueError, self.sock.settimeout, -1)
+        self.assertRaises(ValueError, self.sock.settimeout, -1L)
+        self.assertRaises(ValueError, self.sock.settimeout, -1.0)
 
     def testTimeoutThenoBlocking(self):
-        "Test settimeout followed by setblocking"
-        self.__s.settimeout(10)
-        self.__s.setblocking(1)
-        self.assertEqual(self.__s.gettimeout(), None)
-        self.__s.setblocking(0)
-        self.assertEqual(self.__s.gettimeout(), None)
-
-        self.__s.settimeout(10)
-        self.__s.setblocking(0)
-        self.assertEqual(self.__s.gettimeout(), None)
-        self.__s.setblocking(1)
-        self.assertEqual(self.__s.gettimeout(), None)
+        "Test settimeout() followed by setblocking()"
+        self.sock.settimeout(10)
+        self.sock.setblocking(1)
+        self.assertEqual(self.sock.gettimeout(), None)
+        self.sock.setblocking(0)
+        self.assertEqual(self.sock.gettimeout(), None)
+
+        self.sock.settimeout(10)
+        self.sock.setblocking(0)
+        self.assertEqual(self.sock.gettimeout(), None)
+        self.sock.setblocking(1)
+        self.assertEqual(self.sock.gettimeout(), None)
 
     def testBlockingThenTimeout(self):
-        "Test setblocking followed by settimeout"
-        self.__s.setblocking(0)
-        self.__s.settimeout(1)
-        self.assertEqual(self.__s.gettimeout(), 1)
+        "Test setblocking() followed by settimeout()"
+        self.sock.setblocking(0)
+        self.sock.settimeout(1)
+        self.assertEqual(self.sock.gettimeout(), 1)
 
-        self.__s.setblocking(1)
-        self.__s.settimeout(1)
-        self.assertEqual(self.__s.gettimeout(), 1)
+        self.sock.setblocking(1)
+        self.sock.settimeout(1)
+        self.assertEqual(self.sock.gettimeout(), 1)
 
 
 class TimeoutTestCase(unittest.TestCase):
-    """Test Case for socket.socket() timeout functions"""
+    """Test case for socket.socket() timeout functions"""
+
+    fuzz = 1.0
 
     def setUp(self):
-        self.__s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.__addr_remote = ('www.google.com', 80)
-        self.__addr_local  = ('127.0.0.1', 25339)
+        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)
 
     def tearDown(self):
-        self.__s.close()
+        self.sock.close()
 
     def testConnectTimeout(self):
         "Test connect() timeout"
         _timeout = 0.02
-        self.__s.settimeout(_timeout)
+        self.sock.settimeout(_timeout)
 
         _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.__s.connect,
-                self.__addr_remote)
+        self.failUnlessRaises(socket.error, self.sock.connect,
+                self.addr_remote)
         _t2 = time.time()
 
         _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + 0.5,
-                "timeout (%f) is 0.5 seconds more than required (%f)"
-                %(_delta, _timeout))
+        self.assert_(_delta < _timeout + self.fuzz,
+                     "timeout (%g) is %g seconds more than expected (%g)"
+                     %(_delta, self.fuzz, _timeout))
 
     def testRecvTimeout(self):
         "Test recv() timeout"
         _timeout = 0.02
-        self.__s.connect(self.__addr_remote)
-        self.__s.settimeout(_timeout)
+        self.sock.connect(self.addr_remote)
+        self.sock.settimeout(_timeout)
 
         _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.__s.recv, 1024)
+        self.failUnlessRaises(socket.error, self.sock.recv, 1024)
         _t2 = time.time()
 
         _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + 0.5,
-                "timeout (%f) is 0.5 seconds more than required (%f)"
-                %(_delta, _timeout))
+        self.assert_(_delta < _timeout + self.fuzz,
+                     "timeout (%g) is %g seconds more than expected (%g)"
+                     %(_delta, self.fuzz, _timeout))
 
     def testAcceptTimeout(self):
-        "Test accept() timeout()"
+        "Test accept() timeout"
         _timeout = 2
-        self.__s.settimeout(_timeout)
-        self.__s.bind(self.__addr_local)
-        self.__s.listen(5)
+        self.sock.settimeout(_timeout)
+        self.sock.bind(self.addr_local)
+        self.sock.listen(5)
 
         _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.__s.accept)
+        self.failUnlessRaises(socket.error, self.sock.accept)
         _t2 = time.time()
 
         _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + 0.5,
-                "timeout (%f) is 0.5 seconds more than required (%f)"
-                %(_delta, _timeout))
+        self.assert_(_delta < _timeout + self.fuzz,
+                     "timeout (%g) is %g seconds more than expected (%g)"
+                     %(_delta, self.fuzz, _timeout))
 
     def testRecvfromTimeout(self):
-        "Test recvfrom() timeout()"
+        "Test recvfrom() timeout"
         _timeout = 2
-        self.__s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self.__s.settimeout(_timeout)
-        self.__s.bind(self.__addr_local)
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        self.sock.settimeout(_timeout)
+        self.sock.bind(self.addr_local)
 
         _t1 = time.time()
-        self.failUnlessRaises(socket.error, self.__s.recvfrom, 8192)
+        self.failUnlessRaises(socket.error, self.sock.recvfrom, 8192)
         _t2 = time.time()
 
         _delta = abs(_t1 - _t2)
-        self.assert_(_delta < _timeout + 0.5,
-                "timeout (%f) is 0.5 seconds more than required (%f)"
-                %(_delta, _timeout))
+        self.assert_(_delta < _timeout + self.fuzz,
+                     "timeout (%g) is %g seconds more than expected (%g)"
+                     %(_delta, self.fuzz, _timeout))
 
     def testSend(self):
         "Test send() timeout"