PageRenderTime 33ms CodeModel.GetById 1ms app.highlight 28ms RepoModel.GetById 1ms app.codeStats 0ms

/Lib/test/test_posix.py

http://unladen-swallow.googlecode.com/
Python | 278 lines | 216 code | 45 blank | 17 comment | 36 complexity | 7a416e5caa461b8a917d56ce3009c57d MD5 | raw file
  1"Test posix functions"
  2
  3from test import test_support
  4
  5try:
  6    import posix
  7except ImportError:
  8    raise test_support.TestSkipped, "posix is not available"
  9
 10import time
 11import os
 12import pwd
 13import shutil
 14import unittest
 15import warnings
 16warnings.filterwarnings('ignore', '.* potential security risk .*',
 17                        RuntimeWarning)
 18
 19class 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                os.chdir(curdir)
271                shutil.rmtree(base_path)
272
273
274def test_main():
275    test_support.run_unittest(PosixTester)
276
277if __name__ == '__main__':
278    test_main()