Lines Matching full:os
1 # As a test suite for the os module, this is woefully inadequate, but this
16 import os
63 if hasattr(os, 'geteuid'):
64 root_in_posix = (os.geteuid() == 0)
76 HAVE_WHEEL_GROUP = sys.platform.startswith('freebsd') and os.getgid() == 0
80 return unittest.skipUnless(hasattr(os, name), 'requires os.%s' % name)
90 cwd = os.getcwd()
96 # longer path if longer paths support is enabled. Internally, the os
115 cwd = os.getcwd()
118 need = min_len - (len(cwd) + len(os.path.sep))
124 path = os.path.join(path, dirname)
126 os.mkdir(path)
129 os.chdir(path)
147 cwd = os.getcwdb()
149 self.assertEqual(os.fsdecode(cwd), os.getcwd())
155 if os.path.lexists(support.TESTFN):
156 os.unlink(support.TESTFN)
160 f = os.open(support.TESTFN, os.O_CREAT|os.O_RDWR)
161 os.close(f)
162 self.assertTrue(os.access(support.TESTFN, os.W_OK))
165 first = os.open(support.TESTFN, os.O_CREAT|os.O_RDWR)
169 second = os.dup(first)
173 os.close(first)
178 first, second = second, os.dup(second)
180 os.close(second)
182 os.closerange(first, first + 2)
183 self.assertRaises(OSError, os.write, first, b"a")
189 self.assertRaises(TypeError, os.rename, path, 0)
198 os.lseek(fd, 0, 0)
199 s = os.read(fd, 4)
213 # Issue #21932: Make sure that os.read() does not raise an
216 data = os.read(fp.fileno(), size)
223 # os.write() accepts bytes- and buffer-like objects but not strings
224 fd = os.open(support.TESTFN, os.O_CREAT | os.O_WRONLY)
225 self.assertRaises(TypeError, os.write, fd, "beans")
226 os.write(fd, b"bacon\n")
227 os.write(fd, bytearray(b"eggs\n"))
228 os.write(fd, memoryview(b"spam\n"))
229 os.close(fd)
254 fd = os.open(support.TESTFN, os.O_RDONLY)
255 f = os.fdopen(fd, *args)
259 fd = os.open(support.TESTFN, os.O_CREAT|os.O_RDWR)
260 os.close(fd)
274 os.replace(support.TESTFN, TESTFN2)
275 self.assertRaises(FileNotFoundError, os.stat, support.TESTFN)
280 f = os.open(path=__file__, flags=os.O_RDONLY, mode=0o777,
282 os.close(f)
285 symlink = support.get_attribute(os, "symlink")
290 pass # No OS support or unprivileged user
292 @unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')
295 os.copy_file_range(0, 1, -10)
297 @unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')
315 i = os.copy_file_range(in_fd, out_fd, 5)
331 @unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')
352 i = os.copy_file_range(in_fd, out_fd, bytes_to_copy,
376 # Test attributes on return values from os.*stat* family.
384 result = os.stat(fname)
437 result2 = os.stat_result((10,))
444 result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
459 result = os.stat(self.fname)
468 @unittest.skipUnless(hasattr(os, 'statvfs'), 'test needs os.statvfs()')
470 result = os.statvfs(self.fname)
501 result2 = os.statvfs_result((10,))
508 result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
512 @unittest.skipUnless(hasattr(os, 'statvfs'),
513 "need os.statvfs()")
515 result = os.statvfs(self.fname)
529 os.stat(r"c:\pagefile.sys")
536 @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
539 r, w = os.pipe()
541 os.stat(r) # should not raise error
543 os.close(r)
544 os.close(w)
546 os.stat(r)
558 result = os.stat(self.fname)
566 os.mkdir(dirname)
567 self.addCleanup(os.rmdir, dirname)
569 result = os.stat(dirname)
579 # os.environ['TEMP'] should be located on a volume that
581 fname = os.path.join(os.environ['TEMP'], self.fname)
593 result = os.stat(fname)
598 # bpo-38030: os.stat fails for block devices
600 fname = "//./" + os.path.splitdrive(os.getcwd())[0]
601 result = os.stat(fname)
608 self.fname = os.path.join(self.dirname, "f1")
611 os.mkdir(self.dirname)
617 st = os.stat(filename)
630 # The resolution of the C internal function used by os.utime()
642 st = os.stat(filename)
656 os.utime(filename, ns=ns)
663 # issue, os.utime() rounds towards minus infinity.
674 os.utime(filename, (atime, mtime))
683 os.utime(filename, times=(atime, mtime))
686 @unittest.skipUnless(os.utime in os.supports_follow_symlinks,
693 os.utime(filename, ns=ns, follow_symlinks=False)
696 @unittest.skipUnless(os.utime in os.supports_fd,
703 os.utime(fp.fileno(), ns=ns)
706 @unittest.skipUnless(os.utime in os.supports_dir_fd,
710 dirname, name = os.path.split(filename)
711 dirfd = os.open(dirname, os.O_RDONLY)
714 os.utime(name, dir_fd=dirfd, ns=ns)
716 os.close(dirfd)
721 # test calling os.utime() on a directory
722 os.utime(filename, ns=ns)
729 # Call os.utime() to set the timestamp to the current system clock
741 st = os.stat(self.fname)
750 os.utime(self.fname)
756 os.utime(self.fname, None)
761 root = os.path.splitdrive(os.path.abspath(path))[0] + '\\'
779 os.utime(self.fname, (large, large))
780 self.assertEqual(os.stat(self.fname).st_mtime, large)
785 os.utime(self.fname, (5, 5), ns=(5, 5))
787 os.utime(self.fname, [5, 5])
789 os.utime(self.fname, (5,))
791 os.utime(self.fname, (5, 5, 5))
793 os.utime(self.fname, ns=[5, 5])
795 os.utime(self.fname, ns=(5,))
797 os.utime(self.fname, ns=(5, 5, 5))
799 if os.utime not in os.supports_follow_symlinks:
801 os.utime(self.fname, (5, 5), follow_symlinks=False)
802 if os.utime not in os.supports_fd:
805 os.utime(fp.fileno(), (5, 5))
806 if os.utime not in os.supports_dir_fd:
808 os.utime(self.fname, (5, 5), dir_fd=0)
820 os.utime(self.fname, ns=(get_bad_int(42), 1))
822 os.utime(self.fname, ns=(get_bad_int(()), 1))
824 os.utime(self.fname, ns=(get_bad_int((1, 2, 3)), 1))
830 """check that os.environ object conform to mapping protocol"""
834 self.__save = dict(os.environ)
835 if os.supports_bytes_environ:
836 self.__saveb = dict(os.environb)
838 os.environ[key] = value
841 os.environ.clear()
842 os.environ.update(self.__save)
843 if os.supports_bytes_environ:
844 os.environb.clear()
845 os.environb.update(self.__saveb)
851 os.environ.clear()
852 return os.environ
855 @unittest.skipUnless(unix_shell and os.path.exists(unix_shell),
858 os.environ.clear()
859 os.environ.update(HELLO="World")
860 with os.popen("%s -c 'echo $HELLO'" % unix_shell) as popen:
864 @unittest.skipUnless(unix_shell and os.path.exists(unix_shell),
867 with os.popen("%s -c 'echo \"line1\nline2\nline3\"'"
875 # Verify environ keys and values from the OS are of the
878 for key, val in os.environ.items():
884 self.assertEqual(os.environ.get(key), value)
888 """Check that the repr() of os.environ looks like environ({...})."""
889 env = os.environ
895 defpath_list = os.defpath.split(os.pathsep)
897 test_env = {'PATH': os.pathsep.join(test_path)}
899 saved_environ = os.environ
901 os.environ = dict(test_env)
902 # Test that defaulting to os.environ works.
903 self.assertSequenceEqual(test_path, os.get_exec_path())
904 self.assertSequenceEqual(test_path, os.get_exec_path(env=None))
906 os.environ = saved_environ
909 self.assertSequenceEqual(defpath_list, os.get_exec_path({}))
911 self.assertSequenceEqual(('',), os.get_exec_path({'PATH':''}))
913 self.assertSequenceEqual(test_path, os.get_exec_path(test_env))
915 if os.supports_bytes_environ:
925 self.assertRaises(ValueError, os.get_exec_path, mixed_env)
928 self.assertSequenceEqual(os.get_exec_path({b'PATH': b'abc'}),
930 self.assertSequenceEqual(os.get_exec_path({b'PATH': 'abc'}),
932 self.assertSequenceEqual(os.get_exec_path({'PATH': b'abc'}),
935 @unittest.skipUnless(os.supports_bytes_environ,
936 "os.environb required for this test.")
938 # os.environ -> os.environb
947 os.environ['unicode'] = value
948 self.assertEqual(os.environ['unicode'], value)
949 self.assertEqual(os.environb[b'unicode'], value_bytes)
951 # os.environb -> os.environ
953 os.environb[b'bytes'] = value
954 self.assertEqual(os.environb[b'bytes'], value)
956 self.assertEqual(os.environ['bytes'], value_str)
961 code = f'import os; print(repr(os.environ.get({name!r})))'
966 os.putenv(name, value)
971 os.unsetenv(name)
976 # On OS X < 10.6, unsetenv() doesn't return a value (bpo-13415).
982 self.assertRaises((OSError, ValueError), os.putenv, name, "value")
983 self.assertRaises((OSError, ValueError), os.unsetenv, name)
989 self.assertRaises(ValueError, os.putenv, longstr, "1")
990 self.assertRaises(ValueError, os.putenv, "X", longstr)
991 self.assertRaises(ValueError, os.unsetenv, longstr)
995 self.assertNotIn(missing, os.environ)
998 os.environ[missing]
1003 del os.environ[missing]
1011 next(iterator) # start iteration over os.environ.items
1013 # add a new key in os.environ mapping
1014 os.environ[new_key] = "test_environ_iteration"
1018 self.assertEqual(os.environ[new_key], "test_environ_iteration")
1020 del os.environ[new_key]
1023 self._test_environ_iteration(os.environ)
1026 self._test_environ_iteration(os.environ.items())
1029 self._test_environ_iteration(os.environ.values())
1032 if not (unix_shell and os.path.exists(unix_shell)):
1035 with os.popen(f"{unix_shell} -c 'echo ${var}'") as popen:
1043 os.environ[overridden_key] = original_value
1046 expected = dict(os.environ)
1049 actual = os.environ | new_vars_dict
1054 self.assertIs(NotImplemented, os.environ.__or__(new_vars_items))
1061 os.environ[overridden_key] = 'original_value'
1064 expected = dict(os.environ)
1067 os.environ |= new_vars_dict
1068 self.assertEqual(expected, os.environ)
1069 self.assertEqual('3', os.environ[overridden_key])
1075 os_environ_copy = os.environ.copy()
1078 os.environ |= dict_with_bad_key
1082 os.environ |= dict_with_bad_val
1085 self.assertEqual(os_environ_copy, os.environ)
1089 os.environ[overridden_key] = 'original_value'
1092 expected = dict(os.environ)
1095 os.environ |= new_vars_items
1096 self.assertEqual(expected, os.environ)
1097 self.assertEqual('3', os.environ[overridden_key])
1105 os.environ[overridden_key] = original_value
1109 expected.update(os.environ)
1111 actual = new_vars_dict | os.environ
1116 self.assertIs(NotImplemented, os.environ.__ror__(new_vars_items))
1123 """Tests for os.walk()."""
1125 # Wrapper to hide minor differences between os.walk and os.fwalk
1130 return os.walk(top, **kwargs)
1133 join = os.path.join
1170 os.makedirs(self.sub11_path)
1171 os.makedirs(sub2_path)
1172 os.makedirs(sub21_path)
1173 os.makedirs(t2_path)
1180 os.symlink(os.path.abspath(t2_path), self.link_path)
1181 os.symlink('broken', broken_link_path, True)
1182 os.symlink(join('tmp3', 'broken'), broken_link2_path, True)
1183 os.symlink(join('SUB21', 'tmp5'), broken_link3_path, True)
1190 os.chmod(sub21_path, 0)
1192 os.listdir(sub21_path)
1194 self.addCleanup(os.chmod, sub21_path, stat.S_IRWXU)
1196 os.chmod(sub21_path, stat.S_IRWXU)
1197 os.unlink(tmp5_path)
1198 os.rmdir(sub21_path)
1282 path1 = os.path.join(root, dir1)
1283 path1new = os.path.join(root, dir1 + '.new')
1284 os.rename(path1, path1new)
1292 self.assertIn(os.path.join(root, dir2), roots)
1294 os.rename(path1new, path1)
1298 base = os.path.join(support.TESTFN, 'deep')
1299 p = os.path.join(base, *(['d']*depth))
1300 os.makedirs(p)
1307 p = os.path.dirname(p)
1315 p = os.path.join(p, 'd')
1318 @unittest.skipUnless(hasattr(os, 'fwalk'), "Test needs os.fwalk()")
1320 """Tests for os.fwalk()."""
1327 return os.fwalk(*args, **kwargs)
1340 for root, dirs, files in os.walk(**walk_kwargs):
1353 fd = os.open(".", os.O_RDONLY)
1359 os.close(fd)
1367 os.fstat(rootfd)
1369 os.stat(rootfd)
1371 self.assertEqual(set(os.listdir(rootfd)), set(dirs) | set(files))
1377 minfd = os.dup(1)
1378 os.close(minfd)
1382 newfd = os.dup(1)
1383 self.addCleanup(os.close, newfd)
1391 """Tests for os.walk() with bytes."""
1395 for broot, bdirs, bfiles in os.walk(os.fsencode(top), **kwargs):
1396 root = os.fsdecode(broot)
1397 dirs = list(map(os.fsdecode, bdirs))
1398 files = list(map(os.fsdecode, bfiles))
1400 bdirs[:] = list(map(os.fsencode, dirs))
1401 bfiles[:] = list(map(os.fsencode, files))
1403 @unittest.skipUnless(hasattr(os, 'fwalk'), "Test needs os.fwalk()")
1405 """Tests for os.walk() with bytes."""
1407 for broot, bdirs, bfiles, topfd in os.fwalk(os.fsencode(top), *args, **kwargs):
1408 root = os.fsdecode(broot)
1409 dirs = list(map(os.fsdecode, bdirs))
1410 files = list(map(os.fsdecode, bfiles))
1412 bdirs[:] = list(map(os.fsencode, dirs))
1413 bfiles[:] = list(map(os.fsencode, files))
1418 os.mkdir(support.TESTFN)
1422 path = os.path.join(base, 'dir1', 'dir2', 'dir3')
1423 os.makedirs(path) # Should work
1424 path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4')
1425 os.makedirs(path)
1428 self.assertRaises(OSError, os.makedirs, os.curdir)
1429 path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4', 'dir5', os.curdir)
1430 os.makedirs(path)
1431 path = os.path.join(base, 'dir1', os.curdir, 'dir2', 'dir3', 'dir4',
1433 os.makedirs(path)
1438 parent = os.path.join(base, 'dir1')
1439 path = os.path.join(parent, 'dir2')
1440 os.makedirs(path, 0o555)
1441 self.assertTrue(os.path.exists(path))
1442 self.assertTrue(os.path.isdir(path))
1443 if os.name != 'nt':
1444 self.assertEqual(os.stat(path).st_mode & 0o777, 0o555)
1445 self.assertEqual(os.stat(parent).st_mode & 0o777, 0o775)
1448 path = os.path.join(support.TESTFN, 'dir1')
1450 old_mask = os.umask(0o022)
1451 os.makedirs(path, mode)
1452 self.assertRaises(OSError, os.makedirs, path, mode)
1453 self.assertRaises(OSError, os.makedirs, path, mode, exist_ok=False)
1454 os.makedirs(path, 0o776, exist_ok=True)
1455 os.makedirs(path, mode=mode, exist_ok=True)
1456 os.umask(old_mask)
1459 os.makedirs(os.path.abspath('/'), exist_ok=True)
1462 path = os.path.join(support.TESTFN, 'dir1')
1465 old_mask = os.umask(0o022)
1468 os.lstat(support.TESTFN).st_mode)
1470 os.chmod(support.TESTFN, existing_testfn_mode | S_ISGID)
1473 if (os.lstat(support.TESTFN).st_mode & S_ISGID != S_ISGID):
1475 # The os should apply S_ISGID from the parent dir for us, but
1477 os.makedirs(path, mode | S_ISGID)
1480 os.makedirs(path, mode, exist_ok=True)
1482 os.chmod(path, stat.S_IMODE(os.lstat(path).st_mode) & ~S_ISGID)
1484 os.makedirs(path, mode | S_ISGID, exist_ok=True)
1486 os.umask(old_mask)
1490 path = os.path.join(support.TESTFN, 'dir1')
1493 self.assertRaises(OSError, os.makedirs, path)
1494 self.assertRaises(OSError, os.makedirs, path, exist_ok=False)
1495 self.assertRaises(OSError, os.makedirs, path, exist_ok=True)
1496 os.remove(path)
1499 path = os.path.join(support.TESTFN, 'dir1', 'dir2', 'dir3',
1504 while not os.path.exists(path) and path != support.TESTFN:
1505 path = os.path.dirname(path)
1507 os.removedirs(path)
1510 @unittest.skipUnless(hasattr(os, 'chown'), "Test needs chown")
1515 os.mkdir(support.TESTFN)
1518 stat = os.stat(support.TESTFN)
1522 self.assertRaises(TypeError, os.chown, support.TESTFN, value, gid)
1523 self.assertRaises(TypeError, os.chown, support.TESTFN, uid, value)
1524 self.assertIsNone(os.chown(support.TESTFN, uid, gid))
1525 self.assertIsNone(os.chown(support.TESTFN, -1, -1))
1527 @unittest.skipUnless(hasattr(os, 'getgroups'), 'need os.getgroups')
1529 groups = os.getgroups()
1534 uid = os.stat(support.TESTFN).st_uid
1536 os.chown(support.TESTFN, uid, gid_1)
1537 gid = os.stat(support.TESTFN).st_gid
1540 os.chown(support.TESTFN, uid, gid_2)
1541 gid = os.stat(support.TESTFN).st_gid
1548 gid = os.stat(support.TESTFN).st_gid
1549 os.chown(support.TESTFN, uid_1, gid)
1550 uid = os.stat(support.TESTFN).st_uid
1552 os.chown(support.TESTFN, uid_2, gid)
1553 uid = os.stat(support.TESTFN).st_uid
1560 gid = os.stat(support.TESTFN).st_gid
1562 os.chown(support.TESTFN, uid_1, gid)
1563 os.chown(support.TESTFN, uid_2, gid)
1567 os.rmdir(support.TESTFN)
1572 os.makedirs(support.TESTFN)
1578 dira = os.path.join(support.TESTFN, 'dira')
1579 os.mkdir(dira)
1580 dirb = os.path.join(dira, 'dirb')
1581 os.mkdir(dirb)
1582 os.removedirs(dirb)
1583 self.assertFalse(os.path.exists(dirb))
1584 self.assertFalse(os.path.exists(dira))
1585 self.assertFalse(os.path.exists(support.TESTFN))
1588 dira = os.path.join(support.TESTFN, 'dira')
1589 os.mkdir(dira)
1590 dirb = os.path.join(dira, 'dirb')
1591 os.mkdir(dirb)
1592 create_file(os.path.join(dira, 'file.txt'))
1593 os.removedirs(dirb)
1594 self.assertFalse(os.path.exists(dirb))
1595 self.assertTrue(os.path.exists(dira))
1596 self.assertTrue(os.path.exists(support.TESTFN))
1599 dira = os.path.join(support.TESTFN, 'dira')
1600 os.mkdir(dira)
1601 dirb = os.path.join(dira, 'dirb')
1602 os.mkdir(dirb)
1603 create_file(os.path.join(dirb, 'file.txt'))
1605 os.removedirs(dirb)
1606 self.assertTrue(os.path.exists(dirb))
1607 self.assertTrue(os.path.exists(dira))
1608 self.assertTrue(os.path.exists(support.TESTFN))
1613 with open(os.devnull, 'wb', 0) as f:
1616 with open(os.devnull, 'rb') as f:
1622 self.assertEqual(len(os.urandom(0)), 0)
1623 self.assertEqual(len(os.urandom(1)), 1)
1624 self.assertEqual(len(os.urandom(10)), 10)
1625 self.assertEqual(len(os.urandom(100)), 100)
1626 self.assertEqual(len(os.urandom(1000)), 1000)
1629 data1 = os.urandom(16)
1631 data2 = os.urandom(16)
1636 'import os, sys',
1637 'data = os.urandom(%s)' % count,
1651 @unittest.skipUnless(hasattr(os, 'getrandom'), 'need os.getrandom()')
1656 os.getrandom(1)
1666 data = os.getrandom(16)
1671 empty = os.getrandom(0)
1675 self.assertTrue(hasattr(os, 'GRND_RANDOM'))
1677 # Don't test os.getrandom(1, os.GRND_RANDOM) to not consume the rare
1683 os.getrandom(1, os.GRND_NONBLOCK)
1689 data1 = os.getrandom(16)
1690 data2 = os.getrandom(16)
1694 # os.urandom() doesn't use a file descriptor when it is implemented with the
1702 "os.random() does not use a file descriptor")
1711 # test suite would crash; this actually happened on the OS X Tiger
1715 import os
1721 os.urandom(16)
1733 import os
1736 os.urandom(4)
1738 os.closerange(3, 256)
1739 sys.stdout.buffer.write(os.urandom(4))
1750 import os
1753 os.urandom(4)
1757 os.close(fd)
1763 os.closerange(3, 256)
1770 os.dup2(new_fd, fd)
1771 sys.stdout.buffer.write(os.urandom(4))
1772 sys.stdout.buffer.write(os.urandom(4))
1802 orig_execv = os.execv
1803 orig_execve = os.execve
1804 orig_defpath = os.defpath
1805 os.execv = mock_execv
1806 os.execve = mock_execve
1808 os.defpath = defpath
1811 os.execv = orig_execv
1812 os.execve = orig_execve
1813 os.defpath = orig_defpath
1815 @unittest.skipUnless(hasattr(os, 'execv'),
1816 "need os.execv()")
1821 self.assertRaises(OSError, os.execvpe, 'no such app-',
1825 self.assertRaises(ValueError, os.execv, 'notepad', ())
1826 self.assertRaises(ValueError, os.execv, 'notepad', [])
1827 self.assertRaises(ValueError, os.execv, 'notepad', ('',))
1828 self.assertRaises(ValueError, os.execv, 'notepad', [''])
1831 self.assertRaises(ValueError, os.execvpe, 'notepad', [], None)
1832 self.assertRaises(ValueError, os.execvpe, 'notepad', [], {})
1833 self.assertRaises(ValueError, os.execvpe, 'notepad', [''], {})
1835 @unittest.skipUnless(hasattr(os, '_execvpe'),
1836 "No internal os._execvpe function to test.")
1838 program_path = os.sep + 'absolutepath'
1841 fullpath = os.path.join(os.fsencode(program_path), program)
1847 fullpath = os.path.join(program_path, program)
1848 if os.name != "nt":
1849 native_fullpath = os.fsencode(fullpath)
1854 # test os._execvpe() with an absolute path
1857 os._execvpe, fullpath, arguments)
1861 # test os._execvpe() with a relative path:
1862 # os.get_exec_path() returns defpath
1865 os._execvpe, program, arguments, env=env)
1870 # test os._execvpe() with a relative path:
1871 # os.get_exec_path() reads the 'PATH' variable
1879 os._execvpe, program, arguments, env=env_path)
1886 if os.name != "nt":
1893 newenv = os.environ.copy()
1896 os.execve(args[0], args, newenv)
1899 newenv = os.environ.copy()
1902 os.execve(args[0], args, newenv)
1905 newenv = os.environ.copy()
1908 os.execve(args[0], args, newenv)
1914 os.execve('', ['arg'], {})
1925 os.stat(support.TESTFN)
1930 self.fail("file %s must not exist; os.stat failed with %s"
1936 self.assertRaises(OSError, os.rename, support.TESTFN, support.TESTFN+".bak")
1939 self.assertRaises(OSError, os.remove, support.TESTFN)
1942 self.assertRaises(OSError, os.chdir, support.TESTFN)
1948 self.assertRaises(OSError, os.mkdir, support.TESTFN)
1951 self.assertRaises(OSError, os.utime, support.TESTFN, None)
1954 self.assertRaises(OSError, os.chmod, support.TESTFN, 0)
1964 if hasattr(os, f):
1965 self.check(getattr(os, f))
1979 @unittest.skipUnless(hasattr(os, 'isatty'), 'test needs os.isatty()')
1981 self.assertEqual(os.isatty(support.make_bad_fd()), False)
1983 @unittest.skipUnless(hasattr(os, 'closerange'), 'test needs os.closerange()')
1989 try: os.fstat(fd+i)
1997 self.assertEqual(os.closerange(fd, fd + i-1), None)
1999 @unittest.skipUnless(hasattr(os, 'dup2'), 'test needs os.dup2()')
2001 self.check(os.dup2, 20)
2003 @unittest.skipUnless(hasattr(os, 'fchmod'), 'test needs os.fchmod()')
2005 self.check(os.fchmod, 0)
2007 @unittest.skipUnless(hasattr(os, 'fchown'), 'test needs os.fchown()')
2009 self.check(os.fchown, -1, -1)
2011 @unittest.skipUnless(hasattr(os, 'fpathconf'), 'test needs os.fpathconf()')
2013 self.check(os.pathconf, "PC_NAME_MAX")
2014 self.check(os.fpathconf, "PC_NAME_MAX")
2016 @unittest.skipUnless(hasattr(os, 'ftruncate'), 'test needs os.ftruncate()')
2018 self.check(os.truncate, 0)
2019 self.check(os.ftruncate, 0)
2021 @unittest.skipUnless(hasattr(os, 'lseek'), 'test needs os.lseek()')
2023 self.check(os.lseek, 0, 0)
2025 @unittest.skipUnless(hasattr(os, 'read'), 'test needs os.read()')
2027 self.check(os.read, 1)
2029 @unittest.skipUnless(hasattr(os, 'readv'), 'test needs os.readv()')
2032 self.check(os.readv, [buf])
2034 @unittest.skipUnless(hasattr(os, 'tcsetpgrp'), 'test needs os.tcsetpgrp()')
2036 self.check(os.tcsetpgrp, 0)
2038 @unittest.skipUnless(hasattr(os, 'write'), 'test needs os.write()')
2040 self.check(os.write, b" ")
2042 @unittest.skipUnless(hasattr(os, 'writev'), 'test needs os.writev()')
2044 self.check(os.writev, [b'abc'])
2047 self.check(os.get_inheritable)
2048 self.check(os.set_inheritable, True)
2050 @unittest.skipUnless(hasattr(os, 'get_blocking'),
2051 'needs os.get_blocking() and os.set_blocking()')
2053 self.check(os.get_blocking)
2054 self.check(os.set_blocking, True)
2060 self.file2 = os.path.join(support.TESTFN + "2")
2064 if os.path.exists(file):
2065 os.unlink(file)
2071 os.link(file1, file2)
2073 self.skipTest('os.link(): %s' % e)
2075 self.assertTrue(os.path.sameopenfile(f1.fileno(), f2.fileno()))
2086 os.fsencode("\xf1")
2100 @unittest.skipUnless(hasattr(os, 'setuid'), 'test needs os.setuid()')
2102 if os.getuid() != 0:
2103 self.assertRaises(OSError, os.setuid, 0)
2104 self.assertRaises(TypeError, os.setuid, 'not an int')
2105 self.assertRaises(OverflowError, os.setuid, self.UID_OVERFLOW)
2107 @unittest.skipUnless(hasattr(os, 'setgid'), 'test needs os.setgid()')
2109 if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
2110 self.assertRaises(OSError, os.setgid, 0)
2111 self.assertRaises(TypeError, os.setgid, 'not an int')
2112 self.assertRaises(OverflowError, os.setgid, self.GID_OVERFLOW)
2114 @unittest.skipUnless(hasattr(os, 'seteuid'), 'test needs os.seteuid()')
2116 if os.getuid() != 0:
2117 self.assertRaises(OSError, os.seteuid, 0)
2118 self.assertRaises(TypeError, os.setegid, 'not an int')
2119 self.assertRaises(OverflowError, os.seteuid, self.UID_OVERFLOW)
2121 @unittest.skipUnless(hasattr(os, 'setegid'), 'test needs os.setegid()')
2123 if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
2124 self.assertRaises(OSError, os.setegid, 0)
2125 self.assertRaises(TypeError, os.setegid, 'not an int')
2126 self.assertRaises(OverflowError, os.setegid, self.GID_OVERFLOW)
2128 @unittest.skipUnless(hasattr(os, 'setreuid'), 'test needs os.setreuid()')
2130 if os.getuid() != 0:
2131 self.assertRaises(OSError, os.setreuid, 0, 0)
2132 self.assertRaises(TypeError, os.setreuid, 'not an int', 0)
2133 self.assertRaises(TypeError, os.setreuid, 0, 'not an int')
2134 self.assertRaises(OverflowError, os.setreuid, self.UID_OVERFLOW, 0)
2135 self.assertRaises(OverflowError, os.setreuid, 0, self.UID_OVERFLOW)
2137 @unittest.skipUnless(hasattr(os, 'setreuid'), 'test needs os.setreuid()')
2143 'import os,sys;os.setreuid(-1,-1);sys.exit(0)'])
2145 @unittest.skipUnless(hasattr(os, 'setregid'), 'test needs os.setregid()')
2147 if os.getuid() != 0 and not HAVE_WHEEL_GROUP:
2148 self.assertRaises(OSError, os.setregid, 0, 0)
2149 self.assertRaises(TypeError, os.setregid, 'not an int', 0)
2150 self.assertRaises(TypeError, os.setregid, 0, 'not an int')
2151 self.assertRaises(OverflowError, os.setregid, self.GID_OVERFLOW, 0)
2152 self.assertRaises(OverflowError, os.setregid, 0, self.GID_OVERFLOW)
2154 @unittest.skipUnless(hasattr(os, 'setregid'), 'test needs os.setregid()')
2160 'import os,sys;os.setregid(-1,-1);sys.exit(0)'])
2171 self.bdir = os.fsencode(self.dir)
2176 fn = os.fsencode(fn)
2189 os.mkdir(self.dir)
2192 support.create_empty_file(os.path.join(self.bdir, fn))
2193 fn = os.fsdecode(fn)
2206 found = set(os.listdir(self.dir))
2209 current_directory = os.getcwd()
2211 os.chdir(os.sep)
2212 self.assertEqual(set(os.listdir()), set(os.listdir(os.sep)))
2214 os.chdir(current_directory)
2218 f = open(os.path.join(self.dir, fn), 'rb')
2221 @unittest.skipUnless(hasattr(os, 'statvfs'),
2222 "need os.statvfs()")
2227 fullname = os.path.join(self.dir, fn)
2228 os.statvfs(fullname)
2232 os.stat(os.path.join(self.dir, fn))
2239 # becomes ready, send *sig* via os.kill to the subprocess and check
2287 os.kill(proc.pid, sig)
2295 # os.kill on Windows can take an int which gets set as the exit code
2304 os.path.join(os.path.dirname(__file__),
2316 os.kill(proc.pid, signal.SIGINT)
2318 os.kill(proc.pid, event)
2324 os.kill(proc.pid, signal.SIGINT)
2358 dir_path = os.path.join(support.TESTFN, dir_name)
2360 file_path = os.path.join(support.TESTFN, file_name)
2361 os.makedirs(dir_path)
2374 sorted(os.listdir(support.TESTFN)),
2379 sorted(os.listdir(os.fsencode(support.TESTFN))),
2380 [os.fsencode(path) for path in self.created_paths])
2386 path = '\\\\?\\' + os.path.abspath(support.TESTFN)
2388 sorted(os.listdir(path)),
2392 path = b'\\\\?\\' + os.fsencode(os.path.abspath(support.TESTFN))
2394 sorted(os.listdir(path)),
2395 [os.fsencode(path) for path in self.created_paths])
2398 @unittest.skipUnless(hasattr(os, 'readlink'), 'needs os.readlink()')
2401 filelink_target = os.path.abspath(__file__)
2402 filelinkb = os.fsencode(filelink)
2403 filelinkb_target = os.fsencode(filelink_target)
2406 left = os.path.normcase(left)
2407 right = os.path.normcase(right)
2420 self.assertTrue(os.path.exists(self.filelink_target))
2421 self.assertTrue(os.path.exists(self.filelinkb_target))
2422 self.assertFalse(os.path.exists(self.filelink))
2423 self.assertFalse(os.path.exists(self.filelinkb))
2427 self.assertRaises(OSError, os.readlink, self.filelink_target)
2428 self.assertRaises(OSError, os.readlink, filelink_target)
2431 self.assertRaises(FileNotFoundError, os.readlink, 'missing-link')
2432 self.assertRaises(FileNotFoundError, os.readlink,
2437 os.symlink(self.filelink_target, self.filelink)
2440 self.assertPathEqual(os.readlink(filelink), self.filelink_target)
2444 os.symlink(self.filelinkb_target, self.filelinkb)
2446 path = os.readlink(FakePath(self.filelinkb))
2452 os.symlink(self.filelinkb_target, self.filelinkb)
2454 path = os.readlink(self.filelinkb)
2463 filelink_target = os.path.abspath(__file__)
2465 dirlink_target = os.path.dirname(filelink_target)
2469 assert os.path.exists(self.dirlink_target)
2470 assert os.path.exists(self.filelink_target)
2471 assert not os.path.exists(self.dirlink)
2472 assert not os.path.exists(self.filelink)
2473 assert not os.path.exists(self.missing_link)
2476 if os.path.exists(self.filelink):
2477 os.remove(self.filelink)
2478 if os.path.exists(self.dirlink):
2479 os.rmdir(self.dirlink)
2480 if os.path.lexists(self.missing_link):
2481 os.remove(self.missing_link)
2484 os.symlink(self.dirlink_target, self.dirlink)
2485 self.assertTrue(os.path.exists(self.dirlink))
2486 self.assertTrue(os.path.isdir(self.dirlink))
2487 self.assertTrue(os.path.islink(self.dirlink))
2491 os.symlink(self.filelink_target, self.filelink)
2492 self.assertTrue(os.path.exists(self.filelink))
2493 self.assertTrue(os.path.isfile(self.filelink))
2494 self.assertTrue(os.path.islink(self.filelink))
2500 if os.path.lexists(linkname):
2501 os.remove(linkname)
2503 assert not os.path.exists(target)
2505 os.symlink(target, linkname, target_is_dir)
2509 # For compatibility with Unix, os.remove will check the
2512 os.remove(self.missing_link)
2516 self.assertFalse(os.path.isdir(self.missing_link))
2520 os.rmdir(self.missing_link)
2523 self.assertEqual(os.stat(link), os.stat(target))
2524 self.assertNotEqual(os.lstat(link), os.stat(link))
2526 bytes_link = os.fsencode(link)
2527 self.assertEqual(os.stat(bytes_link), os.stat(target))
2528 self.assertNotEqual(os.lstat(bytes_link), os.stat(bytes_link))
2531 level1 = os.path.abspath(support.TESTFN)
2532 level2 = os.path.join(level1, "level2")
2533 level3 = os.path.join(level2, "level3")
2536 os.mkdir(level1)
2537 os.mkdir(level2)
2538 os.mkdir(level3)
2540 file1 = os.path.abspath(os.path.join(level1, "file1"))
2543 orig_dir = os.getcwd()
2545 os.chdir(level2)
2546 link = os.path.join(level2, "link")
2547 os.symlink(os.path.relpath(file1), "link")
2548 self.assertIn("link", os.listdir(os.getcwd()))
2550 # Check os.stat calls from the same dir as the link
2551 self.assertEqual(os.stat(file1), os.stat("link"))
2553 # Check os.stat calls from a dir below the link
2554 os.chdir(level1)
2555 self.assertEqual(os.stat(file1),
2556 os.stat(os.path.relpath(link)))
2558 # Check os.stat calls from a dir above the link
2559 os.chdir(level3)
2560 self.assertEqual(os.stat(file1),
2561 os.stat(os.path.relpath(link)))
2563 os.chdir(orig_dir)
2565 @unittest.skipUnless(os.path.lexists(r'C:\Users\All Users')
2566 and os.path.exists(r'C:\ProgramData'),
2569 # os.symlink() calls CreateSymbolicLink, which creates
2577 target = os.readlink(r'C:\Users\All Users')
2578 self.assertTrue(os.path.samefile(target, r'C:\ProgramData'))
2585 path = os.path.join(*[segment] * 10)
2596 os.symlink(src, dest)
2601 os.remove(dest)
2606 os.symlink(os.fsencode(src), os.fsencode(dest))
2611 os.remove(dest)
2616 root = os.path.expandvars(r'%LOCALAPPDATA%\Microsoft\WindowsApps')
2617 if not os.path.isdir(root):
2620 aliases = [os.path.join(root, a)
2621 for a in fnmatch.filter(os.listdir(root), '*.exe')]
2627 st = os.lstat(alias)
2628 self.assertEqual(st, os.stat(alias))
2639 junction_target = os.path.dirname(os.path.abspath(__file__))
2642 assert os.path.exists(self.junction_target)
2643 assert not os.path.lexists(self.junction)
2646 if os.path.lexists(self.junction):
2647 os.unlink(self.junction)
2651 self.assertTrue(os.path.lexists(self.junction))
2652 self.assertTrue(os.path.exists(self.junction))
2653 self.assertTrue(os.path.isdir(self.junction))
2654 self.assertNotEqual(os.stat(self.junction), os.lstat(self.junction))
2655 self.assertEqual(os.stat(self.junction), os.stat(self.junction_target))
2658 self.assertFalse(os.path.islink(self.junction))
2659 self.assertEqual(os.path.normcase("\\\\?\\" + self.junction_target),
2660 os.path.normcase(os.readlink(self.junction)))
2664 self.assertTrue(os.path.exists(self.junction))
2665 self.assertTrue(os.path.lexists(self.junction))
2667 os.unlink(self.junction)
2668 self.assertFalse(os.path.exists(self.junction))
2709 os.stat(name)
2730 os.makedirs('base/some_dir')
2747 src = os.path.join('base', 'some_link')
2748 os.symlink('some_dir', src)
2749 assert os.path.isdir(src)
2754 self.assertEqual(os.fsencode(b'abc\xff'), b'abc\xff')
2755 self.assertEqual(os.fsdecode('abc\u0141'), 'abc\u0141')
2761 bytesfn = os.fsencode(fn)
2764 self.assertEqual(os.fsdecode(bytesfn), fn)
2772 self.assertIsNone(os.device_encoding(123456))
2774 @unittest.skipUnless(os.isatty(0) and not win32_is_iot() and (sys.platform.startswith('win') or
2778 encoding = os.device_encoding(0)
2784 @unittest.skipUnless(hasattr(os, 'getppid'), "test needs os.getppid")
2787 'import os; print(os.getppid())'],
2791 self.assertEqual(int(stdout), os.getpid())
2795 # On Windows, os.spawnv() simply joins arguments with spaces:
2800 pid = os.spawnv(os.P_NOWAIT, sys.executable, args)
2805 # don't use support.wait_process() to test directly os.waitpid()
2806 # and os.waitstatus_to_exitcode()
2807 pid2, status = os.waitpid(pid, 0)
2808 self.assertEqual(os.waitstatus_to_exitcode(status), exitcode)
2820 os.waitstatus_to_exitcode(0.0)
2824 # bpo-40138: test os.waitpid() and os.waitstatus_to_exitcode()
2834 self.assertEqual(os.waitstatus_to_exitcode(exitcode << 8),
2839 os.waitstatus_to_exitcode((max_exitcode + 1) << 8)
2841 os.waitstatus_to_exitcode(-1)
2850 os.kill(pid, signum)
2865 self.env = dict(os.environ)
2869 # read the variable from os.environ to check that it exists
2870 code = ('import sys, os; magic = os.environ[%r]; sys.exit(%s)'
2878 args = [os.fsencode(a) for a in args]
2879 self.env = {os.fsencode(k): os.fsencode(v)
2887 exitcode = os.spawnl(os.P_WAIT, args[0], *args)
2893 exitcode = os.spawnle(os.P_WAIT, args[0], *args, self.env)
2899 exitcode = os.spawnlp(os.P_WAIT, args[0], *args)
2905 exitcode = os.spawnlpe(os.P_WAIT, args[0], *args, self.env)
2911 exitcode = os.spawnv(os.P_WAIT, args[0], args)
2915 exitcode = os.spawnv(os.P_WAIT, FakePath(args[0]), args)
2921 exitcode = os.spawnve(os.P_WAIT, args[0], args, self.env)
2927 exitcode = os.spawnvp(os.P_WAIT, args[0], args)
2933 exitcode = os.spawnvpe(os.P_WAIT, args[0], args, self.env)
2939 pid = os.spawnv(os.P_NOWAIT, args[0], args)
2946 exitcode = os.spawnve(os.P_WAIT, args[0], args, self.env)
2952 self.assertRaises(ValueError, os.spawnl, os.P_NOWAIT, args[0])
2953 self.assertRaises(ValueError, os.spawnl, os.P_NOWAIT, args[0], '')
2958 self.assertRaises(ValueError, os.spawnle, os.P_NOWAIT, args[0], {})
2959 self.assertRaises(ValueError, os.spawnle, os.P_NOWAIT, args[0], '', {})
2964 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, args[0], ())
2965 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, args[0], [])
2966 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, args[0], ('',))
2967 self.assertRaises(ValueError, os.spawnv, os.P_NOWAIT, args[0], [''])
2972 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, args[0], (), {})
2973 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, args[0], [], {})
2974 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, args[0], ('',), {})
2975 self.assertRaises(ValueError, os.spawnve, os.P_NOWAIT, args[0], [''], {})
2981 newenv = os.environ.copy()
2984 exitcode = spawn(os.P_WAIT, args[0], args, newenv)
2991 newenv = os.environ.copy()
2994 exitcode = spawn(os.P_WAIT, args[0], args, newenv)
3001 newenv = os.environ.copy()
3004 exitcode = spawn(os.P_WAIT, args[0], args, newenv)
3014 fp.write('import sys, os\n'
3015 'if os.getenv("FRUIT") != "orange=lemon":\n'
3018 newenv = os.environ.copy()
3020 exitcode = spawn(os.P_WAIT, args[0], args, newenv)
3025 self._test_invalid_env(os.spawnve)
3029 self._test_invalid_env(os.spawnvpe)
3035 @unittest.skipUnless(hasattr(os, 'getlogin'), "test needs os.getlogin")
3038 user_name = os.getlogin()
3042 @unittest.skipUnless(hasattr(os, 'getpriority') and hasattr(os, 'setpriority'),
3043 "needs os.getpriority and os.setpriority")
3045 """Tests for os.getpriority() and os.setpriority()."""
3049 base = os.getpriority(os.PRIO_PROCESS, os.getpid())
3050 os.setpriority(os.PRIO_PROCESS, os.getpid(), base + 1)
3052 new_prio = os.getpriority(os.PRIO_PROCESS, os.getpid())
3060 os.setpriority(os.PRIO_PROCESS, os.getpid(), base)
3152 @unittest.skipUnless(hasattr(os, 'sendfile'), "test needs os.sendfile()")
3199 return os.sendfile(*args, **kwargs)
3259 sent = os.sendfile(self.sockno, self.fileno, offset, 4096)
3274 os.sendfile(self.sockno, self.fileno, -1, 4096)
3279 os.sendfile(out_fd=self.sockno, in_fd=self.fileno,
3282 os.sendfile(out_fd=self.sockno, in_fd=self.fileno,
3292 sent = os.sendfile(self.sockno, self.fileno, 0, 4096,
3322 os.sendfile(self.sockno, f.fileno(), 0, 5,
3334 os.sendfile(self.sockno, self.fileno, 0, 0,
3343 os.sendfile(self.sockno, self.fileno, 0, 0,
3348 @unittest.skipUnless(hasattr(os, 'SF_NODISKIO'),
3349 'test needs os.SF_NODISKIO')
3352 os.sendfile(self.sockno, self.fileno, 0, 4096,
3353 flags=os.SF_NODISKIO)
3360 if not hasattr(os, "setxattr"):
3366 os.setxattr(fp.fileno(), b"user.test", b"")
3398 setxattr(fn, s("user.test"), b"hello", os.XATTR_REPLACE, **kwargs)
3402 setxattr(fn, s("user.test"), b"bye", os.XATTR_CREATE, **kwargs)
3406 setxattr(fn, s("user.test2"), b"bye", os.XATTR_REPLACE, **kwargs)
3409 setxattr(fn, s("user.test2"), b"foo", os.XATTR_CREATE, **kwargs)
3433 self._check_xattrs_str(os.fsencode, *args, **kwargs)
3437 self._check_xattrs(os.getxattr, os.setxattr, os.removexattr,
3438 os.listxattr)
3441 self._check_xattrs(os.getxattr, os.setxattr, os.removexattr,
3442 os.listxattr, follow_symlinks=False)
3447 return os.getxattr(fp.fileno(), *args)
3450 os.setxattr(fp.fileno(), *args)
3453 os.removexattr(fp.fileno(), *args)
3456 return os.listxattr(fp.fileno(), *args)
3460 @unittest.skipUnless(hasattr(os, 'get_terminal_size'), "requires os.get_terminal_size")
3469 size = os.get_terminal_size()
3499 actual = os.get_terminal_size(sys.__stdin__.fileno())
3509 @unittest.skipUnless(hasattr(os, 'memfd_create'), 'requires os.memfd_create')
3513 fd = os.memfd_create("Hi", os.MFD_CLOEXEC)
3515 self.addCleanup(os.close, fd)
3516 self.assertFalse(os.get_inheritable(fd))
3521 fd2 = os.memfd_create("Hi")
3522 self.addCleanup(os.close, fd2)
3523 self.assertFalse(os.get_inheritable(fd2))
3542 encoded = os.fsencode(support.TESTFN)
3551 (self.filenames, os.chdir,),
3552 (self.filenames, os.chmod, 0o777),
3553 (self.filenames, os.lstat,),
3554 (self.filenames, os.open, os.O_RDONLY),
3555 (self.filenames, os.rmdir,),
3556 (self.filenames, os.stat,),
3557 (self.filenames, os.unlink,),
3561 (self.bytes_filenames, os.rename, b"dst"),
3562 (self.bytes_filenames, os.replace, b"dst"),
3563 (self.unicode_filenames, os.rename, "dst"),
3564 (self.unicode_filenames, os.replace, "dst"),
3565 (self.unicode_filenames, os.listdir, ),
3569 (self.filenames, os.listdir,),
3570 (self.filenames, os.rename, "dst"),
3571 (self.filenames, os.replace, "dst"),
3573 if hasattr(os, "chown"):
3574 funcs.append((self.filenames, os.chown, 0, 0))
3575 if hasattr(os, "lchown"):
3576 funcs.append((self.filenames, os.lchown, 0, 0))
3577 if hasattr(os, "truncate"):
3578 funcs.append((self.filenames, os.truncate, 0))
3579 if hasattr(os, "chflags"):
3580 funcs.append((self.filenames, os.chflags, 0))
3581 if hasattr(os, "lchflags"):
3582 funcs.append((self.filenames, os.lchflags, 0))
3583 if hasattr(os, "chroot"):
3584 funcs.append((self.filenames, os.chroot,))
3585 if hasattr(os, "link"):
3587 funcs.append((self.bytes_filenames, os.link, b"dst"))
3588 funcs.append((self.unicode_filenames, os.link, "dst"))
3590 funcs.append((self.filenames, os.link, "dst"))
3591 if hasattr(os, "listxattr"):
3593 (self.filenames, os.listxattr,),
3594 (self.filenames, os.getxattr, "user.test"),
3595 (self.filenames, os.setxattr, "user.test", b'user'),
3596 (self.filenames, os.removexattr, "user.test"),
3598 if hasattr(os, "lchmod"):
3599 funcs.append((self.filenames, os.lchmod, 0o777))
3600 if hasattr(os, "readlink"):
3601 funcs.append((self.filenames, os.readlink,))
3621 cpus = os.cpu_count()
3631 fd = os.open(__file__, os.O_RDONLY)
3632 self.addCleanup(os.close, fd)
3633 self.assertEqual(os.get_inheritable(fd), False)
3635 os.set_inheritable(fd, True)
3636 self.assertEqual(os.get_inheritable(fd), True)
3640 fd = os.open(__file__, os.O_RDONLY)
3641 self.addCleanup(os.close, fd)
3642 self.assertEqual(os.get_inheritable(fd), False)
3649 self.assertEqual(os.get_inheritable(fd), True)
3653 fd = os.open(__file__, os.O_RDONLY)
3654 self.addCleanup(os.close, fd)
3658 os.set_inheritable(fd, True)
3663 fd = os.open(__file__, os.O_RDONLY)
3664 self.addCleanup(os.close, fd)
3665 self.assertEqual(os.get_inheritable(fd), False)
3667 @unittest.skipUnless(hasattr(os, 'pipe'), "need os.pipe()")
3669 rfd, wfd = os.pipe()
3670 self.addCleanup(os.close, rfd)
3671 self.addCleanup(os.close, wfd)
3672 self.assertEqual(os.get_inheritable(rfd), False)
3673 self.assertEqual(os.get_inheritable(wfd), False)
3676 fd1 = os.open(__file__, os.O_RDONLY)
3677 self.addCleanup(os.close, fd1)
3679 fd2 = os.dup(fd1)
3680 self.addCleanup(os.close, fd2)
3681 self.assertEqual(os.get_inheritable(fd2), False)
3684 fd = os.dup(1)
3685 self.addCleanup(os.close, fd)
3690 # os.dup() was creating inheritable fds for character files.
3691 fd1 = os.open('NUL', os.O_RDONLY)
3692 self.addCleanup(os.close, fd1)
3693 fd2 = os.dup(fd1)
3694 self.addCleanup(os.close, fd2)
3695 self.assertFalse(os.get_inheritable(fd2))
3697 @unittest.skipUnless(hasattr(os, 'dup2'), "need os.dup2()")
3699 fd = os.open(__file__, os.O_RDONLY)
3700 self.addCleanup(os.close, fd)
3703 fd2 = os.open(__file__, os.O_RDONLY)
3704 self.addCleanup(os.close, fd2)
3705 self.assertEqual(os.dup2(fd, fd2), fd2)
3706 self.assertTrue(os.get_inheritable(fd2))
3709 fd3 = os.open(__file__, os.O_RDONLY)
3710 self.addCleanup(os.close, fd3)
3711 self.assertEqual(os.dup2(fd, fd3, inheritable=False), fd3)
3712 self.assertFalse(os.get_inheritable(fd3))
3714 @unittest.skipUnless(hasattr(os, 'openpty'), "need os.openpty()")
3716 master_fd, slave_fd = os.openpty()
3717 self.addCleanup(os.close, master_fd)
3718 self.addCleanup(os.close, slave_fd)
3719 self.assertEqual(os.get_inheritable(master_fd), False)
3720 self.assertEqual(os.get_inheritable(slave_fd), False)
3729 ('access', False, (os.F_OK,), None),
3732 ('open', False, (0,), getattr(os, 'close', None)),
3737 if os.name == 'nt':
3740 bytes_filename = os.fsencode(support.TESTFN)
3742 fd = os.open(FakePath(str_filename), os.O_WRONLY|os.O_CREAT)
3744 self.addCleanup(os.close, fd)
3752 fn = getattr(os, name)
3776 'os.PathLike'):
3782 os.stat(FakePath(2))
3784 os.stat(FakePath(2.34))
3786 os.stat(FakePath(object()))
3789 @unittest.skipUnless(hasattr(os, 'get_blocking'),
3790 'needs os.get_blocking() and os.set_blocking()')
3793 fd = os.open(__file__, os.O_RDONLY)
3794 self.addCleanup(os.close, fd)
3795 self.assertEqual(os.get_blocking(fd), True)
3797 os.set_blocking(fd, False)
3798 self.assertEqual(os.get_blocking(fd), False)
3800 os.set_blocking(fd, True)
3801 self.assertEqual(os.get_blocking(fd), True)
3807 self.assertIn('open', os.__all__)
3808 self.assertIn('walk', os.__all__)
3813 self.path = os.path.realpath(support.TESTFN)
3815 os.mkdir(self.path)
3818 self.assertRaises(TypeError, os.DirEntry)
3821 filename = create_file(os.path.join(self.path, "file.txt"), b'python')
3822 entry = [entry for entry in os.scandir(self.path)].pop()
3823 self.assertIsInstance(entry, os.DirEntry)
3833 self.path = os.path.realpath(support.TESTFN)
3834 self.bytes_path = os.fsencode(self.path)
3836 os.mkdir(self.path)
3840 filename = os.path.join(path, name)
3846 for entry in os.scandir(self.path))
3864 scandir_iter = os.scandir(self.path)
3870 scandir_iter = os.scandir(self.path)
3876 self.assertIsInstance(entry, os.DirEntry)
3878 self.assertEqual(entry.path, os.path.join(self.path, name))
3880 os.stat(entry.path, follow_symlinks=False).st_ino)
3882 entry_stat = os.stat(entry.path)
3888 os.path.islink(entry.path))
3890 entry_lstat = os.stat(entry.path, follow_symlinks=False)
3898 os.name == 'nt' and not is_symlink)
3901 os.name == 'nt')
3904 link = hasattr(os, 'link')
3907 dirname = os.path.join(self.path, "dir")
3908 os.mkdir(dirname)
3912 os.link(filename, os.path.join(self.path, "link_file.txt"))
3914 self.skipTest('os.link(): %s' % e)
3916 os.symlink(dirname, os.path.join(self.path, "symlink_dir"),
3918 os.symlink(filename, os.path.join(self.path, "symlink_file.txt"))
3946 entries = list(os.scandir(path))
3955 return self.get_entry(os.path.basename(filename))
3959 old_dir = os.getcwd()
3961 os.chdir(self.path)
3965 entries = dict((entry.name, entry) for entry in os.scandir())
3967 [os.path.basename(filename)])
3969 os.chdir(old_dir)
3977 self.assertEqual(os.fspath(entry), os.path.join(self.path, 'file.txt'))
3980 bytes_filename = os.fsencode('bytesfile.txt')
3982 fspath = os.fspath(bytes_entry)
3985 os.path.join(os.fsencode(self.path),bytes_filename))
3988 path = os.path.join(self.path, 'dir')
3990 os.mkdir(path)
3992 os.rmdir(path)
3995 if os.name == 'nt':
3999 if os.name == 'nt':
4011 os.unlink(entry.path)
4015 if os.name == 'nt':
4018 if os.name == 'nt':
4033 os.symlink(filename,
4034 os.path.join(self.path, "symlink.txt"))
4037 os.unlink(filename)
4052 path_bytes = os.fsencode(self.path)
4053 entries = list(os.scandir(path_bytes))
4059 os.fsencode(os.path.join(self.path, 'file.txt')))
4065 path_bytes = cls(os.fsencode(self.path))
4067 entries = list(os.scandir(path_bytes))
4073 os.fsencode(os.path.join(self.path, 'file.txt')))
4077 @unittest.skipUnless(os.listdir in os.supports_fd,
4080 self.assertIn(os.scandir, os.supports_fd)
4084 os.symlink('file.txt', os.path.join(self.path, 'link'))
4087 fd = os.open(self.path, os.O_RDONLY)
4089 with os.scandir(fd) as it:
4093 self.assertEqual(names, os.listdir(fd))
4096 self.assertEqual(os.fspath(entry), entry.name)
4098 if os.stat in os.supports_dir_fd:
4099 st = os.stat(entry.name, dir_fd=fd)
4101 st = os.stat(entry.name, dir_fd=fd, follow_symlinks=False)
4104 os.close(fd)
4107 self.assertRaises(FileNotFoundError, os.scandir, '')
4111 iterator = os.scandir(self.path)
4122 self.assertRaises(TypeError, os.scandir, obj)
4127 iterator = os.scandir(self.path)
4138 with os.scandir(self.path) as iterator:
4146 with os.scandir(self.path) as iterator:
4154 with os.scandir(self.path) as iterator:
4163 iterator = os.scandir(self.path)
4169 iterator = os.scandir(self.path)
4179 fspath = staticmethod(os.fspath)
4194 self.assertEqual(b"path/like/object", os.fsencode(pathlike))
4195 self.assertEqual("path/like/object", os.fsdecode(pathlike))
4199 self.assertTrue(issubclass(FakePath, os.PathLike))
4200 self.assertTrue(isinstance(FakePath('x'), os.PathLike))
4204 for o in int, type, os, vapor():
4224 class A(os.PathLike):
4227 self.assertTrue(issubclass(FakePath, os.PathLike))
4230 self.assertIsInstance(os.PathLike[bytes], types.GenericAlias)
4235 times = os.times()
4236 self.assertIsInstance(times, os.times_result)
4243 if os.name == 'nt':
4251 if hasattr(os, "_fspath"):
4254 """Explicitly test the pure Python implementation of os.fspath()."""
4256 fspath = staticmethod(os._fspath)