Lines Matching refs:posix
1 "Test posix functions"
9 # Skip these tests if there is no posix module.
10 posix = import_helper.import_module('posix')
40 if not hasattr(posix, 'sched_getscheduler'):
43 posix.sched_getscheduler(0)
64 # test posix functions which take no arguments and have
73 posix_func = getattr(posix, name, None)
79 @unittest.skipUnless(hasattr(posix, 'getresuid'),
80 'test needs posix.getresuid()')
82 user_ids = posix.getresuid()
87 @unittest.skipUnless(hasattr(posix, 'getresgid'),
88 'test needs posix.getresgid()')
90 group_ids = posix.getresgid()
95 @unittest.skipUnless(hasattr(posix, 'setresuid'),
96 'test needs posix.setresuid()')
98 current_user_ids = posix.getresuid()
99 self.assertIsNone(posix.setresuid(*current_user_ids))
101 self.assertIsNone(posix.setresuid(-1, -1, -1))
103 @unittest.skipUnless(hasattr(posix, 'setresuid'),
104 'test needs posix.setresuid()')
107 current_user_ids = posix.getresuid()
110 self.assertRaises(OSError, posix.setresuid, *new_user_ids)
112 @unittest.skipUnless(hasattr(posix, 'setresgid'),
113 'test needs posix.setresgid()')
115 current_group_ids = posix.getresgid()
116 self.assertIsNone(posix.setresgid(*current_group_ids))
118 self.assertIsNone(posix.setresgid(-1, -1, -1))
120 @unittest.skipUnless(hasattr(posix, 'setresgid'),
121 'test needs posix.setresgid()')
124 current_group_ids = posix.getresgid()
127 self.assertRaises(OSError, posix.setresgid, *new_group_ids)
129 @unittest.skipUnless(hasattr(posix, 'initgroups'),
135 self.assertRaises(TypeError, posix.initgroups)
136 self.assertRaises(TypeError, posix.initgroups, None)
137 self.assertRaises(TypeError, posix.initgroups, 3, "foo")
138 self.assertRaises(TypeError, posix.initgroups, "foo", 3, object())
144 name = pwd.getpwuid(posix.getuid()).pw_name
149 posix.initgroups(name, 13)
155 @unittest.skipUnless(hasattr(posix, 'statvfs'),
156 'test needs posix.statvfs()')
158 self.assertTrue(posix.statvfs(os.curdir))
160 @unittest.skipUnless(hasattr(posix, 'fstatvfs'),
161 'test needs posix.fstatvfs()')
165 self.assertTrue(posix.fstatvfs(fp.fileno()))
166 self.assertTrue(posix.statvfs(fp.fileno()))
170 @unittest.skipUnless(hasattr(posix, 'ftruncate'),
171 'test needs posix.ftruncate()')
178 posix.ftruncate(fp.fileno(), 0)
182 @unittest.skipUnless(hasattr(posix, 'truncate'), "test needs posix.truncate()")
187 posix.truncate(os_helper.TESTFN, 0)
197 posix.execve(fp, [sys.executable, '-c', 'pass'], os.environ)
204 @unittest.skipUnless(hasattr(posix, 'waitid'), "test needs posix.waitid()")
210 posix.execve(sys.executable, [sys.executable, '-c', 'pass'], os.environ)
212 res = posix.waitid(posix.P_PID, pid, posix.WEXITED)
276 @unittest.skipUnless(hasattr(posix, 'lockf'), "test needs posix.lockf()")
282 posix.lockf(fd, posix.F_LOCK, 4)
284 posix.lockf(fd, posix.F_ULOCK, 4)
288 @unittest.skipUnless(hasattr(posix, 'pread'), "test needs posix.pread()")
294 self.assertEqual(b'es', posix.pread(fd, 2, 1))
296 self.assertEqual(b'te', posix.read(fd, 2))
300 @unittest.skipUnless(hasattr(posix, 'preadv'), "test needs posix.preadv()")
306 self.assertEqual(posix.preadv(fd, buf, 3), 10)
311 @unittest.skipUnless(hasattr(posix, 'preadv'), "test needs posix.preadv()")
312 @unittest.skipUnless(hasattr(posix, 'RWF_HIPRI'), "test needs posix.RWF_HIPRI")
318 self.assertEqual(posix.preadv(fd, buf, 3, os.RWF_HIPRI), 10)
333 @unittest.skipUnless(hasattr(posix, 'preadv'), "test needs posix.preadv()")
346 @unittest.skipUnless(hasattr(posix, 'pwrite'), "test needs posix.pwrite()")
352 posix.pwrite(fd, b'xx', 1)
353 self.assertEqual(b'txxt', posix.read(fd, 4))
357 @unittest.skipUnless(hasattr(posix, 'pwritev'), "test needs posix.pwritev()")
367 self.assertEqual(b'xxtest1tt2t3', posix.read(fd, 100))
371 @unittest.skipUnless(hasattr(posix, 'pwritev'), "test needs posix.pwritev()")
372 @unittest.skipUnless(hasattr(posix, 'os.RWF_SYNC'), "test needs os.RWF_SYNC")
382 self.assertEqual(b'xxtest1tt2', posix.read(fd, 100))
386 @unittest.skipUnless(hasattr(posix, 'pwritev'), "test needs posix.pwritev()")
397 @unittest.skipUnless(hasattr(posix, 'posix_fallocate'),
398 "test needs posix.posix_fallocate()")
402 posix.posix_fallocate(fd, 0, 10)
417 @unittest.skipUnless(hasattr(posix, 'posix_fallocate'),
418 "test needs posix.posix_fallocate()")
421 posix.posix_fallocate(-42, 0, 10)
426 @unittest.skipUnless(hasattr(posix, 'posix_fadvise'),
427 "test needs posix.posix_fadvise()")
431 posix.posix_fadvise(fd, 0, 0, posix.POSIX_FADV_WILLNEED)
435 @unittest.skipUnless(hasattr(posix, 'posix_fadvise'),
436 "test needs posix.posix_fadvise()")
439 posix.posix_fadvise(-42, 0, 0, posix.POSIX_FADV_WILLNEED)
449 posix.utime(fd)
450 posix.utime(fd, None)
451 self.assertRaises(TypeError, posix.utime, fd, (None, None))
452 self.assertRaises(TypeError, posix.utime, fd, (now, None))
453 self.assertRaises(TypeError, posix.utime, fd, (None, now))
454 posix.utime(fd, (int(now), int(now)))
455 posix.utime(fd, (now, now))
456 self.assertRaises(ValueError, posix.utime, fd, (now, now), ns=(now, now))
457 self.assertRaises(ValueError, posix.utime, fd, (now, 0), ns=(None, None))
458 self.assertRaises(ValueError, posix.utime, fd, (None, None), ns=(now, 0))
459 posix.utime(fd, (int(now), int((now - int(now)) * 1e9)))
460 posix.utime(fd, ns=(int(now), int((now - int(now)) * 1e9)))
468 posix.utime(os_helper.TESTFN, None, follow_symlinks=False)
469 self.assertRaises(TypeError, posix.utime, os_helper.TESTFN,
471 self.assertRaises(TypeError, posix.utime, os_helper.TESTFN,
473 self.assertRaises(TypeError, posix.utime, os_helper.TESTFN,
475 posix.utime(os_helper.TESTFN, (int(now), int(now)),
477 posix.utime(os_helper.TESTFN, (now, now), follow_symlinks=False)
478 posix.utime(os_helper.TESTFN, follow_symlinks=False)
480 @unittest.skipUnless(hasattr(posix, 'writev'), "test needs posix.writev()")
488 self.assertEqual(b'test1tt2t3', posix.read(fd, 10))
492 size = posix.writev(fd, [])
502 @unittest.skipUnless(hasattr(posix, 'writev'), "test needs posix.writev()")
513 @unittest.skipUnless(hasattr(posix, 'readv'), "test needs posix.readv()")
520 self.assertEqual(posix.readv(fd, buf), 10)
525 size = posix.readv(fd, [])
535 @unittest.skipUnless(hasattr(posix, 'readv'), "test needs posix.readv()")
548 @unittest.skipUnless(hasattr(posix, 'dup'),
549 'test needs posix.dup()')
554 fd = posix.dup(fp.fileno())
560 @unittest.skipUnless(hasattr(posix, 'confstr'),
561 'test needs posix.confstr()')
563 self.assertRaises(ValueError, posix.confstr, "CS_garbage")
564 self.assertEqual(len(posix.confstr("CS_PATH")) > 0, True)
566 @unittest.skipUnless(hasattr(posix, 'dup2'),
567 'test needs posix.dup2()')
573 posix.dup2(fp1.fileno(), fp2.fileno())
586 @unittest.skipUnless(hasattr(posix, 'O_EXLOCK'),
587 'test needs posix.O_EXLOCK')
595 if hasattr(posix, "O_SHLOCK"):
602 @unittest.skipUnless(hasattr(posix, 'O_SHLOCK'),
603 'test needs posix.O_SHLOCK')
612 if hasattr(posix, "O_EXLOCK"):
619 @unittest.skipUnless(hasattr(posix, 'fstat'),
620 'test needs posix.fstat()')
624 self.assertTrue(posix.fstat(fp.fileno()))
625 self.assertTrue(posix.stat(fp.fileno()))
629 posix.stat, float(fp.fileno()))
634 self.assertTrue(posix.stat(os_helper.TESTFN))
635 self.assertTrue(posix.stat(os.fsencode(os_helper.TESTFN)))
639 posix.stat, bytearray(os.fsencode(os_helper.TESTFN)))
642 posix.stat, None)
645 posix.stat, list(os_helper.TESTFN))
648 posix.stat, list(os.fsencode(os_helper.TESTFN)))
650 @unittest.skipUnless(hasattr(posix, 'mkfifo'), "don't have mkfifo()")
659 posix.mkfifo(fifo_path, stat.S_IRUSR | stat.S_IWUSR)
661 self.skipTest('posix.mkfifo(): %s' % e)
662 self.assertTrue(stat.S_ISFIFO(posix.stat(fifo_path).st_mode))
664 @unittest.skipUnless(hasattr(posix, 'mknod') and hasattr(stat, 'S_IFIFO'),
672 posix.mknod(os_helper.TESTFN, mode, 0)
678 self.assertTrue(stat.S_ISFIFO(posix.stat(os_helper.TESTFN).st_mode))
683 posix.mknod(path=os_helper.TESTFN, mode=mode, device=0,
688 @unittest.skipUnless(hasattr(posix, 'makedev'), 'test needs posix.makedev()')
690 st = posix.stat(os_helper.TESTFN)
695 major = posix.major(dev)
698 self.assertEqual(posix.major(dev), major)
699 self.assertRaises(TypeError, posix.major, float(dev))
700 self.assertRaises(TypeError, posix.major)
701 self.assertRaises((ValueError, OverflowError), posix.major, -1)
703 minor = posix.minor(dev)
706 self.assertEqual(posix.minor(dev), minor)
707 self.assertRaises(TypeError, posix.minor, float(dev))
708 self.assertRaises(TypeError, posix.minor)
709 self.assertRaises((ValueError, OverflowError), posix.minor, -1)
711 self.assertEqual(posix.makedev(major, minor), dev)
712 self.assertRaises(TypeError, posix.makedev, float(major), minor)
713 self.assertRaises(TypeError, posix.makedev, major, float(minor))
714 self.assertRaises(TypeError, posix.makedev, major)
715 self.assertRaises(TypeError, posix.makedev)
794 self.assertRaises(OSError, posix.chown, os_helper.TESTFN, -1, -1)
798 self._test_all_chown_common(posix.chown, os_helper.TESTFN, posix.stat)
801 @unittest.skipUnless(hasattr(posix, 'fchown'), "test needs os.fchown()")
810 self._test_all_chown_common(posix.fchown, fd,
811 getattr(posix, 'fstat', None))
816 @unittest.skipUnless(hasattr(posix, 'lchown'), "test needs os.lchown()")
821 self._test_all_chown_common(posix.lchown, os_helper.TESTFN,
822 getattr(posix, 'lstat', None))
824 @unittest.skipUnless(hasattr(posix, 'chdir'), 'test needs posix.chdir()')
826 posix.chdir(os.curdir)
827 self.assertRaises(OSError, posix.chdir, os_helper.TESTFN)
830 self.assertIn(os_helper.TESTFN, posix.listdir(os.curdir))
835 self.assertIn(os_helper.TESTFN, posix.listdir())
840 self.assertIn(os.fsencode(os_helper.TESTFN), posix.listdir(b'.'))
845 names = posix.listdir(cls(b'.'))
850 @unittest.skipUnless(posix.listdir in os.supports_fd,
851 "test needs fd support for posix.listdir()")
853 f = posix.open(posix.getcwd(), posix.O_RDONLY)
854 self.addCleanup(posix.close, f)
856 sorted(posix.listdir('.')),
857 sorted(posix.listdir(f))
861 sorted(posix.listdir('.')),
862 sorted(posix.listdir(f))
865 @unittest.skipUnless(hasattr(posix, 'access'), 'test needs posix.access()')
867 self.assertTrue(posix.access(os_helper.TESTFN, os.R_OK))
869 @unittest.skipUnless(hasattr(posix, 'umask'), 'test needs posix.umask()')
871 old_mask = posix.umask(0)
873 posix.umask(old_mask)
875 @unittest.skipUnless(hasattr(posix, 'strerror'),
876 'test needs posix.strerror()')
878 self.assertTrue(posix.strerror(0))
880 @unittest.skipUnless(hasattr(posix, 'pipe'), 'test needs posix.pipe()')
882 reader, writer = posix.pipe()
923 @unittest.skipUnless(hasattr(posix, 'utime'), 'test needs posix.utime()')
926 posix.utime(os_helper.TESTFN, None)
927 self.assertRaises(TypeError, posix.utime,
929 self.assertRaises(TypeError, posix.utime,
931 self.assertRaises(TypeError, posix.utime,
933 posix.utime(os_helper.TESTFN, (int(now), int(now)))
934 posix.utime(os_helper.TESTFN, (now, now))
958 posix.chflags(target_file, st.st_flags)
960 @unittest.skipUnless(hasattr(posix, 'chflags'), 'test needs os.chflags()')
962 self._test_chflags_regular_file(posix.chflags, os_helper.TESTFN)
964 @unittest.skipUnless(hasattr(posix, 'lchflags'), 'test needs os.lchflags()')
966 self._test_chflags_regular_file(posix.lchflags, os_helper.TESTFN)
967 self._test_chflags_regular_file(posix.chflags, os_helper.TESTFN,
970 @unittest.skipUnless(hasattr(posix, 'lchflags'), 'test needs os.lchflags()')
981 return posix.chflags(path, flags, follow_symlinks=False)
983 for fn in (posix.lchflags, chflags_nofollow):
1008 for k, v in posix.environ.items():
1026 @unittest.skipUnless(hasattr(posix, 'getcwd'), 'test needs posix.getcwd()')
1062 @unittest.skipUnless(hasattr(posix, 'getgrouplist'), "test needs posix.getgrouplist()")
1068 self.assertIn(group, posix.getgrouplist(user, group))
1096 # posix.getgroups() includes the effective gid.
1097 symdiff = idg_groups.symmetric_difference(posix.getgroups())
1098 self.assertTrue(not symdiff or symdiff == {posix.getegid()})
1110 requires_sched_h = unittest.skipUnless(hasattr(posix, 'sched_yield'),
1112 requires_sched_affinity = unittest.skipUnless(hasattr(posix, 'sched_setaffinity'),
1118 posix.sched_yield()
1121 @unittest.skipUnless(hasattr(posix, 'sched_get_priority_max'),
1125 pol = posix.SCHED_RR
1126 lo = posix.sched_get_priority_min(pol)
1127 hi = posix.sched_get_priority_max(pol)
1133 self.assertRaises(OSError, posix.sched_get_priority_min, -23)
1134 self.assertRaises(OSError, posix.sched_get_priority_max, -23)
1138 possible_schedulers = [sched for name, sched in posix.__dict__.items()
1140 mine = posix.sched_getscheduler(0)
1143 parent = posix.sched_getscheduler(os.getppid())
1149 self.assertRaises(OSError, posix.sched_getscheduler, -1)
1150 self.assertRaises(OSError, posix.sched_getparam, -1)
1151 param = posix.sched_getparam(0)
1159 posix.sched_setscheduler(0, mine, param)
1160 posix.sched_setparam(0, param)
1164 self.assertRaises(OSError, posix.sched_setparam, -1, param)
1166 self.assertRaises(OSError, posix.sched_setscheduler, -1, mine, param)
1167 self.assertRaises(TypeError, posix.sched_setscheduler, 0, mine, None)
1168 self.assertRaises(TypeError, posix.sched_setparam, 0, 43)
1169 param = posix.sched_param(None)
1170 self.assertRaises(TypeError, posix.sched_setparam, 0, param)
1172 param = posix.sched_param(large)
1173 self.assertRaises(OverflowError, posix.sched_setparam, 0, param)
1174 param = posix.sched_param(sched_priority=-large)
1175 self.assertRaises(OverflowError, posix.sched_setparam, 0, param)
1177 @unittest.skipUnless(hasattr(posix, "sched_rr_get_interval"), "no function")
1180 interval = posix.sched_rr_get_interval(0)
1194 mask = posix.sched_getaffinity(0)
1199 self.assertRaises(OSError, posix.sched_getaffinity, -1)
1207 mask = posix.sched_getaffinity(0)
1211 posix.sched_setaffinity(0, mask)
1212 self.assertEqual(posix.sched_getaffinity(0), mask)
1213 self.assertRaises(OSError, posix.sched_setaffinity, 0, [])
1214 self.assertRaises(ValueError, posix.sched_setaffinity, 0, [-10])
1215 self.assertRaises(ValueError, posix.sched_setaffinity, 0, map(int, "0X"))
1216 self.assertRaises(OverflowError, posix.sched_setaffinity, 0, [1<<128])
1219 self.assertRaises(OSError, posix.sched_setaffinity, -1, mask)
1224 posix.RTLD_LAZY
1225 posix.RTLD_NOW
1226 posix.RTLD_GLOBAL
1227 posix.RTLD_LOCAL
1322 # tests for the posix *at functions follow
1331 posix.mkdir(base_dir)
1332 self.addCleanup(posix.rmdir, base_dir)
1342 self.addCleanup(posix.unlink, fullname)
1348 self.assertTrue(posix.access(name, os.R_OK, dir_fd=dir_fd))
1353 posix.chmod(fullname, stat.S_IRUSR)
1354 posix.chmod(name, stat.S_IRUSR | stat.S_IWUSR, dir_fd=dir_fd)
1355 s = posix.stat(fullname)
1364 posix.chown(name, os.getuid(), os.getgid(), dir_fd=dir_fd)
1371 self.addCleanup(posix.unlink, fullname)
1373 s1 = posix.stat(fullname)
1374 s2 = posix.stat(name, dir_fd=dir_fd)
1376 s2 = posix.stat(fullname, dir_fd=None)
1380 posix.stat, name, dir_fd=posix.getcwd())
1382 posix.stat, name, dir_fd=float(dir_fd))
1384 posix.stat, name, dir_fd=10**20)
1390 posix.utime(name, None, dir_fd=dir_fd)
1391 posix.utime(name, dir_fd=dir_fd)
1392 self.assertRaises(TypeError, posix.utime, name,
1394 self.assertRaises(TypeError, posix.utime, name,
1396 self.assertRaises(TypeError, posix.utime, name,
1398 self.assertRaises(TypeError, posix.utime, name,
1400 self.assertRaises(TypeError, posix.utime, name,
1402 posix.utime(name, (int(now), int(now)), dir_fd=dir_fd)
1403 posix.utime(name, (now, now), dir_fd=dir_fd)
1404 posix.utime(name,
1406 posix.utime(name, dir_fd=dir_fd,
1412 posix.utime(name, follow_symlinks=False, dir_fd=dir_fd)
1429 posix.link(name, linkname, src_dir_fd=dir_fd, dst_dir_fd=dir_fd2)
1431 self.skipTest('posix.link(): %s' % e)
1432 self.addCleanup(posix.unlink, fulllinkname)
1434 self.assertEqual(posix.stat(fullname)[1],
1435 posix.stat(fulllinkname)[1])
1440 posix.mkdir(name, dir_fd=dir_fd)
1441 self.addCleanup(posix.rmdir, fullname)
1442 posix.stat(fullname) # should not raise exception
1454 posix.mknod(name, mode, 0, dir_fd=dir_fd)
1460 self.addCleanup(posix.unlink, fullname)
1461 self.assertTrue(stat.S_ISFIFO(posix.stat(fullname).st_mode))
1468 self.addCleanup(posix.unlink, fullname)
1469 fd = posix.open(name, posix.O_RDONLY, dir_fd=dir_fd)
1471 res = posix.read(fd, 9)
1474 posix.close(fd)
1481 self.addCleanup(posix.unlink, fullname)
1482 self.assertEqual(posix.readlink(name, dir_fd=dir_fd), 'symlink')
1488 posix.rename(name, name2,
1490 posix.stat(fullname2) # should not raise exception
1491 posix.rename(fullname2, fullname)
1496 posix.symlink('symlink', name, dir_fd=dir_fd)
1497 self.addCleanup(posix.unlink, fullname)
1498 self.assertEqual(posix.readlink(fullname), 'symlink')
1504 posix.stat(fullname) # should not raise exception
1506 posix.unlink(name, dir_fd=dir_fd)
1507 self.assertRaises(OSError, posix.stat, fullname)
1509 self.addCleanup(posix.unlink, fullname)
1516 posix.mkfifo(name, stat.S_IRUSR | stat.S_IWUSR, dir_fd=dir_fd)
1518 self.skipTest('posix.mkfifo(): %s' % e)
1519 self.addCleanup(posix.unlink, fullname)
1520 self.assertTrue(stat.S_ISFIFO(posix.stat(fullname).st_mode))
1526 if posix.getuid() != 0:
1528 if not hasattr(posix, 'getgroups'):
1529 raise unittest.SkipTest("need posix.getgroups")
1532 self.saved_groups = posix.getgroups()
1535 if hasattr(posix, 'setgroups'):
1536 posix.setgroups(self.saved_groups)
1537 elif hasattr(posix, 'initgroups'):
1538 name = pwd.getpwuid(posix.getuid()).pw_name
1539 posix.initgroups(name, self.saved_groups[0])
1541 @unittest.skipUnless(hasattr(posix, 'initgroups'),
1542 "test needs posix.initgroups()")
1547 name = pwd.getpwuid(posix.getuid()).pw_name
1548 posix.initgroups(name, g)
1549 self.assertIn(g, posix.getgroups())
1551 @unittest.skipUnless(hasattr(posix, 'setgroups'),
1552 "test needs posix.setgroups()")
1555 posix.setgroups(groups)
1556 self.assertListEqual(groups, posix.getgroups())
1908 spawn_func = getattr(posix, 'posix_spawn', None)
1913 spawn_func = getattr(posix, 'posix_spawnp', None)
1980 self.assertIn("HAVE_FSTATAT", posix._have_functions)
1983 self.assertNotIn("HAVE_FSTATAT", posix._have_functions)
1991 self.assertIn("HAVE_FACCESSAT", posix._have_functions)
1994 self.assertNotIn("HAVE_FACCESSAT", posix._have_functions)
2008 self.assertIn("HAVE_FCHMODAT", posix._have_functions)
2011 self.assertNotIn("HAVE_FCHMODAT", posix._have_functions)
2012 self.assertIn("HAVE_LCHMOD", posix._have_functions)
2020 self.assertIn("HAVE_FCHOWNAT", posix._have_functions)
2023 self.assertNotIn("HAVE_FCHOWNAT", posix._have_functions)
2024 self.assertIn("HAVE_LCHOWN", posix._have_functions)
2032 self.assertIn("HAVE_LINKAT", posix._have_functions)
2035 self.assertNotIn("HAVE_LINKAT", posix._have_functions)
2071 self.assertIn("HAVE_FDOPENDIR", posix._have_functions)
2074 self.assertNotIn("HAVE_FDOPENDIR", posix._have_functions)
2085 self.assertIn("HAVE_MKDIRAT", posix._have_functions)
2088 self.assertNotIn("HAVE_MKDIRAT", posix._have_functions)
2096 self.assertIn("HAVE_MKFIFOAT", posix._have_functions)
2099 self.assertNotIn("HAVE_MKFIFOAT", posix._have_functions)
2107 self.assertIn("HAVE_MKNODAT", posix._have_functions)
2110 self.assertNotIn("HAVE_MKNODAT", posix._have_functions)
2118 self.assertIn("HAVE_RENAMEAT", posix._have_functions)
2121 self.assertNotIn("HAVE_RENAMEAT", posix._have_functions)
2138 self.assertIn("HAVE_UNLINKAT", posix._have_functions)
2141 self.assertNotIn("HAVE_UNLINKAT", posix._have_functions)
2152 self.assertIn("HAVE_OPENAT", posix._have_functions)
2155 self.assertNotIn("HAVE_OPENAT", posix._have_functions)
2163 self.assertIn("HAVE_READLINKAT", posix._have_functions)
2166 self.assertNotIn("HAVE_READLINKAT", posix._have_functions)
2174 self.assertIn("HAVE_SYMLINKAT", posix._have_functions)
2177 self.assertNotIn("HAVE_SYMLINKAT", posix._have_functions)
2186 self.assertIn("HAVE_FUTIMENS", posix._have_functions)
2187 self.assertIn("HAVE_UTIMENSAT", posix._have_functions)
2190 self.assertNotIn("HAVE_FUTIMENS", posix._have_functions)
2191 self.assertNotIn("HAVE_UTIMENSAT", posix._have_functions)