Lines Matching full:posix
1 "Test posix functions"
9 # Skip these tests if there is no posix module.
10 posix = import_helper.import_module('posix') variable
33 if not hasattr(posix, 'sched_getscheduler'):
36 posix.sched_getscheduler(0)
42 requires_sched = unittest.skipUnless(_supports_sched(), 'requires POSIX scheduler API')
63 # test posix functions which take no arguments and have
72 posix_func = getattr(posix, name, None)
77 @unittest.skipUnless(hasattr(posix, 'getresuid'),
78 'test needs posix.getresuid()')
80 user_ids = posix.getresuid()
85 @unittest.skipUnless(hasattr(posix, 'getresgid'),
86 'test needs posix.getresgid()')
88 group_ids = posix.getresgid()
93 @unittest.skipUnless(hasattr(posix, 'setresuid'),
94 'test needs posix.setresuid()')
96 current_user_ids = posix.getresuid()
97 self.assertIsNone(posix.setresuid(*current_user_ids))
99 self.assertIsNone(posix.setresuid(-1, -1, -1))
101 @unittest.skipUnless(hasattr(posix, 'setresuid'),
102 'test needs posix.setresuid()')
105 current_user_ids = posix.getresuid()
108 self.assertRaises(OSError, posix.setresuid, *new_user_ids)
110 @unittest.skipUnless(hasattr(posix, 'setresgid'),
111 'test needs posix.setresgid()')
113 current_group_ids = posix.getresgid()
114 self.assertIsNone(posix.setresgid(*current_group_ids))
116 self.assertIsNone(posix.setresgid(-1, -1, -1))
118 @unittest.skipUnless(hasattr(posix, 'setresgid'),
119 'test needs posix.setresgid()')
122 current_group_ids = posix.getresgid()
125 self.assertRaises(OSError, posix.setresgid, *new_group_ids)
127 @unittest.skipUnless(hasattr(posix, 'initgroups'),
132 self.assertRaises(TypeError, posix.initgroups)
133 self.assertRaises(TypeError, posix.initgroups, None)
134 self.assertRaises(TypeError, posix.initgroups, 3, "foo")
135 self.assertRaises(TypeError, posix.initgroups, "foo", 3, object())
141 name = pwd.getpwuid(posix.getuid()).pw_name
146 posix.initgroups(name, 13)
152 @unittest.skipUnless(hasattr(posix, 'statvfs'),
153 'test needs posix.statvfs()')
155 self.assertTrue(posix.statvfs(os.curdir))
157 @unittest.skipUnless(hasattr(posix, 'fstatvfs'),
158 'test needs posix.fstatvfs()')
162 self.assertTrue(posix.fstatvfs(fp.fileno()))
163 self.assertTrue(posix.statvfs(fp.fileno()))
167 @unittest.skipUnless(hasattr(posix, 'ftruncate'),
168 'test needs posix.ftruncate()')
175 posix.ftruncate(fp.fileno(), 0)
179 @unittest.skipUnless(hasattr(posix, 'truncate'), "test needs posix.truncate()")
184 posix.truncate(os_helper.TESTFN, 0)
194 posix.execve(fp, [sys.executable, '-c', 'pass'], os.environ)
201 @unittest.skipUnless(hasattr(posix, 'waitid'), "test needs posix.waitid()")
207 posix.execve(sys.executable, [sys.executable, '-c', 'pass'], os.environ)
209 res = posix.waitid(posix.P_PID, pid, posix.WEXITED)
273 @unittest.skipUnless(hasattr(posix, 'lockf'), "test needs posix.lockf()")
279 posix.lockf(fd, posix.F_LOCK, 4)
281 posix.lockf(fd, posix.F_ULOCK, 4)
285 @unittest.skipUnless(hasattr(posix, 'pread'), "test needs posix.pread()")
291 self.assertEqual(b'es', posix.pread(fd, 2, 1))
293 self.assertEqual(b'te', posix.read(fd, 2))
297 @unittest.skipUnless(hasattr(posix, 'preadv'), "test needs posix.preadv()")
303 self.assertEqual(posix.preadv(fd, buf, 3), 10)
308 @unittest.skipUnless(hasattr(posix, 'preadv'), "test needs posix.preadv()")
309 @unittest.skipUnless(hasattr(posix, 'RWF_HIPRI'), "test needs posix.RWF_HIPRI")
315 self.assertEqual(posix.preadv(fd, buf, 3, os.RWF_HIPRI), 10)
330 @unittest.skipUnless(hasattr(posix, 'preadv'), "test needs posix.preadv()")
343 @unittest.skipUnless(hasattr(posix, 'pwrite'), "test needs posix.pwrite()")
349 posix.pwrite(fd, b'xx', 1)
350 self.assertEqual(b'txxt', posix.read(fd, 4))
354 @unittest.skipUnless(hasattr(posix, 'pwritev'), "test needs posix.pwritev()")
364 self.assertEqual(b'xxtest1tt2t3', posix.read(fd, 100))
368 @unittest.skipUnless(hasattr(posix, 'pwritev'), "test needs posix.pwritev()")
369 @unittest.skipUnless(hasattr(posix, 'os.RWF_SYNC'), "test needs os.RWF_SYNC")
379 self.assertEqual(b'xxtest1tt2', posix.read(fd, 100))
383 @unittest.skipUnless(hasattr(posix, 'pwritev'), "test needs posix.pwritev()")
394 @unittest.skipUnless(hasattr(posix, 'posix_fallocate'),
395 "test needs posix.posix_fallocate()")
399 posix.posix_fallocate(fd, 0, 10)
414 @unittest.skipUnless(hasattr(posix, 'posix_fallocate'),
415 "test needs posix.posix_fallocate()")
418 posix.posix_fallocate(-42, 0, 10)
423 @unittest.skipUnless(hasattr(posix, 'posix_fadvise'),
424 "test needs posix.posix_fadvise()")
428 posix.posix_fadvise(fd, 0, 0, posix.POSIX_FADV_WILLNEED)
432 @unittest.skipUnless(hasattr(posix, 'posix_fadvise'),
433 "test needs posix.posix_fadvise()")
436 posix.posix_fadvise(-42, 0, 0, posix.POSIX_FADV_WILLNEED)
446 posix.utime(fd)
447 posix.utime(fd, None)
448 self.assertRaises(TypeError, posix.utime, fd, (None, None))
449 self.assertRaises(TypeError, posix.utime, fd, (now, None))
450 self.assertRaises(TypeError, posix.utime, fd, (None, now))
451 posix.utime(fd, (int(now), int(now)))
452 posix.utime(fd, (now, now))
453 self.assertRaises(ValueError, posix.utime, fd, (now, now), ns=(now, now))
454 self.assertRaises(ValueError, posix.utime, fd, (now, 0), ns=(None, None))
455 self.assertRaises(ValueError, posix.utime, fd, (None, None), ns=(now, 0))
456 posix.utime(fd, (int(now), int((now - int(now)) * 1e9)))
457 posix.utime(fd, ns=(int(now), int((now - int(now)) * 1e9)))
465 posix.utime(os_helper.TESTFN, None, follow_symlinks=False)
466 self.assertRaises(TypeError, posix.utime, os_helper.TESTFN,
468 self.assertRaises(TypeError, posix.utime, os_helper.TESTFN,
470 self.assertRaises(TypeError, posix.utime, os_helper.TESTFN,
472 posix.utime(os_helper.TESTFN, (int(now), int(now)),
474 posix.utime(os_helper.TESTFN, (now, now), follow_symlinks=False)
475 posix.utime(os_helper.TESTFN, follow_symlinks=False)
477 @unittest.skipUnless(hasattr(posix, 'writev'), "test needs posix.writev()")
485 self.assertEqual(b'test1tt2t3', posix.read(fd, 10))
489 size = posix.writev(fd, [])
499 @unittest.skipUnless(hasattr(posix, 'writev'), "test needs posix.writev()")
510 @unittest.skipUnless(hasattr(posix, 'readv'), "test needs posix.readv()")
517 self.assertEqual(posix.readv(fd, buf), 10)
522 size = posix.readv(fd, [])
532 @unittest.skipUnless(hasattr(posix, 'readv'), "test needs posix.readv()")
545 @unittest.skipUnless(hasattr(posix, 'dup'),
546 'test needs posix.dup()')
550 fd = posix.dup(fp.fileno())
556 @unittest.skipUnless(hasattr(posix, 'confstr'),
557 'test needs posix.confstr()')
559 self.assertRaises(ValueError, posix.confstr, "CS_garbage")
560 self.assertEqual(len(posix.confstr("CS_PATH")) > 0, True)
562 @unittest.skipUnless(hasattr(posix, 'dup2'),
563 'test needs posix.dup2()')
568 posix.dup2(fp1.fileno(), fp2.fileno())
580 @unittest.skipUnless(hasattr(posix, 'O_EXLOCK'),
581 'test needs posix.O_EXLOCK')
589 if hasattr(posix, "O_SHLOCK"):
596 @unittest.skipUnless(hasattr(posix, 'O_SHLOCK'),
597 'test needs posix.O_SHLOCK')
606 if hasattr(posix, "O_EXLOCK"):
613 @unittest.skipUnless(hasattr(posix, 'fstat'),
614 'test needs posix.fstat()')
618 self.assertTrue(posix.fstat(fp.fileno()))
619 self.assertTrue(posix.stat(fp.fileno()))
623 posix.stat, float(fp.fileno()))
628 self.assertTrue(posix.stat(os_helper.TESTFN))
629 self.assertTrue(posix.stat(os.fsencode(os_helper.TESTFN)))
633 posix.stat, bytearray(os.fsencode(os_helper.TESTFN)))
636 posix.stat, None)
639 posix.stat, list(os_helper.TESTFN))
642 posix.stat, list(os.fsencode(os_helper.TESTFN)))
644 @unittest.skipUnless(hasattr(posix, 'mkfifo'), "don't have mkfifo()")
653 posix.mkfifo(fifo_path, stat.S_IRUSR | stat.S_IWUSR)
655 self.skipTest('posix.mkfifo(): %s' % e)
656 self.assertTrue(stat.S_ISFIFO(posix.stat(fifo_path).st_mode))
658 @unittest.skipUnless(hasattr(posix, 'mknod') and hasattr(stat, 'S_IFIFO'),
662 # by POSIX).
666 posix.mknod(os_helper.TESTFN, mode, 0)
672 self.assertTrue(stat.S_ISFIFO(posix.stat(os_helper.TESTFN).st_mode))
677 posix.mknod(path=os_helper.TESTFN, mode=mode, device=0,
682 @unittest.skipUnless(hasattr(posix, 'makedev'), 'test needs posix.makedev()')
684 st = posix.stat(os_helper.TESTFN)
689 major = posix.major(dev)
692 self.assertEqual(posix.major(dev), major)
693 self.assertRaises(TypeError, posix.major, float(dev))
694 self.assertRaises(TypeError, posix.major)
695 self.assertRaises((ValueError, OverflowError), posix.major, -1)
697 minor = posix.minor(dev)
700 self.assertEqual(posix.minor(dev), minor)
701 self.assertRaises(TypeError, posix.minor, float(dev))
702 self.assertRaises(TypeError, posix.minor)
703 self.assertRaises((ValueError, OverflowError), posix.minor, -1)
705 self.assertEqual(posix.makedev(major, minor), dev)
706 self.assertRaises(TypeError, posix.makedev, float(major), minor)
707 self.assertRaises(TypeError, posix.makedev, major, float(minor))
708 self.assertRaises(TypeError, posix.makedev, major)
709 self.assertRaises(TypeError, posix.makedev)
779 @unittest.skipUnless(hasattr(posix, 'chown'), "test needs os.chown()")
783 self.assertRaises(OSError, posix.chown, os_helper.TESTFN, -1, -1)
787 self._test_all_chown_common(posix.chown, os_helper.TESTFN, posix.stat)
789 @unittest.skipUnless(hasattr(posix, 'fchown'), "test needs os.fchown()")
797 self._test_all_chown_common(posix.fchown, fd,
798 getattr(posix, 'fstat', None))
802 @unittest.skipUnless(hasattr(posix, 'lchown'), "test needs os.lchown()")
807 self._test_all_chown_common(posix.lchown, os_helper.TESTFN,
808 getattr(posix, 'lstat', None))
810 @unittest.skipUnless(hasattr(posix, 'chdir'), 'test needs posix.chdir()')
812 posix.chdir(os.curdir)
813 self.assertRaises(OSError, posix.chdir, os_helper.TESTFN)
816 self.assertIn(os_helper.TESTFN, posix.listdir(os.curdir))
821 self.assertIn(os_helper.TESTFN, posix.listdir())
826 self.assertIn(os.fsencode(os_helper.TESTFN), posix.listdir(b'.'))
831 names = posix.listdir(cls(b'.'))
836 @unittest.skipUnless(posix.listdir in os.supports_fd,
837 "test needs fd support for posix.listdir()")
839 f = posix.open(posix.getcwd(), posix.O_RDONLY)
840 self.addCleanup(posix.close, f)
842 sorted(posix.listdir('.')),
843 sorted(posix.listdir(f))
847 sorted(posix.listdir('.')),
848 sorted(posix.listdir(f))
851 @unittest.skipUnless(hasattr(posix, 'access'), 'test needs posix.access()')
853 self.assertTrue(posix.access(os_helper.TESTFN, os.R_OK))
855 @unittest.skipUnless(hasattr(posix, 'umask'), 'test needs posix.umask()')
857 old_mask = posix.umask(0)
859 posix.umask(old_mask)
861 @unittest.skipUnless(hasattr(posix, 'strerror'),
862 'test needs posix.strerror()')
864 self.assertTrue(posix.strerror(0))
866 @unittest.skipUnless(hasattr(posix, 'pipe'), 'test needs posix.pipe()')
868 reader, writer = posix.pipe()
909 @unittest.skipUnless(hasattr(posix, 'utime'), 'test needs posix.utime()')
912 posix.utime(os_helper.TESTFN, None)
913 self.assertRaises(TypeError, posix.utime,
915 self.assertRaises(TypeError, posix.utime,
917 self.assertRaises(TypeError, posix.utime,
919 posix.utime(os_helper.TESTFN, (int(now), int(now)))
920 posix.utime(os_helper.TESTFN, (now, now))
944 posix.chflags(target_file, st.st_flags)
946 @unittest.skipUnless(hasattr(posix, 'chflags'), 'test needs os.chflags()')
948 self._test_chflags_regular_file(posix.chflags, os_helper.TESTFN)
950 @unittest.skipUnless(hasattr(posix, 'lchflags'), 'test needs os.lchflags()')
952 self._test_chflags_regular_file(posix.lchflags, os_helper.TESTFN)
953 self._test_chflags_regular_file(posix.chflags, os_helper.TESTFN,
956 @unittest.skipUnless(hasattr(posix, 'lchflags'), 'test needs os.lchflags()')
967 return posix.chflags(path, flags, follow_symlinks=False)
969 for fn in (posix.lchflags, chflags_nofollow):
994 for k, v in posix.environ.items():
1012 @unittest.skipUnless(hasattr(posix, 'getcwd'), 'test needs posix.getcwd()')
1048 @unittest.skipUnless(hasattr(posix, 'getgrouplist'), "test needs posix.getgrouplist()")
1054 self.assertIn(group, posix.getgrouplist(user, group))
1081 # posix.getgroups() includes the effective gid.
1082 symdiff = idg_groups.symmetric_difference(posix.getgroups())
1083 self.assertTrue(not symdiff or symdiff == {posix.getegid()})
1095 requires_sched_h = unittest.skipUnless(hasattr(posix, 'sched_yield'),
1097 requires_sched_affinity = unittest.skipUnless(hasattr(posix, 'sched_setaffinity'),
1103 posix.sched_yield()
1106 @unittest.skipUnless(hasattr(posix, 'sched_get_priority_max'),
1110 pol = posix.SCHED_RR
1111 lo = posix.sched_get_priority_min(pol)
1112 hi = posix.sched_get_priority_max(pol)
1118 self.assertRaises(OSError, posix.sched_get_priority_min, -23)
1119 self.assertRaises(OSError, posix.sched_get_priority_max, -23)
1123 possible_schedulers = [sched for name, sched in posix.__dict__.items()
1125 mine = posix.sched_getscheduler(0)
1128 parent = posix.sched_getscheduler(os.getppid())
1134 self.assertRaises(OSError, posix.sched_getscheduler, -1)
1135 self.assertRaises(OSError, posix.sched_getparam, -1)
1136 param = posix.sched_getparam(0)
1139 # POSIX states that calling sched_setparam() or sched_setscheduler() on
1144 posix.sched_setscheduler(0, mine, param)
1145 posix.sched_setparam(0, param)
1149 self.assertRaises(OSError, posix.sched_setparam, -1, param)
1151 self.assertRaises(OSError, posix.sched_setscheduler, -1, mine, param)
1152 self.assertRaises(TypeError, posix.sched_setscheduler, 0, mine, None)
1153 self.assertRaises(TypeError, posix.sched_setparam, 0, 43)
1154 param = posix.sched_param(None)
1155 self.assertRaises(TypeError, posix.sched_setparam, 0, param)
1157 param = posix.sched_param(large)
1158 self.assertRaises(OverflowError, posix.sched_setparam, 0, param)
1159 param = posix.sched_param(sched_priority=-large)
1160 self.assertRaises(OverflowError, posix.sched_setparam, 0, param)
1162 @unittest.skipUnless(hasattr(posix, "sched_rr_get_interval"), "no function")
1165 interval = posix.sched_rr_get_interval(0)
1179 mask = posix.sched_getaffinity(0)
1182 self.assertRaises(OSError, posix.sched_getaffinity, -1)
1190 mask = posix.sched_getaffinity(0)
1194 posix.sched_setaffinity(0, mask)
1195 self.assertEqual(posix.sched_getaffinity(0), mask)
1196 self.assertRaises(OSError, posix.sched_setaffinity, 0, [])
1197 self.assertRaises(ValueError, posix.sched_setaffinity, 0, [-10])
1198 self.assertRaises(ValueError, posix.sched_setaffinity, 0, map(int, "0X"))
1199 self.assertRaises(OverflowError, posix.sched_setaffinity, 0, [1<<128])
1200 self.assertRaises(OSError, posix.sched_setaffinity, -1, mask)
1204 posix.RTLD_LAZY
1205 posix.RTLD_NOW
1206 posix.RTLD_GLOBAL
1207 posix.RTLD_LOCAL
1302 # tests for the posix *at functions follow
1311 posix.mkdir(base_dir)
1312 self.addCleanup(posix.rmdir, base_dir)
1322 self.addCleanup(posix.unlink, fullname)
1328 self.assertTrue(posix.access(name, os.R_OK, dir_fd=dir_fd))
1333 posix.chmod(fullname, stat.S_IRUSR)
1334 posix.chmod(name, stat.S_IRUSR | stat.S_IWUSR, dir_fd=dir_fd)
1335 s = posix.stat(fullname)
1343 posix.chown(name, os.getuid(), os.getgid(), dir_fd=dir_fd)
1350 self.addCleanup(posix.unlink, fullname)
1352 s1 = posix.stat(fullname)
1353 s2 = posix.stat(name, dir_fd=dir_fd)
1355 s2 = posix.stat(fullname, dir_fd=None)
1359 posix.stat, name, dir_fd=posix.getcwd())
1361 posix.stat, name, dir_fd=float(dir_fd))
1363 posix.stat, name, dir_fd=10**20)
1369 posix.utime(name, None, dir_fd=dir_fd)
1370 posix.utime(name, dir_fd=dir_fd)
1371 self.assertRaises(TypeError, posix.utime, name,
1373 self.assertRaises(TypeError, posix.utime, name,
1375 self.assertRaises(TypeError, posix.utime, name,
1377 self.assertRaises(TypeError, posix.utime, name,
1379 self.assertRaises(TypeError, posix.utime, name,
1381 posix.utime(name, (int(now), int(now)), dir_fd=dir_fd)
1382 posix.utime(name, (now, now), dir_fd=dir_fd)
1383 posix.utime(name,
1385 posix.utime(name, dir_fd=dir_fd,
1391 posix.utime(name, follow_symlinks=False, dir_fd=dir_fd)
1401 posix.link(name, linkname, src_dir_fd=dir_fd, dst_dir_fd=dir_fd2)
1403 self.skipTest('posix.link(): %s' % e)
1404 self.addCleanup(posix.unlink, fulllinkname)
1406 self.assertEqual(posix.stat(fullname)[1],
1407 posix.stat(fulllinkname)[1])
1412 posix.mkdir(name, dir_fd=dir_fd)
1413 self.addCleanup(posix.rmdir, fullname)
1414 posix.stat(fullname) # should not raise exception
1422 # by POSIX).
1426 posix.mknod(name, mode, 0, dir_fd=dir_fd)
1432 self.addCleanup(posix.unlink, fullname)
1433 self.assertTrue(stat.S_ISFIFO(posix.stat(fullname).st_mode))
1440 self.addCleanup(posix.unlink, fullname)
1441 fd = posix.open(name, posix.O_RDONLY, dir_fd=dir_fd)
1443 res = posix.read(fd, 9)
1446 posix.close(fd)
1453 self.addCleanup(posix.unlink, fullname)
1454 self.assertEqual(posix.readlink(name, dir_fd=dir_fd), 'symlink')
1460 posix.rename(name, name2,
1462 posix.stat(fullname2) # should not raise exception
1463 posix.rename(fullname2, fullname)
1468 posix.symlink('symlink', name, dir_fd=dir_fd)
1469 self.addCleanup(posix.unlink, fullname)
1470 self.assertEqual(posix.readlink(fullname), 'symlink')
1476 posix.stat(fullname) # should not raise exception
1478 posix.unlink(name, dir_fd=dir_fd)
1479 self.assertRaises(OSError, posix.stat, fullname)
1481 self.addCleanup(posix.unlink, fullname)
1488 posix.mkfifo(name, stat.S_IRUSR | stat.S_IWUSR, dir_fd=dir_fd)
1490 self.skipTest('posix.mkfifo(): %s' % e)
1491 self.addCleanup(posix.unlink, fullname)
1492 self.assertTrue(stat.S_ISFIFO(posix.stat(fullname).st_mode))
1498 if posix.getuid() != 0:
1500 if not hasattr(posix, 'getgroups'):
1501 raise unittest.SkipTest("need posix.getgroups")
1504 self.saved_groups = posix.getgroups()
1507 if hasattr(posix, 'setgroups'):
1508 posix.setgroups(self.saved_groups)
1509 elif hasattr(posix, 'initgroups'):
1510 name = pwd.getpwuid(posix.getuid()).pw_name
1511 posix.initgroups(name, self.saved_groups[0])
1513 @unittest.skipUnless(hasattr(posix, 'initgroups'),
1514 "test needs posix.initgroups()")
1519 name = pwd.getpwuid(posix.getuid()).pw_name
1520 posix.initgroups(name, g)
1521 self.assertIn(g, posix.getgroups())
1523 @unittest.skipUnless(hasattr(posix, 'setgroups'),
1524 "test needs posix.setgroups()")
1527 posix.setgroups(groups)
1528 self.assertListEqual(groups, posix.getgroups())
1880 spawn_func = getattr(posix, 'posix_spawn', None)
1885 spawn_func = getattr(posix, 'posix_spawnp', None)
1952 self.assertIn("HAVE_FSTATAT", posix._have_functions)
1955 self.assertNotIn("HAVE_FSTATAT", posix._have_functions)
1963 self.assertIn("HAVE_FACCESSAT", posix._have_functions)
1966 self.assertNotIn("HAVE_FACCESSAT", posix._have_functions)
1980 self.assertIn("HAVE_FCHMODAT", posix._have_functions)
1983 self.assertNotIn("HAVE_FCHMODAT", posix._have_functions)
1984 self.assertIn("HAVE_LCHMOD", posix._have_functions)
1992 self.assertIn("HAVE_FCHOWNAT", posix._have_functions)
1995 self.assertNotIn("HAVE_FCHOWNAT", posix._have_functions)
1996 self.assertIn("HAVE_LCHOWN", posix._have_functions)
2004 self.assertIn("HAVE_LINKAT", posix._have_functions)
2007 self.assertNotIn("HAVE_LINKAT", posix._have_functions)
2043 self.assertIn("HAVE_FDOPENDIR", posix._have_functions)
2046 self.assertNotIn("HAVE_FDOPENDIR", posix._have_functions)
2057 self.assertIn("HAVE_MKDIRAT", posix._have_functions)
2060 self.assertNotIn("HAVE_MKDIRAT", posix._have_functions)
2068 self.assertIn("HAVE_RENAMEAT", posix._have_functions)
2071 self.assertNotIn("HAVE_RENAMEAT", posix._have_functions)
2088 self.assertIn("HAVE_UNLINKAT", posix._have_functions)
2091 self.assertNotIn("HAVE_UNLINKAT", posix._have_functions)
2102 self.assertIn("HAVE_OPENAT", posix._have_functions)
2105 self.assertNotIn("HAVE_OPENAT", posix._have_functions)
2113 self.assertIn("HAVE_READLINKAT", posix._have_functions)
2116 self.assertNotIn("HAVE_READLINKAT", posix._have_functions)
2124 self.assertIn("HAVE_SYMLINKAT", posix._have_functions)
2127 self.assertNotIn("HAVE_SYMLINKAT", posix._have_functions)
2136 self.assertIn("HAVE_FUTIMENS", posix._have_functions)
2137 self.assertIn("HAVE_UTIMENSAT", posix._have_functions)
2140 self.assertNotIn("HAVE_FUTIMENS", posix._have_functions)
2141 self.assertNotIn("HAVE_UTIMENSAT", posix._have_functions)