Debian Codegraph @

Lib/test/test_stat.py

raw
1 import unittest
2 import os
3 import socket
4 import sys
5 from test.support import is_apple, os_helper, socket_helper
6 from test.support.import_helper import import_fresh_module
7 from test.support.os_helper import TESTFN
8
9
10 c_stat = import_fresh_module('stat', fresh=['_stat'])
11 py_stat = import_fresh_module('stat', blocked=['_stat'])
12
13 class TestFilemode:
14 statmod = None
15
16 file_flags = {'SF_APPEND', 'SF_ARCHIVED', 'SF_IMMUTABLE', 'SF_NOUNLINK',
17 'SF_SNAPSHOT', 'SF_SETTABLE', 'SF_RESTRICTED', 'SF_FIRMLINK',
18 'SF_DATALESS', 'UF_APPEND', 'UF_COMPRESSED', 'UF_HIDDEN',
19 'UF_IMMUTABLE', 'UF_NODUMP', 'UF_NOUNLINK', 'UF_OPAQUE',
20 'UF_SETTABLE', 'UF_TRACKED', 'UF_DATAVAULT'}
21
22 formats = {'S_IFBLK', 'S_IFCHR', 'S_IFDIR', 'S_IFIFO', 'S_IFLNK',
23 'S_IFREG', 'S_IFSOCK', 'S_IFDOOR', 'S_IFPORT', 'S_IFWHT'}
24
25 format_funcs = {'S_ISBLK', 'S_ISCHR', 'S_ISDIR', 'S_ISFIFO', 'S_ISLNK',
26 'S_ISREG', 'S_ISSOCK', 'S_ISDOOR', 'S_ISPORT', 'S_ISWHT'}
27
28 stat_struct = {
29 'ST_MODE': 0,
30 'ST_INO': 1,
31 'ST_DEV': 2,
32 'ST_NLINK': 3,
33 'ST_UID': 4,
34 'ST_GID': 5,
35 'ST_SIZE': 6,
36 'ST_ATIME': 7,
37 'ST_MTIME': 8,
38 'ST_CTIME': 9}
39
40 # permission bit value are defined by POSIX
41 permission_bits = {
42 'S_ISUID': 0o4000,
43 'S_ISGID': 0o2000,
44 'S_ENFMT': 0o2000,
45 'S_ISVTX': 0o1000,
46 'S_IRWXU': 0o700,
47 'S_IRUSR': 0o400,
48 'S_IREAD': 0o400,
49 'S_IWUSR': 0o200,
50 'S_IWRITE': 0o200,
51 'S_IXUSR': 0o100,
52 'S_IEXEC': 0o100,
53 'S_IRWXG': 0o070,
54 'S_IRGRP': 0o040,
55 'S_IWGRP': 0o020,
56 'S_IXGRP': 0o010,
57 'S_IRWXO': 0o007,
58 'S_IROTH': 0o004,
59 'S_IWOTH': 0o002,
60 'S_IXOTH': 0o001}
61
62 # defined by the Windows API documentation
63 file_attributes = {
64 'FILE_ATTRIBUTE_ARCHIVE': 32,
65 'FILE_ATTRIBUTE_COMPRESSED': 2048,
66 'FILE_ATTRIBUTE_DEVICE': 64,
67 'FILE_ATTRIBUTE_DIRECTORY': 16,
68 'FILE_ATTRIBUTE_ENCRYPTED': 16384,
69 'FILE_ATTRIBUTE_HIDDEN': 2,
70 'FILE_ATTRIBUTE_INTEGRITY_STREAM': 32768,
71 'FILE_ATTRIBUTE_NORMAL': 128,
72 'FILE_ATTRIBUTE_NOT_CONTENT_INDEXED': 8192,
73 'FILE_ATTRIBUTE_NO_SCRUB_DATA': 131072,
74 'FILE_ATTRIBUTE_OFFLINE': 4096,
75 'FILE_ATTRIBUTE_READONLY': 1,
76 'FILE_ATTRIBUTE_REPARSE_POINT': 1024,
77 'FILE_ATTRIBUTE_SPARSE_FILE': 512,
78 'FILE_ATTRIBUTE_SYSTEM': 4,
79 'FILE_ATTRIBUTE_TEMPORARY': 256,
80 'FILE_ATTRIBUTE_VIRTUAL': 65536}
81
82 def setUp(self):
83 try:
84 os.remove(TESTFN)
85 except OSError:
86 try:
87 os.rmdir(TESTFN)
88 except OSError:
89 pass
90 tearDown = setUp
91
92 def get_mode(self, fname=TESTFN, lstat=True):
93 if lstat:
94 st_mode = os.lstat(fname).st_mode
95 else:
96 st_mode = os.stat(fname).st_mode
97 modestr = self.statmod.filemode(st_mode)
98 return st_mode, modestr
99
100 def assertS_IS(self, name, mode):
101 # test format, lstrip is for S_IFIFO
102 fmt = getattr(self.statmod, "S_IF" + name.lstrip("F"))
103 self.assertEqual(self.statmod.S_IFMT(mode), fmt)
104 # test that just one function returns true
105 testname = "S_IS" + name
106 for funcname in self.format_funcs:
107 func = getattr(self.statmod, funcname, None)
108 if func is None:
109 if funcname == testname:
110 raise ValueError(funcname)
111 continue
112 if funcname == testname:
113 self.assertTrue(func(mode))
114 else:
115 self.assertFalse(func(mode))
116
117 @os_helper.skip_unless_working_chmod
118 def test_mode(self):
119 with open(TESTFN, 'w'):
120 pass
121 if os.name == 'posix':
122 os.chmod(TESTFN, 0o700)
123 st_mode, modestr = self.get_mode()
124 self.assertEqual(modestr, '-rwx------')
125 self.assertS_IS("REG", st_mode)
126 imode = self.statmod.S_IMODE(st_mode)
127 self.assertEqual(imode,
128 self.statmod.S_IRWXU)
129 self.assertEqual(self.statmod.filemode(imode),
130 '?rwx------')
131
132 os.chmod(TESTFN, 0o070)
133 st_mode, modestr = self.get_mode()
134 self.assertEqual(modestr, '----rwx---')
135 self.assertS_IS("REG", st_mode)
136 self.assertEqual(self.statmod.S_IMODE(st_mode),
137 self.statmod.S_IRWXG)
138
139 os.chmod(TESTFN, 0o007)
140 st_mode, modestr = self.get_mode()
141 self.assertEqual(modestr, '-------rwx')
142 self.assertS_IS("REG", st_mode)
143 self.assertEqual(self.statmod.S_IMODE(st_mode),
144 self.statmod.S_IRWXO)
145
146 os.chmod(TESTFN, 0o444)
147 st_mode, modestr = self.get_mode()
148 self.assertS_IS("REG", st_mode)
149 self.assertEqual(modestr, '-r--r--r--')
150 self.assertEqual(self.statmod.S_IMODE(st_mode), 0o444)
151 else:
152 os.chmod(TESTFN, 0o500)
153 st_mode, modestr = self.get_mode()
154 self.assertEqual(modestr[:3], '-r-')
155 self.assertS_IS("REG", st_mode)
156 self.assertEqual(self.statmod.S_IMODE(st_mode), 0o444)
157
158 os.chmod(TESTFN, 0o700)
159 st_mode, modestr = self.get_mode()
160 self.assertStartsWith(modestr, '-rw')
161 self.assertS_IS("REG", st_mode)
162 self.assertEqual(self.statmod.S_IFMT(st_mode),
163 self.statmod.S_IFREG)
164 self.assertEqual(self.statmod.S_IMODE(st_mode), 0o666)
165
166 def test_filemode_does_not_misclassify_random_bits(self):
167 # gh-144050 regression test
168 self.assertEqual(self.statmod.filemode(0o77777)[0], "?")
169 self.assertEqual(self.statmod.filemode(0o177777)[0], "?")
170
171 @os_helper.skip_unless_working_chmod
172 def test_directory(self):
173 os.mkdir(TESTFN)
174 os.chmod(TESTFN, 0o700)
175 st_mode, modestr = self.get_mode()
176 self.assertS_IS("DIR", st_mode)
177 if os.name == 'posix':
178 self.assertEqual(modestr, 'drwx------')
179 else:
180 self.assertEqual(modestr[0], 'd')
181
182 @os_helper.skip_unless_symlink
183 def test_link(self):
184 try:
185 os.symlink(os.getcwd(), TESTFN)
186 except (OSError, NotImplementedError) as err:
187 raise unittest.SkipTest(str(err))
188 else:
189 st_mode, modestr = self.get_mode()
190 self.assertEqual(modestr[0], 'l')
191 self.assertS_IS("LNK", st_mode)
192
193 @unittest.skipUnless(hasattr(os, 'mkfifo'), 'os.mkfifo not available')
194 def test_fifo(self):
195 if sys.platform == "vxworks":
196 fifo_path = os.path.join("/fifos/", TESTFN)
197 else:
198 fifo_path = TESTFN
199 self.addCleanup(os_helper.unlink, fifo_path)
200 try:
201 os.mkfifo(fifo_path, 0o700)
202 except PermissionError as e:
203 self.skipTest('os.mkfifo(): %s' % e)
204 st_mode, modestr = self.get_mode(fifo_path)
205 self.assertEqual(modestr, 'prwx------')
206 self.assertS_IS("FIFO", st_mode)
207
208 @unittest.skipUnless(os.name == 'posix', 'requires Posix')
209 def test_devices(self):
210 if os.path.exists(os.devnull):
211 st_mode, modestr = self.get_mode(os.devnull, lstat=False)
212 self.assertEqual(modestr[0], 'c')
213 self.assertS_IS("CHR", st_mode)
214 # Linux block devices, BSD has no block devices anymore
215 for blockdev in ("/dev/sda", "/dev/hda"):
216 if os.path.exists(blockdev):
217 st_mode, modestr = self.get_mode(blockdev, lstat=False)
218 self.assertEqual(modestr[0], 'b')
219 self.assertS_IS("BLK", st_mode)
220 break
221
222 @socket_helper.skip_unless_bind_unix_socket
223 def test_socket(self):
224 with socket.socket(socket.AF_UNIX) as s:
225 s.bind(TESTFN)
226 st_mode, modestr = self.get_mode()
227 self.assertEqual(modestr[0], 's')
228 self.assertS_IS("SOCK", st_mode)
229
230 def test_module_attributes(self):
231 for key, value in self.stat_struct.items():
232 modvalue = getattr(self.statmod, key)
233 self.assertEqual(value, modvalue, key)
234 for key, value in self.permission_bits.items():
235 modvalue = getattr(self.statmod, key)
236 self.assertEqual(value, modvalue, key)
237 for key in self.file_flags:
238 modvalue = getattr(self.statmod, key)
239 self.assertIsInstance(modvalue, int)
240 for key in self.formats:
241 modvalue = getattr(self.statmod, key)
242 self.assertIsInstance(modvalue, int)
243 for key in self.format_funcs:
244 func = getattr(self.statmod, key)
245 self.assertTrue(callable(func))
246 self.assertEqual(func(0), 0)
247
248 def test_flags_consistent(self):
249 self.assertFalse(self.statmod.UF_SETTABLE & self.statmod.SF_SETTABLE)
250
251 for flag in self.file_flags:
252 if flag.startswith("UF"):
253 self.assertTrue(getattr(self.statmod, flag) & self.statmod.UF_SETTABLE, f"{flag} not in UF_SETTABLE")
254 elif is_apple and self.statmod is c_stat and flag == 'SF_DATALESS':
255 self.assertTrue(self.statmod.SF_DATALESS & self.statmod.SF_SYNTHETIC, "SF_DATALESS not in SF_SYNTHETIC")
256 self.assertFalse(self.statmod.SF_DATALESS & self.statmod.SF_SETTABLE, "SF_DATALESS in SF_SETTABLE")
257 else:
258 self.assertTrue(getattr(self.statmod, flag) & self.statmod.SF_SETTABLE, f"{flag} notin SF_SETTABLE")
259
260 @unittest.skipUnless(sys.platform == "win32",
261 "FILE_ATTRIBUTE_* constants are Win32 specific")
262 def test_file_attribute_constants(self):
263 for key, value in sorted(self.file_attributes.items()):
264 self.assertHasAttr(self.statmod, key)
265 modvalue = getattr(self.statmod, key)
266 self.assertEqual(value, modvalue, key)
267
268 @unittest.skipUnless(sys.platform == "darwin", "macOS system check")
269 def test_macosx_attribute_values(self):
270 self.assertEqual(self.statmod.UF_SETTABLE, 0x0000ffff)
271 self.assertEqual(self.statmod.UF_NODUMP, 0x00000001)
272 self.assertEqual(self.statmod.UF_IMMUTABLE, 0x00000002)
273 self.assertEqual(self.statmod.UF_APPEND, 0x00000004)
274 self.assertEqual(self.statmod.UF_OPAQUE, 0x00000008)
275 self.assertEqual(self.statmod.UF_COMPRESSED, 0x00000020)
276 self.assertEqual(self.statmod.UF_TRACKED, 0x00000040)
277 self.assertEqual(self.statmod.UF_DATAVAULT, 0x00000080)
278 self.assertEqual(self.statmod.UF_HIDDEN, 0x00008000)
279
280 if self.statmod is c_stat:
281 self.assertEqual(self.statmod.SF_SUPPORTED, 0x009f0000)
282 self.assertEqual(self.statmod.SF_SETTABLE, 0x3fff0000)
283 self.assertEqual(self.statmod.SF_SYNTHETIC, 0xc0000000)
284 else:
285 self.assertEqual(self.statmod.SF_SETTABLE, 0xffff0000)
286 self.assertEqual(self.statmod.SF_ARCHIVED, 0x00010000)
287 self.assertEqual(self.statmod.SF_IMMUTABLE, 0x00020000)
288 self.assertEqual(self.statmod.SF_APPEND, 0x00040000)
289 self.assertEqual(self.statmod.SF_RESTRICTED, 0x00080000)
290 self.assertEqual(self.statmod.SF_NOUNLINK, 0x00100000)
291 self.assertEqual(self.statmod.SF_FIRMLINK, 0x00800000)
292 self.assertEqual(self.statmod.SF_DATALESS, 0x40000000)
293
294 self.assertFalse(isinstance(self.statmod.S_IFMT, int))
295 self.assertEqual(self.statmod.S_IFIFO, 0o010000)
296 self.assertEqual(self.statmod.S_IFCHR, 0o020000)
297 self.assertEqual(self.statmod.S_IFDIR, 0o040000)
298 self.assertEqual(self.statmod.S_IFBLK, 0o060000)
299 self.assertEqual(self.statmod.S_IFREG, 0o100000)
300 self.assertEqual(self.statmod.S_IFLNK, 0o120000)
301 self.assertEqual(self.statmod.S_IFSOCK, 0o140000)
302
303 if self.statmod is c_stat:
304 self.assertEqual(self.statmod.S_IFWHT, 0o160000)
305
306 self.assertEqual(self.statmod.S_IRWXU, 0o000700)
307 self.assertEqual(self.statmod.S_IRUSR, 0o000400)
308 self.assertEqual(self.statmod.S_IWUSR, 0o000200)
309 self.assertEqual(self.statmod.S_IXUSR, 0o000100)
310 self.assertEqual(self.statmod.S_IRWXG, 0o000070)
311 self.assertEqual(self.statmod.S_IRGRP, 0o000040)
312 self.assertEqual(self.statmod.S_IWGRP, 0o000020)
313 self.assertEqual(self.statmod.S_IXGRP, 0o000010)
314 self.assertEqual(self.statmod.S_IRWXO, 0o000007)
315 self.assertEqual(self.statmod.S_IROTH, 0o000004)
316 self.assertEqual(self.statmod.S_IWOTH, 0o000002)
317 self.assertEqual(self.statmod.S_IXOTH, 0o000001)
318 self.assertEqual(self.statmod.S_ISUID, 0o004000)
319 self.assertEqual(self.statmod.S_ISGID, 0o002000)
320 self.assertEqual(self.statmod.S_ISVTX, 0o001000)
321
322 self.assertNotHasAttr(self.statmod, "S_ISTXT")
323 self.assertEqual(self.statmod.S_IREAD, self.statmod.S_IRUSR)
324 self.assertEqual(self.statmod.S_IWRITE, self.statmod.S_IWUSR)
325 self.assertEqual(self.statmod.S_IEXEC, self.statmod.S_IXUSR)
326
327
328
329 @unittest.skipIf(c_stat is None, 'need _stat extension')
330 class TestFilemodeCStat(TestFilemode, unittest.TestCase):
331 statmod = c_stat
332
333
334 class TestFilemodePyStat(TestFilemode, unittest.TestCase):
335 statmod = py_stat
336
337
338 if __name__ == '__main__':
339 unittest.main()