← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Lib/test/test_posix.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/test_posix.py
 
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()