home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_posix.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  9.6 KB  |  279 lines
  1. "Test posix functions"
  2.  
  3. from test import test_support
  4.  
  5. try:
  6.     import posix
  7. except ImportError:
  8.     raise test_support.TestSkipped, "posix is not available"
  9.  
  10. import time
  11. import os
  12. import pwd
  13. import shutil
  14. import unittest
  15. import warnings
  16. warnings.filterwarnings('ignore', '.* potential security risk .*',
  17.                         RuntimeWarning)
  18.  
  19. class PosixTester(unittest.TestCase):
  20.  
  21.     def setUp(self):
  22.         # create empty file
  23.         fp = open(test_support.TESTFN, 'w+')
  24.         fp.close()
  25.  
  26.     def tearDown(self):
  27.         os.unlink(test_support.TESTFN)
  28.  
  29.     def testNoArgFunctions(self):
  30.         # test posix functions which take no arguments and have
  31.         # no side-effects which we need to cleanup (e.g., fork, wait, abort)
  32.         NO_ARG_FUNCTIONS = [ "ctermid", "getcwd", "getcwdu", "uname",
  33.                              "times", "getloadavg", "tmpnam",
  34.                              "getegid", "geteuid", "getgid", "getgroups",
  35.                              "getpid", "getpgrp", "getppid", "getuid",
  36.                            ]
  37.  
  38.         for name in NO_ARG_FUNCTIONS:
  39.             posix_func = getattr(posix, name, None)
  40.             if posix_func is not None:
  41.                 posix_func()
  42.                 self.assertRaises(TypeError, posix_func, 1)
  43.  
  44.     def test_statvfs(self):
  45.         if hasattr(posix, 'statvfs'):
  46.             self.assert_(posix.statvfs(os.curdir))
  47.  
  48.     def test_fstatvfs(self):
  49.         if hasattr(posix, 'fstatvfs'):
  50.             fp = open(test_support.TESTFN)
  51.             try:
  52.                 self.assert_(posix.fstatvfs(fp.fileno()))
  53.             finally:
  54.                 fp.close()
  55.  
  56.     def test_ftruncate(self):
  57.         if hasattr(posix, 'ftruncate'):
  58.             fp = open(test_support.TESTFN, 'w+')
  59.             try:
  60.                 # we need to have some data to truncate
  61.                 fp.write('test')
  62.                 fp.flush()
  63.                 posix.ftruncate(fp.fileno(), 0)
  64.             finally:
  65.                 fp.close()
  66.  
  67.     def test_dup(self):
  68.         if hasattr(posix, 'dup'):
  69.             fp = open(test_support.TESTFN)
  70.             try:
  71.                 fd = posix.dup(fp.fileno())
  72.                 self.assert_(isinstance(fd, int))
  73.                 os.close(fd)
  74.             finally:
  75.                 fp.close()
  76.  
  77.     def test_confstr(self):
  78.         if hasattr(posix, 'confstr'):
  79.             self.assertRaises(ValueError, posix.confstr, "CS_garbage")
  80.             self.assertEqual(len(posix.confstr("CS_PATH")) > 0, True)
  81.  
  82.     def test_dup2(self):
  83.         if hasattr(posix, 'dup2'):
  84.             fp1 = open(test_support.TESTFN)
  85.             fp2 = open(test_support.TESTFN)
  86.             try:
  87.                 posix.dup2(fp1.fileno(), fp2.fileno())
  88.             finally:
  89.                 fp1.close()
  90.                 fp2.close()
  91.  
  92.     def fdopen_helper(self, *args):
  93.         fd = os.open(test_support.TESTFN, os.O_RDONLY)
  94.         fp2 = posix.fdopen(fd, *args)
  95.         fp2.close()
  96.  
  97.     def test_fdopen(self):
  98.         if hasattr(posix, 'fdopen'):
  99.             self.fdopen_helper()
  100.             self.fdopen_helper('r')
  101.             self.fdopen_helper('r', 100)
  102.  
  103.     def test_osexlock(self):
  104.         if hasattr(posix, "O_EXLOCK"):
  105.             fd = os.open(test_support.TESTFN,
  106.                          os.O_WRONLY|os.O_EXLOCK|os.O_CREAT)
  107.             self.assertRaises(OSError, os.open, test_support.TESTFN,
  108.                               os.O_WRONLY|os.O_EXLOCK|os.O_NONBLOCK)
  109.             os.close(fd)
  110.  
  111.             if hasattr(posix, "O_SHLOCK"):
  112.                 fd = os.open(test_support.TESTFN,
  113.                              os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)
  114.                 self.assertRaises(OSError, os.open, test_support.TESTFN,
  115.                                   os.O_WRONLY|os.O_EXLOCK|os.O_NONBLOCK)
  116.                 os.close(fd)
  117.  
  118.     def test_osshlock(self):
  119.         if hasattr(posix, "O_SHLOCK"):
  120.             fd1 = os.open(test_support.TESTFN,
  121.                          os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)
  122.             fd2 = os.open(test_support.TESTFN,
  123.                           os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)
  124.             os.close(fd2)
  125.             os.close(fd1)
  126.  
  127.             if hasattr(posix, "O_EXLOCK"):
  128.                 fd = os.open(test_support.TESTFN,
  129.                              os.O_WRONLY|os.O_SHLOCK|os.O_CREAT)
  130.                 self.assertRaises(OSError, os.open, test_support.TESTFN,
  131.                                   os.O_RDONLY|os.O_EXLOCK|os.O_NONBLOCK)
  132.                 os.close(fd)
  133.  
  134.     def test_fstat(self):
  135.         if hasattr(posix, 'fstat'):
  136.             fp = open(test_support.TESTFN)
  137.             try:
  138.                 self.assert_(posix.fstat(fp.fileno()))
  139.             finally:
  140.                 fp.close()
  141.  
  142.     def test_stat(self):
  143.         if hasattr(posix, 'stat'):
  144.             self.assert_(posix.stat(test_support.TESTFN))
  145.  
  146.     if hasattr(posix, 'chown'):
  147.         def test_chown(self):
  148.             # raise an OSError if the file does not exist
  149.             os.unlink(test_support.TESTFN)
  150.             self.assertRaises(OSError, posix.chown, test_support.TESTFN, -1, -1)
  151.  
  152.             # re-create the file
  153.             open(test_support.TESTFN, 'w').close()
  154.             if os.getuid() == 0:
  155.                 try:
  156.                     # Many linux distros have a nfsnobody user as MAX_UID-2
  157.                     # that makes a good test case for signedness issues.
  158.                     #   http://bugs.python.org/issue1747858
  159.                     # This part of the test only runs when run as root.
  160.                     # Only scary people run their tests as root.
  161.                     ent = pwd.getpwnam('nfsnobody')
  162.                     posix.chown(test_support.TESTFN, ent.pw_uid, ent.pw_gid)
  163.                 except KeyError:
  164.                     pass
  165.             else:
  166.                 # non-root cannot chown to root, raises OSError
  167.                 self.assertRaises(OSError, posix.chown,
  168.                                   test_support.TESTFN, 0, 0)
  169.  
  170.             # test a successful chown call
  171.             posix.chown(test_support.TESTFN, os.getuid(), os.getgid())
  172.  
  173.     def test_chdir(self):
  174.         if hasattr(posix, 'chdir'):
  175.             posix.chdir(os.curdir)
  176.             self.assertRaises(OSError, posix.chdir, test_support.TESTFN)
  177.  
  178.     def test_lsdir(self):
  179.         if hasattr(posix, 'lsdir'):
  180.             self.assert_(test_support.TESTFN in posix.lsdir(os.curdir))
  181.  
  182.     def test_access(self):
  183.         if hasattr(posix, 'access'):
  184.             self.assert_(posix.access(test_support.TESTFN, os.R_OK))
  185.  
  186.     def test_umask(self):
  187.         if hasattr(posix, 'umask'):
  188.             old_mask = posix.umask(0)
  189.             self.assert_(isinstance(old_mask, int))
  190.             posix.umask(old_mask)
  191.  
  192.     def test_strerror(self):
  193.         if hasattr(posix, 'strerror'):
  194.             self.assert_(posix.strerror(0))
  195.  
  196.     def test_pipe(self):
  197.         if hasattr(posix, 'pipe'):
  198.             reader, writer = posix.pipe()
  199.             os.close(reader)
  200.             os.close(writer)
  201.  
  202.     def test_tempnam(self):
  203.         if hasattr(posix, 'tempnam'):
  204.             self.assert_(posix.tempnam())
  205.             self.assert_(posix.tempnam(os.curdir))
  206.             self.assert_(posix.tempnam(os.curdir, 'blah'))
  207.  
  208.     def test_tmpfile(self):
  209.         if hasattr(posix, 'tmpfile'):
  210.             fp = posix.tmpfile()
  211.             fp.close()
  212.  
  213.     def test_utime(self):
  214.         if hasattr(posix, 'utime'):
  215.             now = time.time()
  216.             posix.utime(test_support.TESTFN, None)
  217.             self.assertRaises(TypeError, posix.utime, test_support.TESTFN, (None, None))
  218.             self.assertRaises(TypeError, posix.utime, test_support.TESTFN, (now, None))
  219.             self.assertRaises(TypeError, posix.utime, test_support.TESTFN, (None, now))
  220.             posix.utime(test_support.TESTFN, (int(now), int(now)))
  221.             posix.utime(test_support.TESTFN, (now, now))
  222.  
  223.     def test_chflags(self):
  224.         if hasattr(posix, 'chflags'):
  225.             st = os.stat(test_support.TESTFN)
  226.             if hasattr(st, 'st_flags'):
  227.                 posix.chflags(test_support.TESTFN, st.st_flags)
  228.  
  229.     def test_lchflags(self):
  230.         if hasattr(posix, 'lchflags'):
  231.             st = os.stat(test_support.TESTFN)
  232.             if hasattr(st, 'st_flags'):
  233.                 posix.lchflags(test_support.TESTFN, st.st_flags)
  234.  
  235.     def test_getcwd_long_pathnames(self):
  236.         if hasattr(posix, 'getcwd'):
  237.             dirname = 'getcwd-test-directory-0123456789abcdef-01234567890abcdef'
  238.             curdir = os.getcwd()
  239.             base_path = os.path.abspath(test_support.TESTFN) + '.getcwd'
  240.  
  241.             try:
  242.                 os.mkdir(base_path)
  243.                 os.chdir(base_path)
  244.             except:
  245. #               Just returning nothing instead of the TestSkipped exception,
  246. #               because the test results in Error in that case.
  247. #               Is that ok?
  248. #                raise test_support.TestSkipped, "cannot create directory for testing"
  249.                 return
  250.  
  251.             try:
  252.                 def _create_and_do_getcwd(dirname, current_path_length = 0):
  253.                     try:
  254.                         os.mkdir(dirname)
  255.                     except:
  256.                         raise test_support.TestSkipped, "mkdir cannot create directory sufficiently deep for getcwd test"
  257.  
  258.                     os.chdir(dirname)
  259.                     try:
  260.                         os.getcwd()
  261.                         if current_path_length < 1027:
  262.                             _create_and_do_getcwd(dirname, current_path_length + len(dirname) + 1)
  263.                     finally:
  264.                         os.chdir('..')
  265.                         os.rmdir(dirname)
  266.  
  267.                 _create_and_do_getcwd(dirname)
  268.  
  269.             finally:
  270.                 shutil.rmtree(base_path)
  271.                 os.chdir(curdir)
  272.  
  273.  
  274. def test_main():
  275.     test_support.run_unittest(PosixTester)
  276.  
  277. if __name__ == '__main__':
  278.     test_main()
  279.