diff -r 000000000000 -r ae805ac0140d python-2.5.2/win32/Lib/test/test_timeout.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/python-2.5.2/win32/Lib/test/test_timeout.py Fri Apr 03 17:19:34 2009 +0100 @@ -0,0 +1,198 @@ +"""Unit tests for socket timeout feature.""" + +import unittest +from test import test_support + +# This requires the 'network' resource as given on the regrtest command line. +skip_expected = not test_support.is_resource_enabled('network') + +import time +import socket + + +class CreationTestCase(unittest.TestCase): + """Test case for socket.gettimeout() and socket.settimeout()""" + + def setUp(self): + self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + + def tearDown(self): + self.sock.close() + + def testObjectCreation(self): + # Test Socket creation + self.assertEqual(self.sock.gettimeout(), None, + "timeout not disabled by default") + + def testFloatReturnValue(self): + # Test return value of gettimeout() + self.sock.settimeout(7.345) + self.assertEqual(self.sock.gettimeout(), 7.345) + + self.sock.settimeout(3) + self.assertEqual(self.sock.gettimeout(), 3) + + self.sock.settimeout(None) + self.assertEqual(self.sock.gettimeout(), None) + + def testReturnType(self): + # Test return type of gettimeout() + self.sock.settimeout(1) + self.assertEqual(type(self.sock.gettimeout()), type(1.0)) + + self.sock.settimeout(3.9) + self.assertEqual(type(self.sock.gettimeout()), type(1.0)) + + def testTypeCheck(self): + # 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.sock.settimeout, -1) + self.assertRaises(ValueError, self.sock.settimeout, -1L) + self.assertRaises(ValueError, self.sock.settimeout, -1.0) + + def testTimeoutThenBlocking(self): + # 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(), 0.0) + + self.sock.settimeout(10) + self.sock.setblocking(0) + self.assertEqual(self.sock.gettimeout(), 0.0) + self.sock.setblocking(1) + self.assertEqual(self.sock.gettimeout(), None) + + def testBlockingThenTimeout(self): + # Test setblocking() followed by settimeout() + self.sock.setblocking(0) + self.sock.settimeout(1) + self.assertEqual(self.sock.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""" + + # There are a number of tests here trying to make sure that an operation + # doesn't take too much longer than expected. But competing machine + # activity makes it inevitable that such tests will fail at times. + # When fuzz was at 1.0, I (tim) routinely saw bogus failures on Win2K + # and Win98SE. Boosting it to 2.0 helped a lot, but isn't a real + # solution. + fuzz = 2.0 + + def setUp(self): + self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + self.addr_remote = ('www.python.org.', 80) + self.addr_local = ('127.0.0.1', 25339) + + def tearDown(self): + self.sock.close() + + def testConnectTimeout(self): + # Test connect() timeout + _timeout = 0.001 + self.sock.settimeout(_timeout) + + # If we are too close to www.python.org, this test will fail. + # Pick a host that should be farther away. + if (socket.getfqdn().split('.')[-2:] == ['python', 'org'] or + socket.getfqdn().split('.')[-2:-1] == ['xs4all']): + self.addr_remote = ('tut.fi', 80) + + _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 more than %g seconds more than expected (%g)" + %(_delta, self.fuzz, _timeout)) + + 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)) + + def testAcceptTimeout(self): + # Test accept() timeout + _timeout = 2 + self.sock.settimeout(_timeout) + self.sock.bind(self.addr_local) + self.sock.listen(5) + + _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)) + + def testRecvfromTimeout(self): + # Test recvfrom() timeout + _timeout = 2 + 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.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)) + + def testSend(self): + # Test send() timeout + # couldn't figure out how to test it + pass + + def testSendto(self): + # Test sendto() timeout + # couldn't figure out how to test it + pass + + def testSendall(self): + # Test sendall() timeout + # couldn't figure out how to test it + pass + + +def test_main(): + test_support.requires('network') + test_support.run_unittest(CreationTestCase, TimeoutTestCase) + +if __name__ == "__main__": + test_main()