Lines Matching refs:posix
1 "Test posix functions"
6 # Skip these tests if there is no posix module.
7 posix = support.import_module('posix')
41 # test posix functions which take no arguments and have
50 posix_func = getattr(posix, name, None)
55 @unittest.skipUnless(hasattr(posix, 'getresuid'),
56 'test needs posix.getresuid()')
58 user_ids = posix.getresuid()
63 @unittest.skipUnless(hasattr(posix, 'getresgid'),
64 'test needs posix.getresgid()')
66 group_ids = posix.getresgid()
71 @unittest.skipUnless(hasattr(posix, 'setresuid'),
72 'test needs posix.setresuid()')
74 current_user_ids = posix.getresuid()
75 self.assertIsNone(posix.setresuid(*current_user_ids))
77 self.assertIsNone(posix.setresuid(-1, -1, -1))
79 @unittest.skipUnless(hasattr(posix, 'setresuid'),
80 'test needs posix.setresuid()')
83 current_user_ids = posix.getresuid()
86 self.assertRaises(OSError, posix.setresuid, *new_user_ids)
88 @unittest.skipUnless(hasattr(posix, 'setresgid'),
89 'test needs posix.setresgid()')
91 current_group_ids = posix.getresgid()
92 self.assertIsNone(posix.setresgid(*current_group_ids))
94 self.assertIsNone(posix.setresgid(-1, -1, -1))
96 @unittest.skipUnless(hasattr(posix, 'setresgid'),
97 'test needs posix.setresgid()')
100 current_group_ids = posix.getresgid()
103 self.assertRaises(OSError, posix.setresgid, *new_group_ids)
105 @unittest.skipUnless(hasattr(posix, 'initgroups'),
110 self.assertRaises(TypeError, posix.initgroups)
111 self.assertRaises(TypeError, posix.initgroups, None)
112 self.assertRaises(TypeError, posix.initgroups, 3, "foo")
113 self.assertRaises(TypeError, posix.initgroups, "foo", 3, object())
119 name = pwd.getpwuid(posix.getuid()).pw_name
124 posix.initgroups(name, 13)
130 @unittest.skipUnless(hasattr(posix, 'statvfs'),
131 'test needs posix.statvfs()')
133 self.assertTrue(posix.statvfs(os.curdir))
135 @unittest.skipUnless(hasattr(posix, 'fstatvfs'),
136 'test needs posix.fstatvfs()')
140 self.assertTrue(posix.fstatvfs(fp.fileno()))
141 self.assertTrue(posix.statvfs(fp.fileno()))
145 @unittest.skipUnless(hasattr(posix, 'ftruncate'),
146 'test needs posix.ftruncate()')
153 posix.ftruncate(fp.fileno(), 0)
157 @unittest.skipUnless(hasattr(posix, 'truncate'), "test needs posix.truncate()")
162 posix.truncate(support.TESTFN, 0)
173 posix.execve(fp, [sys.executable, '-c', 'pass'], os.environ)
179 @unittest.skipUnless(hasattr(posix, 'waitid'), "test needs posix.waitid()")
185 posix.execve(sys.executable, [sys.executable, '-c', 'pass'], os.environ)
187 res = posix.waitid(posix.P_PID, pid, posix.WEXITED)
190 @unittest.skipUnless(hasattr(posix, 'lockf'), "test needs posix.lockf()")
196 posix.lockf(fd, posix.F_LOCK, 4)
198 posix.lockf(fd, posix.F_ULOCK, 4)
202 @unittest.skipUnless(hasattr(posix, 'pread'), "test needs posix.pread()")
208 self.assertEqual(b'es', posix.pread(fd, 2, 1))
210 self.assertEqual(b'te', posix.read(fd, 2))
214 @unittest.skipUnless(hasattr(posix, 'pwrite'), "test needs posix.pwrite()")
220 posix.pwrite(fd, b'xx', 1)
221 self.assertEqual(b'txxt', posix.read(fd, 4))
225 @unittest.skipUnless(hasattr(posix, 'posix_fallocate'),
226 "test needs posix.posix_fallocate()")
230 posix.posix_fallocate(fd, 0, 10)
239 @unittest.skipUnless(hasattr(posix, 'posix_fadvise'),
240 "test needs posix.posix_fadvise()")
244 posix.posix_fadvise(fd, 0, 0, posix.POSIX_FADV_WILLNEED)
253 posix.utime(fd)
254 posix.utime(fd, None)
255 self.assertRaises(TypeError, posix.utime, fd, (None, None))
256 self.assertRaises(TypeError, posix.utime, fd, (now, None))
257 self.assertRaises(TypeError, posix.utime, fd, (None, now))
258 posix.utime(fd, (int(now), int(now)))
259 posix.utime(fd, (now, now))
260 self.assertRaises(ValueError, posix.utime, fd, (now, now), ns=(now, now))
261 self.assertRaises(ValueError, posix.utime, fd, (now, 0), ns=(None, None))
262 self.assertRaises(ValueError, posix.utime, fd, (None, None), ns=(now, 0))
263 posix.utime(fd, (int(now), int((now - int(now)) * 1e9)))
264 posix.utime(fd, ns=(int(now), int((now - int(now)) * 1e9)))
272 posix.utime(support.TESTFN, None, follow_symlinks=False)
273 self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None), follow_symlinks=False)
274 self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, None), follow_symlinks=False)
275 self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, now), follow_symlinks=False)
276 posix.utime(support.TESTFN, (int(now), int(now)), follow_symlinks=False)
277 posix.utime(support.TESTFN, (now, now), follow_symlinks=False)
278 posix.utime(support.TESTFN, follow_symlinks=False)
280 @unittest.skipUnless(hasattr(posix, 'writev'), "test needs posix.writev()")
288 self.assertEqual(b'test1tt2t3', posix.read(fd, 10))
292 size = posix.writev(fd, [])
302 @unittest.skipUnless(hasattr(posix, 'readv'), "test needs posix.readv()")
309 self.assertEqual(posix.readv(fd, buf), 10)
314 size = posix.readv(fd, [])
324 @unittest.skipUnless(hasattr(posix, 'dup'),
325 'test needs posix.dup()')
329 fd = posix.dup(fp.fileno())
335 @unittest.skipUnless(hasattr(posix, 'confstr'),
336 'test needs posix.confstr()')
338 self.assertRaises(ValueError, posix.confstr, "CS_garbage")
339 self.assertEqual(len(posix.confstr("CS_PATH")) > 0, True)
341 @unittest.skipUnless(hasattr(posix, 'dup2'),
342 'test needs posix.dup2()')
347 posix.dup2(fp1.fileno(), fp2.fileno())
359 @unittest.skipUnless(hasattr(posix, 'O_EXLOCK'),
360 'test needs posix.O_EXLOCK')
368 if hasattr(posix, "O_SHLOCK"):
375 @unittest.skipUnless(hasattr(posix, 'O_SHLOCK'),
376 'test needs posix.O_SHLOCK')
385 if hasattr(posix, "O_EXLOCK"):
392 @unittest.skipUnless(hasattr(posix, 'fstat'),
393 'test needs posix.fstat()')
397 self.assertTrue(posix.fstat(fp.fileno()))
398 self.assertTrue(posix.stat(fp.fileno()))
402 posix.stat, float(fp.fileno()))
406 @unittest.skipUnless(hasattr(posix, 'stat'),
407 'test needs posix.stat()')
409 self.assertTrue(posix.stat(support.TESTFN))
410 self.assertTrue(posix.stat(os.fsencode(support.TESTFN)))
414 posix
417 posix.stat, None)
420 posix.stat, list(support.TESTFN))
423 posix.stat, list(os.fsencode(support.TESTFN)))
425 @unittest.skipUnless(hasattr(posix, 'mkfifo'), "don't have mkfifo()")
429 posix.mkfifo(support.TESTFN, stat.S_IRUSR | stat.S_IWUSR)
430 self.assertTrue(stat.S_ISFIFO(posix.stat(support.TESTFN).st_mode))
432 @unittest.skipUnless(hasattr(posix, 'mknod') and hasattr(stat, 'S_IFIFO'),
437 # by POSIX).
441 posix.mknod(support.TESTFN, mode, 0)
447 self.assertTrue(stat.S_ISFIFO(posix.stat(support.TESTFN).st_mode))
452 posix.mknod(path=support.TESTFN, mode=mode, device=0,
457 @unittest.skipUnless(hasattr(posix, 'stat'), 'test needs posix.stat()')
458 @unittest.skipUnless(hasattr(posix, 'makedev'), 'test needs posix.makedev()')
460 st = posix.stat(support.TESTFN)
465 major = posix.major(dev)
468 self.assertEqual(posix.major(dev), major)
469 self.assertRaises(TypeError, posix.major, float(dev))
470 self.assertRaises(TypeError, posix.major)
471 self.assertRaises((ValueError, OverflowError), posix.major, -1)
473 minor = posix.minor(dev)
476 self.assertEqual(posix.minor(dev), minor)
477 self.assertRaises(TypeError, posix.minor, float(dev))
478 self.assertRaises(TypeError, posix.minor)
479 self.assertRaises((ValueError, OverflowError), posix.minor, -1)
481 self.assertEqual(posix.makedev(major, minor), dev)
482 self.assertRaises(TypeError, posix.makedev, float(major), minor)
483 self.assertRaises(TypeError, posix.makedev, major, float(minor))
484 self.assertRaises(TypeError, posix.makedev, major)
485 self.assertRaises(TypeError, posix.makedev)
546 @unittest.skipUnless(hasattr(posix, 'chown'), "test needs os.chown()")
550 self.assertRaises(OSError, posix.chown, support.TESTFN, -1, -1)
554 self._test_all_chown_common(posix.chown, support.TESTFN,
555 getattr(posix, 'stat', None))
557 @unittest.skipUnless(hasattr(posix, 'fchown'), "test needs os.fchown()")
565 self._test_all_chown_common(posix.fchown, fd,
566 getattr(posix, 'fstat', None))
570 @unittest.skipUnless(hasattr(posix, 'lchown'), "test needs os.lchown()")
575 self._test_all_chown_common(posix.lchown, support.TESTFN,
576 getattr(posix, 'lstat', None))
578 @unittest.skipUnless(hasattr(posix, 'chdir'), 'test needs posix.chdir()')
580 posix.chdir(os.curdir)
581 self.assertRaises(OSError, posix.chdir, support.TESTFN)
584 self.assertTrue(support.TESTFN in posix.listdir(os.curdir))
589 self.assertTrue(support.TESTFN in posix.listdir())
594 self.assertTrue(os.fsencode(support.TESTFN) in posix.listdir(b'.'))
596 @unittest.skipUnless(posix.listdir in os.supports_fd,
597 "test needs fd support for posix.listdir()")
599 f = posix.open(posix.getcwd(), posix.O_RDONLY)
600 self.addCleanup(posix.close, f)
602 sorted(posix.listdir('.')),
603 sorted(posix.listdir(f))
607 sorted(posix.listdir('.')),
608 sorted(posix.listdir(f))
611 @unittest.skipUnless(hasattr(posix, 'access'), 'test needs posix.access()')
613 self.assertTrue(posix.access(support.TESTFN, os.R_OK))
615 @unittest.skipUnless(hasattr(posix, 'umask'), 'test needs posix.umask()')
617 old_mask = posix.umask(0)
619 posix.umask(old_mask)
621 @unittest.skipUnless(hasattr(posix, 'strerror'),
622 'test needs posix.strerror()')
624 self.assertTrue(posix.strerror(0))
626 @unittest.skipUnless(hasattr(posix, 'pipe'), 'test needs posix.pipe()')
628 reader, writer = posix.pipe()
669 @unittest.skipUnless(hasattr(posix, 'utime'), 'test needs posix.utime()')
672 posix.utime(support.TESTFN, None)
673 self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None))
674 self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, None))
675 self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, now))
676 posix.utime(support.TESTFN, (int(now), int(now)))
677 posix.utime(support.TESTFN, (now, now))
701 posix.chflags(target_file, st.st_flags)
703 @unittest.skipUnless(hasattr(posix, 'chflags'), 'test needs os.chflags()')
705 self._test_chflags_regular_file(posix.chflags, support.TESTFN)
707 @unittest.skipUnless(hasattr(posix, 'lchflags'), 'test needs os.lchflags()')
709 self._test_chflags_regular_file(posix.lchflags, support.TESTFN)
710 self._test_chflags_regular_file(posix.chflags, support.TESTFN, follow_symlinks=False)
712 @unittest.skipUnless(hasattr(posix, 'lchflags'), 'test needs os.lchflags()')
723 return posix.chflags(path, flags, follow_symlinks=False)
725 for fn in (posix.lchflags, chflags_nofollow):
750 for k, v in posix.environ.items():
754 @unittest.skipUnless(hasattr(posix, 'getcwd'), 'test needs posix.getcwd()')
790 @unittest.skipUnless(hasattr(posix, 'getgrouplist'), "test needs posix.getgrouplist()")
796 self.assertIn(group, posix.getgrouplist(user, group))
822 # posix.getgroups() includes the effective gid.
823 symdiff = idg_groups.symmetric_difference(posix.getgroups())
824 self.assertTrue(not symdiff or symdiff == {posix.getegid()})
826 # tests for the posix *at functions follow
830 f = posix.open(posix.getcwd(), posix.O_RDONLY)
832 self.assertTrue(posix.access(support.TESTFN, os.R_OK, dir_fd=f))
834 posix.close(f)
840 f = posix.open(posix.getcwd(), posix.O_RDONLY)
842 posix.chmod(support.TESTFN, stat.S_IRUSR | stat.S_IWUSR, dir_fd=f)
844 s = posix.stat(support.TESTFN)
847 posix.close(f)
854 f = posix.open(posix.getcwd(), posix.O_RDONLY)
856 posix.chown(support.TESTFN, os.getuid(), os.getgid(), dir_fd=f)
858 posix.close(f)
866 f = posix.open(posix.getcwd(), posix.O_RDONLY)
868 s1 = posix.stat(support.TESTFN)
869 s2 = posix.stat(support.TESTFN, dir_fd=f)
871 s2 = posix.stat(support.TESTFN, dir_fd=None)
874 posix.stat, support.TESTFN, dir_fd=posix.getcwd())
876 posix.stat, support.TESTFN, dir_fd=float(f))
878 posix.stat, support.TESTFN, dir_fd=10**20)
880 posix.close(f)
884 f = posix.open(posix.getcwd(), posix.O_RDONLY)
887 posix.utime(support.TESTFN, None, dir_fd=f)
888 posix.utime(support.TESTFN, dir_fd=f)
889 self.assertRaises(TypeError, posix.utime, support.TESTFN, now, dir_fd=f)
890 self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, None), dir_fd=f)
891 self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, None), dir_fd=f)
892 self.assertRaises(TypeError, posix.utime, support.TESTFN, (None, now), dir_fd=f)
893 self.assertRaises(TypeError, posix.utime, support.TESTFN, (now, "x"), dir_fd=f)
894 posix.utime(support.TESTFN, (int(now), int(now)), dir_fd=f)
895 posix.utime(support.TESTFN, (now, now), dir_fd=f)
896 posix.utime(support.TESTFN,
898 posix.utime(support.TESTFN, dir_fd=f,
904 posix.utime(support.TESTFN, follow_symlinks=False, dir_fd=f)
910 posix.close(f)
915 f = posix.open(posix.getcwd(), posix.O_RDONLY)
917 posix.link(support.TESTFN, support.TESTFN + 'link', src_dir_fd=f, dst_dir_fd=f)
919 self.assertEqual(posix.stat(support.TESTFN)[1],
920 posix.stat(support.TESTFN + 'link')[1])
922 posix.close(f)
927 f = posix.open(posix.getcwd(), posix.O_RDONLY)
929 posix.mkdir(support.TESTFN + 'dir', dir_fd=f)
930 posix.stat(support.TESTFN + 'dir') # should not raise exception
932 posix.close(f)
940 # by POSIX).
943 f = posix.open(posix.getcwd(), posix.O_RDONLY)
945 posix.mknod(support.TESTFN, mode, 0, dir_fd=f)
951 self.assertTrue(stat.S_ISFIFO(posix.stat(support.TESTFN).st_mode))
953 posix.close(f)
960 a = posix.open(posix.getcwd(), posix.O_RDONLY)
961 b = posix.open(support.TESTFN, posix.O_RDONLY, dir_fd=a)
963 res = posix.read(b, 9).decode(encoding="utf-8")
966 posix.close(a)
967 posix.close(b)
972 f = posix.open(posix.getcwd(), posix.O_RDONLY)
974 self.assertEqual(posix.readlink(support.TESTFN + 'link'),
975 posix.readlink(support.TESTFN + 'link', dir_fd=f))
978 posix.close(f)
984 f = posix.open(posix.getcwd(), posix.O_RDONLY)
986 posix.rename(support.TESTFN + 'ren', support.TESTFN, src_dir_fd=f, dst_dir_fd=f)
988 posix.rename(support.TESTFN + 'ren', support.TESTFN)
991 posix.stat(support.TESTFN) # should not raise exception
993 posix.close(f)
997 f = posix.open(posix.getcwd(), posix.O_RDONLY)
999 posix.symlink(support.TESTFN, support.TESTFN + 'link', dir_fd=f)
1000 self.assertEqual(posix.readlink(support.TESTFN + 'link'), support.TESTFN)
1002 posix.close(f)
1007 f = posix.open(posix.getcwd(), posix.O_RDONLY)
1009 posix.stat(support.TESTFN + 'del') # should not raise exception
1011 posix.unlink(support.TESTFN + 'del', dir_fd=f)
1016 self.assertRaises(OSError, posix.stat, support.TESTFN + 'link')
1018 posix.close(f)
1024 f = posix.open(posix.getcwd(), posix.O_RDONLY)
1026 posix.mkfifo(support.TESTFN, stat.S_IRUSR | stat.S_IWUSR, dir_fd=f)
1027 self.assertTrue(stat.S_ISFIFO(posix.stat(support.TESTFN).st_mode))
1029 posix.close(f)
1031 requires_sched_h = unittest.skipUnless(hasattr(posix, 'sched_yield'),
1033 requires_sched_affinity = unittest.skipUnless(hasattr(posix, 'sched_setaffinity'),
1039 posix.sched_yield()
1042 @unittest.skipUnless(hasattr(posix, 'sched_get_priority_max'),
1046 pol = posix.SCHED_RR
1047 lo = posix.sched_get_priority_min(pol)
1048 hi = posix.sched_get_priority_max(pol)
1054 self.assertRaises(OSError, posix.sched_get_priority_min, -23)
1055 self.assertRaises(OSError, posix.sched_get_priority_max, -23)
1057 @unittest.skipUnless(hasattr(posix, 'sched_setscheduler'), "can't change scheduler")
1059 possible_schedulers = [sched for name, sched in posix.__dict__.items()
1061 mine = posix.sched_getscheduler(0)
1064 parent = posix.sched_getscheduler(os.getppid())
1070 self.assertRaises(OSError, posix.sched_getscheduler, -1)
1071 self.assertRaises(OSError, posix.sched_getparam, -1)
1072 param = posix.sched_getparam(0)
1075 # POSIX states that calling sched_setparam() or sched_setscheduler() on
1080 posix.sched_setscheduler(0, mine, param)
1081 posix.sched_setparam(0, param)
1085 self.assertRaises(OSError, posix.sched_setparam, -1, param)
1087 self.assertRaises(OSError, posix.sched_setscheduler, -1, mine, param)
1088 self.assertRaises(TypeError, posix.sched_setscheduler, 0, mine, None)
1089 self.assertRaises(TypeError, posix.sched_setparam, 0, 43)
1090 param = posix.sched_param(None)
1091 self.assertRaises(TypeError, posix.sched_setparam, 0, param)
1093 param = posix.sched_param(large)
1094 self.assertRaises(OverflowError, posix.sched_setparam, 0, param)
1095 param = posix.sched_param(sched_priority=-large)
1096 self.assertRaises(OverflowError, posix.sched_setparam, 0, param)
1098 @unittest.skipUnless(hasattr(posix, "sched_rr_get_interval"), "no function")
1101 interval = posix.sched_rr_get_interval(0)
1115 mask = posix.sched_getaffinity(0)
1118 self.assertRaises(OSError, posix.sched_getaffinity, -1)
1126 mask = posix.sched_getaffinity(0)
1130 posix.sched_setaffinity(0, mask)
1131 self.assertEqual(posix.sched_getaffinity(0), mask)
1132 self.assertRaises(OSError, posix.sched_setaffinity, 0, [])
1133 self.assertRaises(ValueError, posix.sched_setaffinity, 0, [-10])
1134 self.assertRaises(OverflowError, posix.sched_setaffinity, 0, [1<<128])
1135 self.assertRaises(OSError, posix.sched_setaffinity, -1, mask)
1139 posix.RTLD_LAZY
1140 posix.RTLD_NOW
1141 posix.RTLD_GLOBAL
1142 posix.RTLD_LOCAL
1228 if posix.getuid() != 0:
1230 if not hasattr(posix, 'getgroups'):
1231 raise unittest.SkipTest("need posix.getgroups")
1234 self.saved_groups = posix.getgroups()
1237 if hasattr(posix, 'setgroups'):
1238 posix.setgroups(self.saved_groups)
1239 elif hasattr(posix, 'initgroups'):
1240 name = pwd.getpwuid(posix.getuid()).pw_name
1241 posix.initgroups(name, self.saved_groups[0])
1243 @unittest.skipUnless(hasattr(posix, 'initgroups'),
1244 "test needs posix.initgroups()")
1249 name = pwd.getpwuid(posix.getuid()).pw_name
1250 posix.initgroups(name, g)
1251 self.assertIn(g, posix.getgroups())
1253 @unittest.skipUnless(hasattr(posix, 'setgroups'),
1254 "test needs posix.setgroups()")
1257 posix.setgroups(groups)
1258 self.assertListEqual(groups, posix.getgroups())
