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