Lib/test/test_posix.py

   1 "Test posix functions"
   2
   3 from test import test_support
   4
   5 # Skip these tests if there is no posix module.
   6 posix = test_support.import_module('posix')
   7
   8 import time
   9 import os
  10 import pwd
  11 import shutil
  12 import unittest
  13 import warnings
  14
  15
  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.assertTrue(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.assertTrue(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.assertTrue(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.assertTrue(posix.fstat(fp.fileno()))
 139             finally:
 140                 fp.close()
 141
 142     def test_stat(self):
 143         if hasattr(posix, 'stat'):
 144             self.assertTrue(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.assertTrue(test_support.TESTFN in posix.lsdir(os.curdir))
 181
 182     def test_access(self):
 183         if hasattr(posix, 'access'):
 184             self.assertTrue(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.assertTrue(isinstance(old_mask, int))
 190             posix.umask(old_mask)
 191
 192     def test_strerror(self):
 193         if hasattr(posix, 'strerror'):
 194             self.assertTrue(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.assertTrue(posix.tempnam())
 205             self.assertTrue(posix.tempnam(os.curdir))
 206             self.assertTrue(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 SkipTest exception,
 246 #               because the test results in Error in that case.
 247 #               Is that ok?
 248 #                raise unittest.SkipTest, "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 unittest.SkipTest, "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                 os.chdir(curdir)
 271                 shutil.rmtree(base_path)
 272
 273
 274 def test_main():
 275     test_support.run_unittest(PosixTester)
 276
 277 if __name__ == '__main__':
 278     test_main()