Lines Matching full:os
1 # As a test suite for the os module, this is woefully inadequate, but this
14 import os
72 if hasattr(os, 'geteuid'):
73 root_in_posix = (os.geteuid() == 0)
85 HAVE_WHEEL_GROUP = sys.platform.startswith('freebsd') and os.getgid() == 0
89 return unittest.skipUnless(hasattr(os, name), 'requires os.%s' % name)
108 cwd = os.getcwd()
114 # longer path if longer paths support is enabled. Internally, the os
137 cwd = os.getcwd()
140 need = min_len - (len(cwd) + len(os.path.sep))
146 path = os.path.join(path, dirname)
148 os.mkdir(path)
151 os.chdir(path)
169 cwd = os.getcwdb()
171 self.assertEqual(os.fsdecode(cwd), os.getcwd())
177 if os.path.lexists(os_helper.TESTFN):
178 os.unlink(os_helper.TESTFN)
182 f = os.open(os_helper.TESTFN, os.O_CREAT|os.O_RDWR)
183 os.close(f)
184 self.assertTrue(os.access(os_helper.TESTFN, os.W_OK))
193 first = os.open(os_helper.TESTFN, os.O_CREAT|os.O_RDWR)
197 second = os.dup(first)
201 os.close(first)
206 first, second = second, os.dup(second)
208 os.close(second)
210 os.closerange(first, first + 2)
211 self.assertRaises(OSError, os.write, first, b"a")
217 self.assertRaises(TypeError, os.rename, path, 0)
226 os.lseek(fd, 0, 0)
227 s = os.read(fd, 4)
241 # Issue #21932: Make sure that os.read() does not raise an
244 data = os.read(fp.fileno(), size)
251 # os.write() accepts bytes- and buffer-like objects but not strings
252 fd = os.open(os_helper.TESTFN, os.O_CREAT | os.O_WRONLY)
253 self.assertRaises(TypeError, os.write, fd, "beans")
254 os.write(fd, b"bacon\n")
255 os.write(fd, bytearray(b"eggs\n"))
256 os.write(fd, memoryview(b"spam\n"))
257 os.close(fd)
282 fd = os.open(os_helper.TESTFN, os.O_RDONLY)
283 f = os.fdopen(fd, *args, encoding="utf-8")
287 fd = os.open(os_helper.TESTFN, os.O_CREAT|os.O_RDWR)
288 os.close(fd)
302 os.replace(os_helper.TESTFN, TESTFN2)
303 self.assertRaises(FileNotFoundError, os.stat, os_helper.TESTFN)
308 f = os.open(path=__file__, flags=os.O_RDONLY, mode=0o777,
310 os.close(f)
313 symlink = support.get_attribute(os, "symlink")
318 pass # No OS support or unprivileged user
320 @unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')
323 os.copy_file_range(0, 1, -10)
325 @unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')
343 i = os.copy_file_range(in_fd, out_fd, 5)
359 @unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')
380 i = os.copy_file_range(in_fd, out_fd, bytes_to_copy,
404 @unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')
407 os.splice(0, 1, -10)
409 @unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')
422 read_fd, write_fd = os.pipe()
423 self.addCleanup(lambda: os.close(read_fd))
424 self.addCleanup(lambda: os.close(write_fd))
427 i = os.splice(in_fd, write_fd, 5)
440 self.assertEqual(os.read(read_fd, 100), data[:i])
442 @unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')
457 read_fd, write_fd = os.pipe()
458 self.addCleanup(lambda: os.close(read_fd))
459 self.addCleanup(lambda: os.close(write_fd))
462 i = os.splice(in_fd, write_fd, bytes_to_copy, offset_src=in_skip)
475 read = os.read(read_fd, 100)
480 @unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')
491 read_fd, write_fd = os.pipe()
492 self.addCleanup(lambda: os.close(read_fd))
493 self.addCleanup(lambda: os.close(write_fd))
494 os.write(write_fd, data)
502 i = os.splice(read_fd, out_fd, bytes_to_copy, offset_dst=out_seek)
524 # Test attributes on return values from os.*stat* family.
532 result = os.stat(fname)
585 result2 = os.stat_result((10,))
592 result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
607 result = os.stat(self.fname)
616 @unittest.skipUnless(hasattr(os, 'statvfs'), 'test needs os.statvfs()')
618 result = os.statvfs(self.fname)
649 result2 = os.statvfs_result((10,))
656 result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
660 @unittest.skipUnless(hasattr(os, 'statvfs'),
661 "need os.statvfs()")
663 result = os.statvfs(self.fname)
677 os.stat(r"c:\pagefile.sys")
684 @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
687 r, w = os.pipe()
689 os.stat(r) # should not raise error
691 os.close(r)
692 os.close(w)
694 os.stat(r)
706 result = os.stat(self.fname)
714 os.mkdir(dirname)
715 self.addCleanup(os.rmdir, dirname)
717 result = os.stat(dirname)
727 # os.environ['TEMP'] should be located on a volume that
729 fname = os.path.join(os.environ['TEMP'], self.fname)
741 result = os.stat(fname)
746 # bpo-38030: os.stat fails for block devices
748 fname = "//./" + os.path.splitdrive(os.getcwd())[0]
749 result = os.stat(fname)
756 self.fname = os.path.join(self.dirname, "f1")
759 os.mkdir(self.dirname)
765 st = os.stat(filename)
778 # The resolution of the C internal function used by os.utime()
790 st = os.stat(filename)
804 os.utime(filename, ns=ns)
811 # issue, os.utime() rounds towards minus infinity.
822 os.utime(filename, (atime, mtime))
831 os.utime(filename, times=(atime, mtime))
834 @unittest.skipUnless(os.utime in os.supports_follow_symlinks,
841 os.utime(filename, ns=ns, follow_symlinks=False)
844 @unittest.skipUnless(os.utime in os.supports_fd,
851 os.utime(fp.fileno(), ns=ns)
854 @unittest.skipUnless(os.utime in os.supports_dir_fd,
858 dirname, name = os.path.split(filename)
861 os.utime(name, dir_fd=dirfd, ns=ns)
866 # test calling os.utime() on a directory
867 os.utime(filename, ns=ns)
874 # Call os.utime() to set the timestamp to the current system clock
886 st = os.stat(self.fname)
895 os.utime(self.fname)
901 os.utime(self.fname, None)
906 root = os.path.splitdrive(os.path.abspath(path))[0] + '\\'
924 os.utime(self.fname, (large, large))
925 self.assertEqual(os.stat(self.fname).st_mtime, large)
930 os.utime(self.fname, (5, 5), ns=(5, 5))
932 os.utime(self.fname, [5, 5])
934 os.utime(self.fname, (5,))
936 os.utime(self.fname, (5, 5, 5))
938 os.utime(self.fname, ns=[5, 5])
940 os.utime(self.fname, ns=(5,))
942 os.utime(self.fname, ns=(5, 5, 5))
944 if os.utime not in os.supports_follow_symlinks:
946 os.utime(self.fname, (5, 5), follow_symlinks=False)
947 if os.utime not in os.supports_fd:
950 os.utime(fp.fileno(), (5, 5))
951 if os.utime not in os.supports_dir_fd:
953 os.utime(self.fname, (5, 5), dir_fd=0)
965 os.utime(self.fname, ns=(get_bad_int(42), 1))
967 os.utime(self.fname, ns=(get_bad_int(()), 1))
969 os.utime(self.fname, ns=(get_bad_int((1, 2, 3)), 1))
975 """check that os.environ object conform to mapping protocol"""
979 self.__save = dict(os.environ)
980 if os.supports_bytes_environ:
981 self.__saveb = dict(os.environb)
983 os.environ[key] = value
986 os.environ.clear()
987 os.environ.update(self.__save)
988 if os.supports_bytes_environ:
989 os.environb.clear()
990 os.environb.update(self.__saveb)
996 os.environ.clear()
997 return os.environ
1000 @unittest.skipUnless(unix_shell and os.path.exists(unix_shell),
1002 @unittest.skipUnless(hasattr(os, 'popen'), "needs os.popen()")
1005 os.environ.clear()
1006 os.environ.update(HELLO="World")
1007 with os.popen("%s -c 'echo $HELLO'" % unix_shell) as popen:
1011 @unittest.skipUnless(unix_shell and os.path.exists(unix_shell),
1013 @unittest.skipUnless(hasattr(os, 'popen'), "needs os.popen()")
1016 with os.popen("%s -c 'echo \"line1\nline2\nline3\"'"
1024 # Verify environ keys and values from the OS are of the
1027 for key, val in os.environ.items():
1033 self.assertEqual(os.environ.get(key), value)
1037 """Check that the repr() of os.environ looks like environ({...})."""
1038 env = os.environ
1046 defpath_list = os.defpath.split(os.pathsep)
1048 test_env = {'PATH': os.pathsep.join(test_path)}
1050 saved_environ = os.environ
1052 os.environ = dict(test_env)
1053 # Test that defaulting to os.environ works.
1054 self.assertSequenceEqual(test_path, os.get_exec_path())
1055 self.assertSequenceEqual(test_path, os.get_exec_path(env=None))
1057 os.environ = saved_environ
1060 self.assertSequenceEqual(defpath_list, os.get_exec_path({}))
1062 self.assertSequenceEqual(('',), os.get_exec_path({'PATH':''}))
1064 self.assertSequenceEqual(test_path, os.get_exec_path(test_env))
1066 if os.supports_bytes_environ:
1076 self.assertRaises(ValueError, os.get_exec_path, mixed_env)
1079 self.assertSequenceEqual(os.get_exec_path({b'PATH': b'abc'}),
1081 self.assertSequenceEqual(os.get_exec_path({b'PATH': 'abc'}),
1083 self.assertSequenceEqual(os.get_exec_path({'PATH': b'abc'}),
1086 @unittest.skipUnless(os.supports_bytes_environ,
1087 "os.environb required for this test.")
1089 # os.environ -> os.environb
1098 os.environ['unicode'] = value
1099 self.assertEqual(os.environ['unicode'], value)
1100 self.assertEqual(os.environb[b'unicode'], value_bytes)
1102 # os.environb -> os.environ
1104 os.environb[b'bytes'] = value
1105 self.assertEqual(os.environb[b'bytes'], value)
1107 self.assertEqual(os.environ['bytes'], value_str)
1113 code = f'import os; print(repr(os.environ.get({name!r})))'
1118 os.putenv(name, value)
1123 os.unsetenv(name)
1128 # On OS X < 10.6, unsetenv() doesn't return a value (bpo-13415).
1134 self.assertRaises((OSError, ValueError), os.putenv, name, "value")
1135 self.assertRaises((OSError, ValueError), os.unsetenv, name)
1141 self.assertRaises(ValueError, os.putenv, longstr, "1")
1142 self.assertRaises(ValueError, os.putenv, "X", longstr)
1143 self.assertRaises(ValueError, os.unsetenv, longstr)
1147 self.assertNotIn(missing, os.environ)
1150 os.environ[missing]
1155 del os.environ[missing]
1163 next(iterator) # start iteration over os.environ.items
1165 # add a new key in os.environ mapping
1166 os.environ[new_key] = "test_environ_iteration"
1170 self.assertEqual(os.environ[new_key], "test_environ_iteration")
1172 del os.environ[new_key]
1175 self._test_environ_iteration(os.environ)
1178 self._test_environ_iteration(os.environ.items())
1181 self._test_environ_iteration(os.environ.values())
1184 if not (unix_shell and os.path.exists(unix_shell)):
1189 with os.popen(f"{unix_shell} -c 'echo ${var}'") as popen:
1197 os.environ[overridden_key] = original_value
1200 expected = dict(os.environ)
1203 actual = os.environ | new_vars_dict
1208 self.assertIs(NotImplemented, os.environ.__or__(new_vars_items))
1215 os.environ[overridden_key] = 'original_value'
1218 expected = dict(os.environ)
1221 os.environ |= new_vars_dict
1222 self.assertEqual(expected, os.environ)
1223 self.assertEqual('3', os.environ[overridden_key])
1229 os_environ_copy = os.environ.copy()
1232 os.environ |= dict_with_bad_key
1236 os.environ |= dict_with_bad_val
1239 self.assertEqual(os_environ_copy, os.environ)
1243 os.environ[overridden_key] = 'original_value'
1246 expected = dict(os.environ)
1249 os.environ |= new_vars_items
1250 self.assertEqual(expected, os.environ)
1251 self.assertEqual('3', os.environ[overridden_key])
1259 os.environ[overridden_key] = original_value
1263 expected.update(os.environ)
1265 actual = new_vars_dict | os.environ
1270 self.assertIs(NotImplemented, os.environ.__ror__(new_vars_items))
1277 """Tests for os.walk()."""
1279 # Wrapper to hide minor differences between os.walk and os.fwalk
1284 return os.walk(top, **kwargs)
1287 join = os.path.join
1324 os.makedirs(self.sub11_path)
1325 os.makedirs(sub2_path)
1326 os.makedirs(sub21_path)
1327 os.makedirs(t2_path)
1334 os.symlink(os.path.abspath(t2_path), self.link_path)
1335 os.symlink('broken', broken_link_path, True)
1336 os.symlink(join('tmp3', 'broken'), broken_link2_path, True)
1337 os.symlink(join('SUB21', 'tmp5'), broken_link3_path, True)
1346 os.chmod(sub21_path, 0)
1348 os.listdir(sub21_path)
1350 self.addCleanup(os.chmod, sub21_path, stat.S_IRWXU)
1352 os.chmod(sub21_path, stat.S_IRWXU)
1353 os.unlink(tmp5_path)
1354 os.rmdir(sub21_path)
1438 path1 = os.path.join(root, dir1)
1439 path1new = os.path.join(root, dir1 + '.new')
1440 os.rename(path1, path1new)
1448 self.assertIn(os.path.join(root, dir2), roots)
1450 os.rename(path1new, path1)
1454 base = os.path.join(os_helper.TESTFN, 'deep')
1455 p = os.path.join(base, *(['d']*depth))
1456 os.makedirs(p)
1463 p = os.path.dirname(p)
1471 p = os.path.join(p, 'd')
1474 @unittest.skipUnless(hasattr(os, 'fwalk'), "Test needs os.fwalk()")
1476 """Tests for os.fwalk()."""
1483 return os.fwalk(*args, **kwargs)
1496 for root, dirs, files in os.walk(**walk_kwargs):
1509 fd = os.open(".", os.O_RDONLY)
1515 os.close(fd)
1523 os.fstat(rootfd)
1525 os.stat(rootfd)
1527 self.assertEqual(set(os.listdir(rootfd)), set(dirs) | set(files))
1536 minfd = os.dup(1)
1537 os.close(minfd)
1541 newfd = os.dup(1)
1542 self.addCleanup(os.close, newfd)
1550 """Tests for os.walk() with bytes."""
1554 for broot, bdirs, bfiles in os.walk(os.fsencode(top), **kwargs):
1555 root = os.fsdecode(broot)
1556 dirs = list(map(os.fsdecode, bdirs))
1557 files = list(map(os.fsdecode, bfiles))
1559 bdirs[:] = list(map(os.fsencode, dirs))
1560 bfiles[:] = list(map(os.fsencode, files))
1562 @unittest.skipUnless(hasattr(os, 'fwalk'), "Test needs os.fwalk()")
1564 """Tests for os.walk() with bytes."""
1566 for broot, bdirs, bfiles, topfd in os.fwalk(os.fsencode(top), *args, **kwargs):
1567 root = os.fsdecode(broot)
1568 dirs = list(map(os.fsdecode, bdirs))
1569 files = list(map(os.fsdecode, bfiles))
1571 bdirs[:] = list(map(os.fsencode, dirs))
1572 bfiles[:] = list(map(os.fsencode, files))
1577 os.mkdir(os_helper.TESTFN)
1581 path = os.path.join(base, 'dir1', 'dir2', 'dir3')
1582 os.makedirs(path) # Should work
1583 path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4')
1584 os.makedirs(path)
1587 self.assertRaises(OSError, os.makedirs, os.curdir)
1588 path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4', 'dir5', os.curdir)
1589 os.makedirs(path)
1590 path = os.path.join(base, 'dir1', os.curdir, 'dir2', 'dir3', 'dir4',
1592 os.makedirs(path)
1601 parent = os.path.join(base, 'dir1')
1602 path = os.path.join(parent, 'dir2')
1603 os.makedirs(path, 0o555)
1604 self.assertTrue(os.path.exists(path))
1605 self.assertTrue(os.path.isdir(path))
1606 if os.name != 'nt':
1607 self.assertEqual(os.stat(path).st_mode & 0o777, 0o555)
1608 self.assertEqual(os.stat(parent).st_mode & 0o777, 0o775)
1615 path = os.path.join(os_helper.TESTFN, 'dir1')
1617 old_mask = os.umask(0o022)
1618 os.makedirs(path, mode)
1619 self.assertRaises(OSError, os.makedirs, path, mode)
1620 self.assertRaises(OSError, os.makedirs, path, mode, exist_ok=False)
1621 os.makedirs(path, 0o776, exist_ok=True)
1622 os.makedirs(path, mode=mode, exist_ok=True)
1623 os.umask(old_mask)
1626 os.makedirs(os.path.abspath('/'), exist_ok=True)
1633 path = os.path.join(os_helper.TESTFN, 'dir1')
1636 old_mask = os.umask(0o022)
1639 os.lstat(os_helper.TESTFN).st_mode)
1641 os.chmod(os_helper.TESTFN, existing_testfn_mode | S_ISGID)
1644 if (os.lstat(os_helper.TESTFN).st_mode & S_ISGID != S_ISGID):
1646 # The os should apply S_ISGID from the parent dir for us, but
1648 os.makedirs(path, mode | S_ISGID)
1651 os.makedirs(path, mode, exist_ok=True)
1653 os.chmod(path, stat.S_IMODE(os.lstat(path).st_mode) & ~S_ISGID)
1655 os.makedirs(path, mode | S_ISGID, exist_ok=True)
1657 os.umask(old_mask)
1661 path = os.path.join(os_helper.TESTFN, 'dir1')
1664 self.assertRaises(OSError, os.makedirs, path)
1665 self.assertRaises(OSError, os.makedirs, path, exist_ok=False)
1666 self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
1667 os.remove(path)
1669 @unittest.skipUnless(os.name == 'nt', "requires Windows")
1672 path = os.path.abspath(os.path.join(os_helper.TESTFN, 'dir'))
1673 os.mkdir(path, mode=0o700)
1675 os.rmdir(path)
1682 path = os.path.join(os_helper.TESTFN, 'dir1', 'dir2', 'dir3',
1687 while not os.path.exists(path) and path != os_helper.TESTFN:
1688 path = os.path.dirname(path)
1690 os.removedirs(path)
1698 os.mkdir(os_helper.TESTFN)
1701 stat = os.stat(os_helper.TESTFN)
1705 self.assertRaises(TypeError, os.chown, os_helper.TESTFN, value, gid)
1706 self.assertRaises(TypeError, os.chown, os_helper.TESTFN, uid, value)
1707 self.assertIsNone(os.chown(os_helper.TESTFN, uid, gid))
1708 self.assertIsNone(os.chown(os_helper.TESTFN, -1, -1))
1710 @unittest.skipUnless(hasattr(os, 'getgroups'), 'need os.getgroups')
1712 groups = os.getgroups()
1717 uid = os.stat(os_helper.TESTFN).st_uid
1719 os.chown(os_helper.TESTFN, uid, gid_1)
1720 gid = os.stat(os_helper.TESTFN).st_gid
1723 os.chown(os_helper.TESTFN, uid, gid_2)
1724 gid = os.stat(os_helper.TESTFN).st_gid
1731 gid = os.stat(os_helper.TESTFN).st_gid
1732 os.chown(os_helper.TESTFN, uid_1, gid)
1733 uid = os.stat(os_helper.TESTFN).st_uid
1735 os.chown(os_helper.TESTFN, uid_2, gid)
1736 uid = os.stat(os_helper.TESTFN).st_uid
1743 gid = os.stat(os_helper.TESTFN).st_gid
1745 os.chown(os_helper.TESTFN, uid_1, gid)
1746 os.chown(os_helper.TESTFN, uid_2, gid)
1750 os.rmdir(os_helper.TESTFN)
1755 os.makedirs(os_helper.TESTFN)
1761 dira = os.path.join(os_helper.TESTFN, 'dira')
1762 os.mkdir(dira)
1763 dirb = os.path.join(dira, 'dirb')
1764 os.mkdir(dirb)
1765 os.removedirs(dirb)
1766 self.assertFalse(os.path.exists(dirb))
1767 self.assertFalse(os.path.exists(dira))
1768 self.assertFalse(os.path.exists(os_helper.TESTFN))
1771 dira = os.path.join(os_helper.TESTFN, 'dira')
1772 os.mkdir(dira)
1773 dirb = os.path.join(dira, 'dirb')
1774 os.mkdir(dirb)
1775 create_file(os.path.join(dira, 'file.txt'))
1776 os.removedirs(dirb)
1777 self.assertFalse(os.path.exists(dirb))
1778 self.assertTrue(os.path.exists(dira))
1779 self.assertTrue(os.path.exists(os_helper.TESTFN))
1782 dira = os.path.join(os_helper.TESTFN, 'dira')
1783 os.mkdir(dira)
1784 dirb = os.path.join(dira, 'dirb')
1785 os.mkdir(dirb)
1786 create_file(os.path.join(dirb, 'file.txt'))
1788 os.removedirs(dirb)
1789 self.assertTrue(os.path.exists(dirb))
1790 self.assertTrue(os.path.exists(dira))
1791 self.assertTrue(os.path.exists(os_helper.TESTFN))
1797 with open(os.devnull, 'wb', 0) as f:
1800 with open(os.devnull, 'rb') as f:
1806 self.assertEqual(len(os.urandom(0)), 0)
1807 self.assertEqual(len(os.urandom(1)), 1)
1808 self.assertEqual(len(os.urandom(10)), 10)
1809 self.assertEqual(len(os.urandom(100)), 100)
1810 self.assertEqual(len(os.urandom(1000)), 1000)
1813 data1 = os.urandom(16)
1815 data2 = os.urandom(16)
1820 'import os, sys',
1821 'data = os.urandom(%s)' % count,
1835 @unittest.skipUnless(hasattr(os, 'getrandom'), 'need os.getrandom()')
1840 os.getrandom(1)
1850 data = os.getrandom(16)
1855 empty = os.getrandom(0)
1859 self.assertTrue(hasattr(os, 'GRND_RANDOM'))
1861 # Don't test os.getrandom(1, os.GRND_RANDOM) to not consume the rare
1867 os.getrandom(1, os.GRND_NONBLOCK)
1873 data1 = os.getrandom(16)
1874 data2 = os.getrandom(16)
1878 # os.urandom() doesn't use a file descriptor when it is implemented with the
1886 "os.random() does not use a file descriptor")
1895 # test suite would crash; this actually happened on the OS X Tiger
1899 import os
1905 os.urandom(16)
1917 import os
1920 os.urandom(4)
1922 os.closerange(3, 256)
1923 sys.stdout.buffer.write(os.urandom(4))
1934 import os
1937 os.urandom(4)
1941 os.close(fd)
1947 os.closerange(3, 256)
1954 os.dup2(new_fd, fd)
1955 sys.stdout.buffer.write(os.urandom(4))
1956 sys.stdout.buffer.write(os.urandom(4))
1986 orig_execv = os.execv
1987 orig_execve = os.execve
1988 orig_defpath = os.defpath
1989 os.execv = mock_execv
1990 os.execve = mock_execve
1992 os.defpath = defpath
1995 os.execv = orig_execv
1996 os.execve = orig_execve
1997 os.defpath = orig_defpath
1999 @unittest.skipUnless(hasattr(os, 'execv'),
2000 "need os.execv()")
2005 self.assertRaises(OSError, os.execvpe, 'no such app-',
2009 self.assertRaises(ValueError, os.execv, 'notepad', ())
2010 self.assertRaises(ValueError, os.execv, 'notepad', [])
2011 self.assertRaises(ValueError, os.execv, 'notepad', ('',))
2012 self.assertRaises(ValueError, os.execv, 'notepad', [''])
2015 self.assertRaises(ValueError, os.execvpe, 'notepad', [], None)
2016 self.assertRaises(ValueError, os.execvpe, 'notepad', [], {})
2017 self.assertRaises(ValueError, os.execvpe, 'notepad', [''], {})
2019 @unittest.skipUnless(hasattr(os, '_execvpe'),
2020 "No internal os._execvpe function to test.")
2022 program_path = os.sep + 'absolutepath'
2025 fullpath = os.path.join(os.fsencode(program_path), program)
2031 fullpath = os.path.join(program_path, program)
2032 if os.name != "nt":
2033 native_fullpath = os.fsencode(fullpath)
2038 # test os._execvpe() with an absolute path
2041 os._execvpe, fullpath, arguments)
2045 # test os._execvpe() with a relative path:
2046 # os.get_exec_path() returns defpath
2049 os._execvpe, program, arguments, env=env)
2054 # test os._execvpe() with a relative path:
2055 # os.get_exec_path() reads the 'PATH' variable
2063 os._execvpe, program, arguments, env=env_path)
2070 if os.name != "nt":
2077 newenv = os.environ.copy()
2080 os.execve(args[0], args, newenv)
2083 newenv = os.environ.copy()
2086 os.execve(args[0], args, newenv)
2089 newenv = os.environ.copy()
2092 os.execve(args[0], args, newenv)
2098 os.execve('', ['arg'], {})
2109 os.stat(os_helper.TESTFN)
2114 self.fail("file %s must not exist; os.stat failed with %s"
2120 self.assertRaises(OSError, os.rename, os_helper.TESTFN, os_helper.TESTFN+".bak")
2123 self.assertRaises(OSError, os.remove, os_helper.TESTFN)
2126 self.assertRaises(OSError, os.chdir, os_helper.TESTFN)
2132 self.assertRaises(OSError, os.mkdir, os_helper.TESTFN)
2135 self.assertRaises(OSError, os.utime, os_helper.TESTFN, None)
2138 self.assertRaises(OSError, os.chmod, os_helper.TESTFN, 0)
2149 if hasattr(os, f):
2150 self.check(getattr(os, f))
2165 self.check(os.fdopen, encoding="utf-8")
2167 @unittest.skipUnless(hasattr(os, 'isatty'), 'test needs os.isatty()')
2169 self.assertEqual(os.isatty(os_helper.make_bad_fd()), False)
2171 @unittest.skipUnless(hasattr(os, 'closerange'), 'test needs os.closerange()')
2177 try: os.fstat(fd+i)
2185 self.assertEqual(os.closerange(fd, fd + i-1), None)
2187 @unittest.skipUnless(hasattr(os, 'dup2'), 'test needs os.dup2()')
2189 self.check(os.dup2, 20)
2191 @unittest.skipUnless(hasattr(os, 'dup2'), 'test needs os.dup2()')
2197 valid_fd = os.open(__file__, os.O_RDONLY)
2198 self.addCleanup(os.close, valid_fd)
2208 os.dup2(fd, fd2)
2211 @unittest.skipUnless(hasattr(os, 'fchmod'), 'test needs os.fchmod()')
2213 self.check(os.fchmod, 0)
2215 @unittest.skipUnless(hasattr(os, 'fchown'), 'test needs os.fchown()')
2217 self.check(os.fchown, -1, -1)
2219 @unittest.skipUnless(hasattr(os, 'fpathconf'), 'test needs os.fpathconf()')
2225 self.check(os.pathconf, "PC_NAME_MAX")
2226 self.check(os.fpathconf, "PC_NAME_MAX")
2228 @unittest.skipUnless(hasattr(os, 'ftruncate'), 'test needs os.ftruncate()')
2230 self.check(os.truncate, 0)
2231 self.check(os.ftruncate, 0)
2233 @unittest.skipUnless(hasattr(os, 'lseek'), 'test needs os.lseek()')
2235 self.check(os.lseek, 0, 0)
2237 @unittest.skipUnless(hasattr(os, 'read'), 'test needs os.read()')
2239 self.check(os.read, 1)
2241 @unittest.skipUnless(hasattr(os, 'readv'), 'test needs os.readv()')
2244 self.check(os.readv, [buf])
2246 @unittest.skipUnless(hasattr(os, 'tcsetpgrp'), 'test needs os.tcsetpgrp()')
2248 self.check(os.tcsetpgrp, 0)
2250 @unittest.skipUnless(hasattr(os, 'write'), 'test needs os.write()')
2252 self.check(os.write, b" ")
2254 @unittest.skipUnless(hasattr(os, 'writev'), 'test needs os.writev()')
2256 self.check(os.writev, [b'abc'])
2260 self.check(os.get_inheritable)
2261 self.check(os.set_inheritable, True)
2263 @unittest.skipUnless(hasattr(os, 'get_blocking'),
2264 'needs os.get_blocking() and os.set_blocking()')
2266 self.check(os.get_blocking)
2267 self.check(os.set_blocking, True)
2270 @unittest.skipUnless(hasattr(os, 'link'), 'requires os.link')
2274 self.file2 = os.path.join(os_helper.TESTFN + "2")
2278 if os.path.exists(file):
2279 os.unlink(file)
2285 os.link(file1, file2)
2287 self.skipTest('os.link(): %s' % e)
2289 self.assertTrue(os.path.sameopenfile(f1.fileno(), f2.fileno()))
2300 os.fsencode("\xf1")
2314 @unittest.skipUnless(hasattr(os, 'setuid'), 'test needs os.setuid()')
2316 if os.getuid() != 0:
2317 self.assertRaises(OSError, os.setuid, 0)
2318 self.assertRaises(TypeError, os.setuid, 'not an int')
2319 self.assertRaises(OverflowError, os.setuid, self.UID_OVERFLOW)
2321 @unittest.skipUnless(hasattr(os, 'setgid'), 'test needs os.setgid()')
2323 if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
2324 self.assertRaises(OSError, os.setgid, 0)
2325 self.assertRaises(TypeError, os.setgid, 'not an int')
2326 self.assertRaises(OverflowError, os.setgid, self.GID_OVERFLOW)
2328 @unittest.skipUnless(hasattr(os, 'seteuid'), 'test needs os.seteuid()')
2330 if os.getuid() != 0:
2331 self.assertRaises(OSError, os.seteuid, 0)
2332 self.assertRaises(TypeError, os.setegid, 'not an int')
2333 self.assertRaises(OverflowError, os.seteuid, self.UID_OVERFLOW)
2335 @unittest.skipUnless(hasattr(os, 'setegid'), 'test needs os.setegid()')
2337 if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
2338 self.assertRaises(OSError, os.setegid, 0)
2339 self.assertRaises(TypeError, os.setegid, 'not an int')
2340 self.assertRaises(OverflowError, os.setegid, self.GID_OVERFLOW)
2342 @unittest.skipUnless(hasattr(os, 'setreuid'), 'test needs os.setreuid()')
2344 if os.getuid() != 0:
2345 self.assertRaises(OSError, os.setreuid, 0, 0)
2346 self.assertRaises(TypeError, os.setreuid, 'not an int', 0)
2347 self.assertRaises(TypeError, os.setreuid, 0, 'not an int')
2348 self.assertRaises(OverflowError, os.setreuid, self.UID_OVERFLOW, 0)
2349 self.assertRaises(OverflowError, os.setreuid, 0, self.UID_OVERFLOW)
2351 @unittest.skipUnless(hasattr(os, 'setreuid'), 'test needs os.setreuid()')
2358 'import os,sys;os.setreuid(-1,-1);sys.exit(0)'])
2360 @unittest.skipUnless(hasattr(os, 'setregid'), 'test needs os.setregid()')
2363 if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
2364 self.assertRaises(OSError, os.setregid, 0, 0)
2365 self.assertRaises(TypeError, os.setregid, 'not an int', 0)
2366 self.assertRaises(TypeError, os.setregid, 0, 'not an int')
2367 self.assertRaises(OverflowError, os.setregid, self.GID_OVERFLOW, 0)
2368 self.assertRaises(OverflowError, os.setregid, 0, self.GID_OVERFLOW)
2370 @unittest.skipUnless(hasattr(os, 'setregid'), 'test needs os.setregid()')
2377 'import os,sys;os.setregid(-1,-1);sys.exit(0)'])
2388 self.bdir = os.fsencode(self.dir)
2393 fn = os.fsencode(fn)
2406 os.mkdir(self.dir)
2409 os_helper.create_empty_file(os.path.join(self.bdir, fn))
2410 fn = os.fsdecode(fn)
2423 found = set(os.listdir(self.dir))
2426 current_directory = os.getcwd()
2428 os.chdir(os.sep)
2429 self.assertEqual(set(os.listdir()), set(os.listdir(os.sep)))
2431 os.chdir(current_directory)
2435 f = open(os.path.join(self.dir, fn), 'rb')
2438 @unittest.skipUnless(hasattr(os, 'statvfs'),
2439 "need os.statvfs()")
2444 fullname = os.path.join(self.dir, fn)
2445 os.statvfs(fullname)
2449 os.stat(os.path.join(self.dir, fn))
2456 # becomes ready, send *sig* via os.kill to the subprocess and check
2504 os.kill(proc.pid, sig)
2512 # os.kill on Windows can take an int which gets set as the exit code
2522 os.path.join(os.path.dirname(__file__),
2534 os.kill(proc.pid, signal.SIGINT)
2536 os.kill(proc.pid, event)
2542 os.kill(proc.pid, signal.SIGINT)
2578 dir_path = os.path.join(os_helper.TESTFN, dir_name)
2580 file_path = os.path.join(os_helper.TESTFN, file_name)
2581 os.makedirs(dir_path)
2594 sorted(os.listdir(os_helper.TESTFN)),
2599 sorted(os.listdir(os.fsencode(os_helper.TESTFN))),
2600 [os.fsencode(path) for path in self.created_paths])
2606 path = '\\\\?\\' + os.path.abspath(os_helper.TESTFN)
2608 sorted(os.listdir(path)),
2612 path = b'\\\\?\\' + os.fsencode(os.path.abspath(os_helper.TESTFN))
2614 sorted(os.listdir(path)),
2615 [os.fsencode(path) for path in self.created_paths])
2618 @unittest.skipUnless(hasattr(os, 'readlink'), 'needs os.readlink()')
2621 filelink_target = os.path.abspath(__file__)
2622 filelinkb = os.fsencode(filelink)
2623 filelinkb_target = os.fsencode(filelink_target)
2626 left = os.path.normcase(left)
2627 right = os.path.normcase(right)
2640 self.assertTrue(os.path.exists(self.filelink_target))
2641 self.assertTrue(os.path.exists(self.filelinkb_target))
2642 self.assertFalse(os.path.exists(self.filelink))
2643 self.assertFalse(os.path.exists(self.filelinkb))
2647 self.assertRaises(OSError, os.readlink, self.filelink_target)
2648 self.assertRaises(OSError, os.readlink, filelink_target)
2651 self.assertRaises(FileNotFoundError, os.readlink, 'missing-link')
2652 self.assertRaises(FileNotFoundError, os.readlink,
2657 os.symlink(self.filelink_target, self.filelink)
2660 self.assertPathEqual(os.readlink(filelink), self.filelink_target)
2664 os.symlink(self.filelinkb_target, self.filelinkb)
2666 path = os.readlink(FakePath(self.filelinkb))
2672 os.symlink(self.filelinkb_target, self.filelinkb)
2674 path = os.readlink(self.filelinkb)
2683 filelink_target = os.path.abspath(__file__)
2685 dirlink_target = os.path.dirname(filelink_target)
2689 assert os.path.exists(self.dirlink_target)
2690 assert os.path.exists(self.filelink_target)
2691 assert not os.path.exists(self.dirlink)
2692 assert not os.path.exists(self.filelink)
2693 assert not os.path.exists(self.missing_link)
2696 if os.path.exists(self.filelink):
2697 os.remove(self.filelink)
2698 if os.path.exists(self.dirlink):
2699 os.rmdir(self.dirlink)
2700 if os.path.lexists(self.missing_link):
2701 os.remove(self.missing_link)
2704 os.symlink(self.dirlink_target, self.dirlink)
2705 self.assertTrue(os.path.exists(self.dirlink))
2706 self.assertTrue(os.path.isdir(self.dirlink))
2707 self.assertTrue(os.path.islink(self.dirlink))
2711 os.symlink(self.filelink_target, self.filelink)
2712 self.assertTrue(os.path.exists(self.filelink))
2713 self.assertTrue(os.path.isfile(self.filelink))
2714 self.assertTrue(os.path.islink(self.filelink))
2720 if os.path.lexists(linkname):
2721 os.remove(linkname)
2723 assert not os.path.exists(target)
2725 os.symlink(target, linkname, target_is_dir)
2729 # For compatibility with Unix, os.remove will check the
2732 os.remove(self.missing_link)
2736 self.assertFalse(os.path.isdir(self.missing_link))
2740 os.rmdir(self.missing_link)
2743 self.assertEqual(os.stat(link), os.stat(target))
2744 self.assertNotEqual(os.lstat(link), os.stat(link))
2746 bytes_link = os.fsencode(link)
2747 self.assertEqual(os.stat(bytes_link), os.stat(target))
2748 self.assertNotEqual(os.lstat(bytes_link), os.stat(bytes_link))
2751 level1 = os.path.abspath(os_helper.TESTFN)
2752 level2 = os.path.join(level1, "level2")
2753 level3 = os.path.join(level2, "level3")
2756 os.mkdir(level1)
2757 os.mkdir(level2)
2758 os.mkdir(level3)
2760 file1 = os.path.abspath(os.path.join(level1, "file1"))
2763 orig_dir = os.getcwd()
2765 os.chdir(level2)
2766 link = os.path.join(level2, "link")
2767 os.symlink(os.path.relpath(file1), "link")
2768 self.assertIn("link", os.listdir(os.getcwd()))
2770 # Check os.stat calls from the same dir as the link
2771 self.assertEqual(os.stat(file1), os.stat("link"))
2773 # Check os.stat calls from a dir below the link
2774 os.chdir(level1)
2775 self.assertEqual(os.stat(file1),
2776 os.stat(os.path.relpath(link)))
2778 # Check os.stat calls from a dir above the link
2779 os.chdir(level3)
2780 self.assertEqual(os.stat(file1),
2781 os.stat(os.path.relpath(link)))
2783 os.chdir(orig_dir)
2785 @unittest.skipUnless(os.path.lexists(r'C:\Users\All Users')
2786 and os.path.exists(r'C:\ProgramData'),
2789 # os.symlink() calls CreateSymbolicLink, which creates
2797 target = os.readlink(r'C:\Users\All Users')
2798 self.assertTrue(os.path.samefile(target, r'C:\ProgramData'))
2805 path = os.path.join(*[segment] * 10)
2816 os.symlink(src, dest)
2821 os.remove(dest)
2826 os.symlink(os.fsencode(src), os.fsencode(dest))
2831 os.remove(dest)
2836 root = os.path.expandvars(r'%LOCALAPPDATA%\Microsoft\WindowsApps')
2837 if not os.path.isdir(root):
2840 aliases = [os.path.join(root, a)
2841 for a in fnmatch.filter(os.listdir(root), '*.exe')]
2847 st = os.lstat(alias)
2848 self.assertEqual(st, os.stat(alias))
2859 junction_target = os.path.dirname(os.path.abspath(__file__))
2862 assert os.path.exists(self.junction_target)
2863 assert not os.path.lexists(self.junction)
2866 if os.path.lexists(self.junction):
2867 os.unlink(self.junction)
2871 self.assertTrue(os.path.lexists(self.junction))
2872 self.assertTrue(os.path.exists(self.junction))
2873 self.assertTrue(os.path.isdir(self.junction))
2874 self.assertNotEqual(os.stat(self.junction), os.lstat(self.junction))
2875 self.assertEqual(os.stat(self.junction), os.stat(self.junction_target))
2878 self.assertFalse(os.path.islink(self.junction))
2879 self.assertEqual(os.path.normcase("\\\\?\\" + self.junction_target),
2880 os.path.normcase(os.readlink(self.junction)))
2884 self.assertTrue(os.path.exists(self.junction))
2885 self.assertTrue(os.path.lexists(self.junction))
2887 os.unlink(self.junction)
2888 self.assertFalse(os.path.exists(self.junction))
2929 os.stat(name)
2942 # bpo-46785: the implementation of os.stat() falls back to reading
2952 import os
2966 os.remove(filename)
2974 os.stat(filename)
2993 os.makedirs('base/some_dir')
3010 src = os.path.join('base', 'some_link')
3011 os.symlink('some_dir', src)
3012 assert os.path.isdir(src)
3017 self.assertEqual(os.fsencode(b'abc\xff'), b'abc\xff')
3018 self.assertEqual(os.fsdecode('abc\u0141'), 'abc\u0141')
3024 bytesfn = os.fsencode(fn)
3027 self.assertEqual(os.fsdecode(bytesfn), fn)
3035 self.assertIsNone(os.device_encoding(123456))
3037 @unittest.skipUnless(os.isatty(0) and not win32_is_iot() and (sys.platform.startswith('win') or
3044 encoding = os.device_encoding(0)
3051 @unittest.skipUnless(hasattr(os, 'getppid'), "test needs os.getppid")
3054 'import os; print(os.getppid())'],
3058 self.assertEqual(int(stdout), os.getpid())
3062 # On Windows, os.spawnv() simply joins arguments with spaces:
3067 pid = os.spawnv(os.P_NOWAIT, sys.executable, args)
3072 # don't use support.wait_process() to test directly os.waitpid()
3073 # and os.waitstatus_to_exitcode()
3074 pid2, status = os.waitpid(pid, 0)
3075 self.assertEqual(os.waitstatus_to_exitcode(status), exitcode)
3087 os.waitstatus_to_exitcode(0.0)
3091 # bpo-40138: test os.waitpid() and os.waitstatus_to_exitcode()
3101 self.assertEqual(os.waitstatus_to_exitcode(exitcode << 8),
3106 os.waitstatus_to_exitcode((max_exitcode + 1) << 8)
3108 os.waitstatus_to_exitcode(-1)
3117 os.kill(pid, signum)
3126 # On Windows, os.spawn* simply joins arguments with spaces:
3128 if os.name != 'nt':
3141 self.env = dict(os.environ)
3145 # read the variable from os.environ to check that it exists
3146 code = ('import sys, os; magic = os.environ[%r]; sys.exit(%s)'
3155 program = os.fsencode(program)
3156 args = [os.fsencode(a) for a in args]
3157 self.env = {os.fsencode(k): os.fsencode(v)
3165 exitcode = os.spawnl(os.P_WAIT, program, *args)
3171 exitcode = os.spawnle(os.P_WAIT, program, *args, self.env)
3177 exitcode = os.spawnlp(os.P_WAIT, program, *args)
3183 exitcode = os.spawnlpe(os.P_WAIT, program, *args, self.env)
3189 exitcode = os.spawnv(os.P_WAIT, program, args)
3193 exitcode = os.spawnv(os.P_WAIT, FakePath(program), args)
3199 exitcode = os.spawnve(os.P_WAIT, program, args, self.env)
3205 exitcode = os.spawnvp(os.P_WAIT, program, args)
3211 exitcode = os.spawnvpe(os.P_WAIT, program, args, self.env)
3217 pid = os.spawnv(os.P_NOWAIT, program, args)
3224 exitcode = os.spawnve(os.P_WAIT, program, args, self.env)
3230 self.assertRaises(ValueError, os.spawnl, os.P_NOWAIT, program)
3231 self.assertRaises(ValueError, os.spawnl, os.P_NOWAIT, program, '')
3236 self.assertRaises(ValueError, os.spawnle, os.P_NOWAIT, program, {})
3237 self.assertRaises(ValueError, os.spawnle, os.P_NOWAIT, program, '', {})
3242 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, program, ())
3243 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, program, [])
3244 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, program, ('',))
3245 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, program, [''])
3250 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, program, (), {})
3251 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, program, [], {})
3252 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, program, ('',), {})
3253 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, program, [''], {})
3260 newenv = os.environ.copy()
3263 exitcode = spawn(os.P_WAIT, program, args, newenv)
3270 newenv = os.environ.copy()
3273 exitcode = spawn(os.P_WAIT, program, args, newenv)
3280 newenv = os.environ.copy()
3283 exitcode = spawn(os.P_WAIT, program, args, newenv)
3293 fp.write('import sys, os\n'
3294 'if os.getenv("FRUIT") != "orange=lemon":\n'
3298 newenv = os.environ.copy()
3300 exitcode = spawn(os.P_WAIT, program, args, newenv)
3305 self._test_invalid_env(os.spawnve)
3309 self._test_invalid_env(os.spawnvpe)
3315 @unittest.skipUnless(hasattr(os, 'getlogin'), "test needs os.getlogin")
3318 user_name = os.getlogin()
3322 @unittest.skipUnless(hasattr(os, 'getpriority') and hasattr(os, 'setpriority'),
3323 "needs os.getpriority and os.setpriority")
3325 """Tests for os.getpriority() and os.setpriority()."""
3329 base = os.getpriority(os.PRIO_PROCESS, os.getpid())
3330 os.setpriority(os.PRIO_PROCESS, os.getpid(), base + 1)
3332 new_prio = os.getpriority(os.PRIO_PROCESS, os.getpid())
3340 os.setpriority(os.PRIO_PROCESS, os.getpid(), base)
3346 @unittest.skipUnless(hasattr(os, 'sendfile'), "test needs os.sendfile()")
3396 return await asyncio.to_thread(os.sendfile, *args, **kwargs)
3552 @unittest.skipUnless(hasattr(os, 'SF_NODISKIO'),
3553 'test needs os.SF_NODISKIO')
3557 flags=os.SF_NODISKIO)
3564 if not hasattr(os, "setxattr"):
3570 os.setxattr(fp.fileno(), b"user.test", b"")
3602 setxattr(fn, s("user.test"), b"hello", os.XATTR_REPLACE, **kwargs)
3606 setxattr(fn, s("user.test"), b"bye", os.XATTR_CREATE, **kwargs)
3610 setxattr(fn, s("user.test2"), b"bye", os.XATTR_REPLACE, **kwargs)
3613 setxattr(fn, s("user.test2"), b"foo", os.XATTR_CREATE, **kwargs)
3637 self._check_xattrs_str(os.fsencode, *args, **kwargs)
3641 self._check_xattrs(os.getxattr, os.setxattr, os.removexattr,
3642 os.listxattr)
3645 self._check_xattrs(os.getxattr, os.setxattr, os.removexattr,
3646 os.listxattr, follow_symlinks=False)
3651 return os.getxattr(fp.fileno(), *args)
3654 os.setxattr(fp.fileno(), *args)
3657 os.removexattr(fp.fileno(), *args)
3660 return os.listxattr(fp.fileno(), *args)
3664 @unittest.skipUnless(hasattr(os, 'get_terminal_size'), "requires os.get_terminal_size")
3673 size = os.get_terminal_size()
3703 actual = os.get_terminal_size(sys.__stdin__.fileno())
3713 @unittest.skipUnless(hasattr(os, 'memfd_create'), 'requires os.memfd_create')
3717 fd = os.memfd_create("Hi", os.MFD_CLOEXEC)
3719 self.addCleanup(os.close, fd)
3720 self.assertFalse(os.get_inheritable(fd))
3725 fd2 = os.memfd_create("Hi")
3726 self.addCleanup(os.close, fd2)
3727 self.assertFalse(os.get_inheritable(fd2))
3730 @unittest.skipUnless(hasattr(os, 'eventfd'), 'requires os.eventfd')
3740 fd = os.eventfd(initval)
3742 self.addCleanup(os.close, fd)
3743 self.assertFalse(os.get_inheritable(fd))
3746 res = os.read(fd, size)
3749 os.write(fd, pack(23))
3750 res = os.read(fd, size)
3753 os.write(fd, pack(40))
3754 os.write(fd, pack(2))
3755 res = os.read(fd, size)
3759 os.eventfd_write(fd, 20)
3760 os.eventfd_write(fd, 3)
3761 res = os.eventfd_read(fd)
3766 flags = os.EFD_CLOEXEC | os.EFD_SEMAPHORE | os.EFD_NONBLOCK
3767 fd = os.eventfd(initval, flags)
3769 self.addCleanup(os.close, fd)
3772 res = os.eventfd_read(fd)
3774 res = os.eventfd_read(fd)
3778 os.eventfd_read(fd)
3780 os.read(fd, 8)
3783 os.eventfd_write(fd, 1)
3784 res = os.eventfd_read(fd)
3788 os.eventfd_read(fd)
3791 flags = os.EFD_CLOEXEC | os.EFD_NONBLOCK
3792 fd = os.eventfd(0, flags)
3794 self.addCleanup(os.close, fd)
3801 os.eventfd_write(fd, 23)
3804 self.assertEqual(os.eventfd_read(fd), 23)
3807 os.eventfd_write(fd, (2**64) - 2)
3810 os.eventfd_read(fd)
3829 encoded = os.fsencode(os_helper.TESTFN)
3838 (self.filenames, os.chdir,),
3839 (self.filenames, os.lstat,),
3840 (self.filenames, os.open, os.O_RDONLY),
3841 (self.filenames, os.rmdir,),
3842 (self.filenames, os.stat,),
3843 (self.filenames, os.unlink,),
3847 (self.bytes_filenames, os.rename, b"dst"),
3848 (self.bytes_filenames, os.replace, b"dst"),
3849 (self.unicode_filenames, os.rename, "dst"),
3850 (self.unicode_filenames, os.replace, "dst"),
3851 (self.unicode_filenames, os.listdir, ),
3855 (self.filenames, os.listdir,),
3856 (self.filenames, os.rename, "dst"),
3857 (self.filenames, os.replace, "dst"),
3860 funcs.append((self.filenames, os.chmod, 0o777))
3861 if hasattr(os, "chown"):
3862 funcs.append((self.filenames, os.chown, 0, 0))
3863 if hasattr(os, "lchown"):
3864 funcs.append((self.filenames, os.lchown, 0, 0))
3865 if hasattr(os, "truncate"):
3866 funcs.append((self.filenames, os.truncate, 0))
3867 if hasattr(os, "chflags"):
3868 funcs.append((self.filenames, os.chflags, 0))
3869 if hasattr(os, "lchflags"):
3870 funcs.append((self.filenames, os.lchflags, 0))
3871 if hasattr(os, "chroot"):
3872 funcs.append((self.filenames, os.chroot,))
3873 if hasattr(os, "link"):
3875 funcs.append((self.bytes_filenames, os.link, b"dst"))
3876 funcs.append((self.unicode_filenames, os.link, "dst"))
3878 funcs.append((self.filenames, os.link, "dst"))
3879 if hasattr(os, "listxattr"):
3881 (self.filenames, os.listxattr,),
3882 (self.filenames, os.getxattr, "user.test"),
3883 (self.filenames, os.setxattr, "user.test", b'user'),
3884 (self.filenames, os.removexattr, "user.test"),
3886 if hasattr(os, "lchmod"):
3887 funcs.append((self.filenames, os.lchmod, 0o777))
3888 if hasattr(os, "readlink"):
3889 funcs.append((self.filenames, os.readlink,))
3909 cpus = os.cpu_count()
3921 fd = os.open(__file__, os.O_RDONLY)
3922 self.addCleanup(os.close, fd)
3923 self.assertEqual(os.get_inheritable(fd), False)
3925 os.set_inheritable(fd, True)
3926 self.assertEqual(os.get_inheritable(fd), True)
3930 fd = os.open(__file__, os.O_RDONLY)
3931 self.addCleanup(os.close, fd)
3932 self.assertEqual(os.get_inheritable(fd), False)
3939 self.assertEqual(os.get_inheritable(fd), True)
3943 fd = os.open(__file__, os.O_RDONLY)
3944 self.addCleanup(os.close, fd)
3948 os.set_inheritable(fd, True)
3952 @unittest.skipUnless(hasattr(os, 'O_PATH'), "need os.O_PATH")
3954 fd = os.open(__file__, os.O_PATH)
3955 self.addCleanup(os.close, fd)
3956 self.assertEqual(os.get_inheritable(fd), False)
3958 os.set_inheritable(fd, True)
3959 self.assertEqual(os.get_inheritable(fd), True)
3961 os.set_inheritable(fd, False)
3962 self.assertEqual(os.get_inheritable(fd), False)
3968 os.get_inheritable(fd)
3972 os.set_inheritable(fd, True)
3976 os.set_inheritable(fd, False)
3980 fd = os.open(__file__, os.O_RDONLY)
3981 self.addCleanup(os.close, fd)
3982 self.assertEqual(os.get_inheritable(fd), False)
3984 @unittest.skipUnless(hasattr(os, 'pipe'), "need os.pipe()")
3986 rfd, wfd = os.pipe()
3987 self.addCleanup(os.close, rfd)
3988 self.addCleanup(os.close, wfd)
3989 self.assertEqual(os.get_inheritable(rfd), False)
3990 self.assertEqual(os.get_inheritable(wfd), False)
3993 fd1 = os.open(__file__, os.O_RDONLY)
3994 self.addCleanup(os.close, fd1)
3996 fd2 = os.dup(fd1)
3997 self.addCleanup(os.close, fd2)
3998 self.assertEqual(os.get_inheritable(fd2), False)
4001 fd = os.dup(1)
4002 self.addCleanup(os.close, fd)
4007 # os.dup() was creating inheritable fds for character files.
4008 fd1 = os.open('NUL', os.O_RDONLY)
4009 self.addCleanup(os.close, fd1)
4010 fd2 = os.dup(fd1)
4011 self.addCleanup(os.close, fd2)
4012 self.assertFalse(os.get_inheritable(fd2))
4014 @unittest.skipUnless(hasattr(os, 'dup2'), "need os.dup2()")
4016 fd = os.open(__file__, os.O_RDONLY)
4017 self.addCleanup(os.close, fd)
4020 fd2 = os.open(__file__, os.O_RDONLY)
4021 self.addCleanup(os.close, fd2)
4022 self.assertEqual(os.dup2(fd, fd2), fd2)
4023 self.assertTrue(os.get_inheritable(fd2))
4026 fd3 = os.open(__file__, os.O_RDONLY)
4027 self.addCleanup(os.close, fd3)
4028 self.assertEqual(os.dup2(fd, fd3, inheritable=False), fd3)
4029 self.assertFalse(os.get_inheritable(fd3))
4031 @unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
4033 master_fd, slave_fd = os.openpty()
4034 self.addCleanup(os.close, master_fd)
4035 self.addCleanup(os.close, slave_fd)
4036 self.assertEqual(os.get_inheritable(master_fd), False)
4037 self.assertEqual(os.get_inheritable(slave_fd), False)
4046 ('access', False, (os.F_OK,), None),
4049 ('open', False, (os.O_RDONLY,), getattr(os, 'close', None)),
4054 if os.name == 'nt':
4057 bytes_filename = os.fsencode(os_helper.TESTFN)
4059 fd = os.open(FakePath(str_filename), os.O_WRONLY|os.O_CREAT)
4061 self.addCleanup(os.close, fd)
4069 fn = getattr(os, name)
4093 'os.PathLike'):
4099 os.stat(FakePath(2))
4101 os.stat(FakePath(2.34))
4103 os.stat(FakePath(object()))
4106 @unittest.skipUnless(hasattr(os, 'get_blocking'),
4107 'needs os.get_blocking() and os.set_blocking()')
4111 fd = os.open(__file__, os.O_RDONLY)
4112 self.addCleanup(os.close, fd)
4113 self.assertEqual(os.get_blocking(fd), True)
4115 os.set_blocking(fd, False)
4116 self.assertEqual(os.get_blocking(fd), False)
4118 os.set_blocking(fd, True)
4119 self.assertEqual(os.get_blocking(fd), True)
4125 self.assertIn('open', os.__all__)
4126 self.assertIn('walk', os.__all__)
4131 self.path = os.path.realpath(os_helper.TESTFN)
4133 os.mkdir(self.path)
4136 self.assertRaises(TypeError, os.DirEntry)
4139 filename = create_file(os.path.join(self.path, "file.txt"), b'python')
4140 entry = [entry for entry in os.scandir(self.path)].pop()
4141 self.assertIsInstance(entry, os.DirEntry)
4151 self.path = os.path.realpath(os_helper.TESTFN)
4152 self.bytes_path = os.fsencode(self.path)
4154 os.mkdir(self.path)
4158 filename = os.path.join(path, name)
4164 for entry in os.scandir(self.path))
4182 scandir_iter = os.scandir(self.path)
4188 scandir_iter = os.scandir(self.path)
4194 self.assertIsInstance(entry, os.DirEntry)
4196 self.assertEqual(entry.path, os.path.join(self.path, name))
4198 os.stat(entry.path, follow_symlinks=False).st_ino)
4200 entry_stat = os.stat(entry.path)
4206 os.path.islink(entry.path))
4208 entry_lstat = os.stat(entry.path, follow_symlinks=False)
4216 os.name == 'nt' and not is_symlink)
4219 os.name == 'nt')
4222 link = hasattr(os, 'link')
4225 dirname = os.path.join(self.path, "dir")
4226 os.mkdir(dirname)
4230 os.link(filename, os.path.join(self.path, "link_file.txt"))
4232 self.skipTest('os.link(): %s' % e)
4234 os.symlink(dirname, os.path.join(self.path, "symlink_dir"),
4236 os.symlink(filename, os.path.join(self.path, "symlink_file.txt"))
4264 entries = list(os.scandir(path))
4273 return self.get_entry(os.path.basename(filename))
4277 old_dir = os.getcwd()
4279 os.chdir(self.path)
4283 entries = dict((entry.name, entry) for entry in os.scandir())
4285 [os.path.basename(filename)])
4287 os.chdir(old_dir)
4295 self.assertEqual(os.fspath(entry), os.path.join(self.path, 'file.txt'))
4298 bytes_filename = os.fsencode('bytesfile.txt')
4300 fspath = os.fspath(bytes_entry)
4303 os.path.join(os.fsencode(self.path),bytes_filename))
4306 path = os.path.join(self.path, 'dir')
4308 os.mkdir(path)
4310 os.rmdir(path)
4313 if os.name == 'nt':
4317 if os.name == 'nt':
4329 os.unlink(entry.path)
4333 if os.name == 'nt':
4336 if os.name == 'nt':
4351 os.symlink(filename,
4352 os.path.join(self.path, "symlink.txt"))
4355 os.unlink(filename)
4370 path_bytes = os.fsencode(self.path)
4371 entries = list(os.scandir(path_bytes))
4377 os.fsencode(os.path.join(self.path, 'file.txt')))
4383 path_bytes = cls(os.fsencode(self.path))
4385 entries = list(os.scandir(path_bytes))
4391 os.fsencode(os.path.join(self.path, 'file.txt')))
4395 @unittest.skipUnless(os.listdir in os.supports_fd,
4398 self.assertIn(os.scandir, os.supports_fd)
4402 os.symlink('file.txt', os.path.join(self.path, 'link'))
4406 with os.scandir(fd) as it:
4410 self.assertEqual(names, os.listdir(fd))
4413 self.assertEqual(os.fspath(entry), entry.name)
4415 if os.stat in os.supports_dir_fd:
4416 st = os.stat(entry.name, dir_fd=fd)
4418 st = os.stat(entry.name, dir_fd=fd, follow_symlinks=False)
4423 self.assertRaises(FileNotFoundError, os.scandir, '')
4427 iterator = os.scandir(self.path)
4438 self.assertRaises(TypeError, os.scandir, obj)
4443 iterator = os.scandir(self.path)
4454 with os.scandir(self.path) as iterator:
4462 with os.scandir(self.path) as iterator:
4470 with os.scandir(self.path) as iterator:
4479 iterator = os.scandir(self.path)
4485 iterator = os.scandir(self.path)
4495 fspath = staticmethod(os.fspath)
4510 self.assertEqual(b"path/like/object", os.fsencode(pathlike))
4511 self.assertEqual("path/like/object", os.fsdecode(pathlike))
4515 self.assertTrue(issubclass(FakePath, os.PathLike))
4516 self.assertTrue(isinstance(FakePath('x'), os.PathLike))
4520 for o in int, type, os, vapor():
4540 class A(os.PathLike):
4543 self.assertTrue(issubclass(FakePath, os.PathLike))
4546 self.assertIsInstance(os.PathLike[bytes], types.GenericAlias)
4551 times = os.times()
4552 self.assertIsInstance(times, os.times_result)
4559 if os.name == 'nt':
4568 # bpo-42540: ensure os.fork() with non-default memory allocator does
4571 import os
4573 pid = os.fork()
4583 if hasattr(os, "_fspath"):
4586 """Explicitly test the pure Python implementation of os.fspath()."""
4588 fspath = staticmethod(os._fspath)