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