Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / devtools / v9 / lib / python2.4 / test / test_timeout.py

"""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)

       _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()