Lines Matching refs:self
107 def test_getcwd(self):
109 self.assertIsInstance(cwd, str)
111 def test_getcwd_long_path(self):
138 self.assertEqual(cwd, expected)
168 def test_getcwdb(self):
170 self.assertIsInstance(cwd, bytes)
171 self.assertEqual(os.fsdecode(cwd), os.getcwd())
176 def setUp(self):
181 def test_access(self):
184 self.assertTrue(os.access(os_helper.TESTFN, os.W_OK))
192 def test_closerange(self):
205 self.skipTest("couldn't allocate two consecutive fds")
211 self.assertRaises(OSError, os.write, first, b"a")
214 def test_rename(self):
217 self.assertRaises(TypeError, os.rename, path, 0)
219 self.assertEqual(old, new)
221 def test_read(self):
228 self.assertEqual(type(s), bytes)
229 self.assertEqual(s, b"spam")
237 def test_large_read(self, size):
238 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
248 self.assertEqual(data, b'test')
250 def test_write(self):
253 self.assertRaises(TypeError, os.write, fd, "beans")
259 self.assertEqual(fobj.read().splitlines(),
262 def write_windows_console(self, *args):
268 self.assertEqual(retcode, 0)
272 def test_write_windows_console(self):
278 self.write_windows_console(sys.executable, "-c", code)
279 self.write_windows_console(sys.executable, "-u", "-c", code)
281 def fdopen_helper(self, *args):
286 def test_fdopen(self):
290 self.fdopen_helper()
291 self.fdopen_helper('r')
292 self.fdopen_helper('r', 100)
294 def test_replace(self):
296 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
297 self.addCleanup(os_helper.unlink, TESTFN2)
303 self.assertRaises(FileNotFoundError, os.stat, os_helper.TESTFN)
305 self.assertEqual(f.read(), "1")
307 def test_open_keywords(self):
312 def test_symlink_keywords(self):
321 def test_copy_file_range_invalid_values(self):
322 with self.assertRaises(ValueError):
326 def test_copy_file_range(self):
331 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
334 self.addCleanup(in_file.close)
338 self.addCleanup(os_helper.unlink, TESTFN2)
339 self.addCleanup(out_file.close)
350 self.skipTest(e)
354 self.assertIn(i, range(0, 6));
357 self.assertEqual(in_file.read(), data[:i])
360 def test_copy_file_range_offset(self):
368 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
371 self.addCleanup(in_file.close)
375 self.addCleanup(os_helper.unlink, TESTFN4)
376 self.addCleanup(out_file.close)
389 self.skipTest(e)
393 self.assertIn(i, range(0, bytes_to_copy+1));
398 self.assertEqual(read[:out_seek], b'\x00'*out_seek)
401 self.assertEqual(read[out_seek:],
405 def test_splice_invalid_values(self):
406 with self.assertRaises(ValueError):
411 def test_splice(self):
416 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
419 self.addCleanup(in_file.close)
423 self.addCleanup(lambda: os.close(read_fd))
424 self.addCleanup(lambda: os.close(write_fd))
434 self.skipTest(e)
438 self.assertIn(i, range(0, 6));
440 self.assertEqual(os.read(read_fd, 100), data[:i])
444 def test_splice_offset_in(self):
451 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
454 self.addCleanup(in_file.close)
458 self.addCleanup(lambda: os.close(read_fd))
459 self.addCleanup(lambda: os.close(write_fd))
469 self.skipTest(e)
473 self.assertIn(i, range(0, bytes_to_copy+1));
478 self.assertEqual(read, data[in_skip:in_skip+i])
482 def test_splice_offset_out(self):
489 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
492 self.addCleanup(lambda: os.close(read_fd))
493 self.addCleanup(lambda: os.close(write_fd))
497 self.addCleanup(os_helper.unlink, TESTFN4)
498 self.addCleanup(out_file.close)
509 self.skipTest(e)
513 self.assertIn(i, range(0, bytes_to_copy+1));
518 self.assertEqual(read[:out_seek], b'\x00'*out_seek)
521 self.assertEqual(read[out_seek:], data[:i])
526 def setUp(self):
527 self.fname = os_helper.TESTFN
528 self.addCleanup(os_helper.unlink, self.fname)
529 create_file(self.fname, b"ABC")
531 def check_stat_attributes(self, fname):
535 self.assertEqual(result[stat.ST_SIZE], 3)
536 self.assertEqual(result.st_size, 3)
547 self.assertEqual(trunc(getattr(result, attr)),
549 self.assertIn(attr, members)
556 self.assertAlmostEqual(floaty, nanosecondy, delta=2)
560 self.fail("No exception raised")
567 self.fail("No exception raised")
573 self.fail("No exception raised")
579 self.fail("No exception raised")
586 self.fail("No exception raised")
596 def test_stat_attributes(self):
597 self.check_stat_attributes(self.fname)
599 def test_stat_attributes_bytes(self):
601 fname = self.fname.encode(sys.getfilesystemencoding())
603 self.skipTest("cannot encode %a for the filesystem" % self.fname)
604 self.check_stat_attributes(fname)
606 def test_stat_result_pickle(self):
607 result = os.stat(self.fname)
610 self.assertIn(b'stat_result', p)
612 self.assertIn(b'cos\nstat_result\n', p)
614 self.assertEqual(result, unpickled)
617 def test_statvfs_attributes(self):
618 result = os.statvfs(self.fname)
621 self.assertEqual(result.f_bfree, result[3])
627 self.assertEqual(getattr(result, 'f_' + member), result[value])
629 self.assertTrue(isinstance(result.f_fsid, int))
632 self.assertEqual(len(result), 10)
637 self.fail("No exception raised")
643 self.fail("No exception raised")
650 self.fail("No exception raised")
662 def test_statvfs_result_pickle(self):
663 result = os.statvfs(self.fname)
667 self.assertIn(b'statvfs_result', p)
669 self.assertIn(b'cos\nstatvfs_result\n', p)
671 self.assertEqual(result, unpickled)
674 def test_1686475(self):
679 self.skipTest(r'c:\pagefile.sys does not exist')
681 self.fail("Could not stat pagefile.sys")
685 def test_15261(self):
693 with self.assertRaises(OSError) as ctx:
695 self.assertEqual(ctx.exception.errno, errno.EBADF)
697 def check_file_attributes(self, result):
698 self.assertTrue(hasattr(result, 'st_file_attributes'))
699 self.assertTrue(isinstance(result.st_file_attributes, int))
700 self.assertTrue(0 <= result.st_file_attributes <= 0xFFFFFFFF)
704 def test_file_attributes(self):
706 result = os.stat(self.fname)
707 self.check_file_attributes(result)
708 self.assertEqual(
715 self.addCleanup(os.rmdir, dirname)
718 self.check_file_attributes(result)
719 self.assertEqual(
724 def test_access_denied(self):
729 fname = os.path.join(os.environ['TEMP'], self.fname)
730 self.addCleanup(os_helper.unlink, fname)
742 self.assertNotEqual(result.st_size, 0)
745 def test_stat_block_device(self):
750 self.assertEqual(result.st_mode, stat.S_IFBLK)
754 def setUp(self):
755 self.dirname = os_helper.TESTFN
756 self.fname = os.path.join(self.dirname, "f1")
758 self.addCleanup(os_helper.rmtree, self.dirname)
759 os.mkdir(self.dirname)
760 create_file(self.fname)
762 def support_subsecond(self, filename):
770 def _test_utime(self, set_time, filename=None):
772 filename = self.fname
774 support_subsecond = self.support_subsecond(filename)
793 self.assertAlmostEqual(st.st_atime, atime_ns * 1e-9, delta=1e-6)
794 self.assertAlmostEqual(st.st_mtime, mtime_ns * 1e-9, delta=1e-6)
796 self.assertEqual(st.st_atime, atime_ns * 1e-9)
797 self.assertEqual(st.st_mtime, mtime_ns * 1e-9)
798 self.assertEqual(st.st_atime_ns, atime_ns)
799 self.assertEqual(st.st_mtime_ns, mtime_ns)
801 def test_utime(self):
805 self._test_utime(set_time)
814 def test_utime_by_indexed(self):
818 atime = self.ns_to_sec(atime_ns)
819 mtime = self.ns_to_sec(mtime_ns)
823 self._test_utime(set_time)
825 def test_utime_by_times(self):
828 atime = self.ns_to_sec(atime_ns)
829 mtime = self.ns_to_sec(mtime_ns)
832 self._test_utime(set_time)
837 def test_utime_nofollow_symlinks(self):
842 self._test_utime(set_time)
846 def test_utime_fd(self):
852 self._test_utime(set_time)
856 def test_utime_dir_fd(self):
862 self._test_utime(set_time)
864 def test_utime_directory(self):
868 self._test_utime(set_time, filename=self.dirname)
870 def _test_utime_current(self, set_time):
875 set_time(self.fname)
877 if not self.support_subsecond(self.fname):
886 st = os.stat(self.fname)
889 self.assertAlmostEqual(st.st_mtime, current,
892 def test_utime_current(self):
895 os.utime(self.fname)
896 self._test_utime_current(set_time)
898 def test_utime_current_old(self):
901 os.utime(self.fname, None)
902 self._test_utime_current(set_time)
904 def get_file_system(self, path):
917 def test_large_time(self):
920 if self.get_file_system(self.dirname) != "NTFS":
921 self.skipTest("requires NTFS")
924 os.utime(self.fname, (large, large))
925 self.assertEqual(os.stat(self.fname).st_mtime, large)
927 def test_utime_invalid_arguments(self):
929 with self.assertRaises(ValueError):
930 os.utime(self.fname, (5, 5), ns=(5, 5))
931 with self.assertRaises(TypeError):
932 os.utime(self.fname, [5, 5])
933 with self.assertRaises(TypeError):
934 os.utime(self.fname, (5,))
935 with self.assertRaises(TypeError):
936 os.utime(self.fname, (5, 5, 5))
937 with self.assertRaises(TypeError):
938 os.utime(self.fname, ns=[5, 5])
939 with self.assertRaises(TypeError):
940 os.utime(self.fname, ns=(5,))
941 with self.assertRaises(TypeError):
942 os.utime(self.fname, ns=(5, 5, 5))
945 with self.assertRaises(NotImplementedError):
946 os.utime(self.fname, (5, 5), follow_symlinks=False)
948 with open(self.fname, 'wb', 0) as fp:
949 with self.assertRaises(TypeError):
952 with self.assertRaises(NotImplementedError):
953 os.utime(self.fname, (5, 5), dir_fd=0)
956 def test_issue31577(self):
964 with self.assertRaises(TypeError):
965 os.utime(self.fname, ns=(get_bad_int(42), 1))
966 with self.assertRaises(TypeError):
967 os.utime(self.fname, ns=(get_bad_int(()), 1))
968 with self.assertRaises(TypeError):
969 os.utime(self.fname, ns=(get_bad_int((1, 2, 3)), 1))
978 def setUp(self):
979 self.__save = dict(os.environ)
981 self.__saveb = dict(os.environb)
982 for key, value in self._reference().items():
985 def tearDown(self):
987 os.environ.update(self.__save)
990 os.environb.update(self.__saveb)
992 def _reference(self):
995 def _empty_mapping(self):
1004 def test_update2(self):
1009 self.assertEqual(value, "World")
1015 def test_os_popen_iter(self):
1019 self.assertEqual(next(it), "line1\n")
1020 self.assertEqual(next(it), "line2\n")
1021 self.assertEqual(next(it), "line3\n")
1022 self.assertRaises(StopIteration, next, it)
1026 def test_keyvalue_types(self):
1028 self.assertEqual(type(key), str)
1029 self.assertEqual(type(val), str)
1031 def test_items(self):
1032 for key, value in self._reference().items():
1033 self.assertEqual(os.environ.get(key), value)
1036 def test___repr__(self):
1043 self.assertEqual(repr(env), f"environ({{{formatted_items}}})")
1045 def test_get_exec_path(self):
1054 self.assertSequenceEqual(test_path, os.get_exec_path())
1055 self.assertSequenceEqual(test_path, os.get_exec_path(env=None))
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))
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'}),
1088 def test_environb(self):
1097 self.skipTest(msg)
1099 self.assertEqual(os.environ['unicode'], value)
1100 self.assertEqual(os.environb[b'unicode'], value_bytes)
1105 self.assertEqual(os.environb[b'bytes'], value)
1107 self.assertEqual(os.environ['bytes'], value_str)
1110 def test_putenv_unsetenv(self):
1121 self.assertEqual(proc.stdout.rstrip(), repr(value))
1126 self.assertEqual(proc.stdout.rstrip(), repr(None))
1130 def test_putenv_unsetenv_error(self):
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)
1145 def test_key_type(self):
1147 self.assertNotIn(missing, os.environ)
1149 with self.assertRaises(KeyError) as cm:
1151 self.assertIs(cm.exception.args[0], missing)
1152 self.assertTrue(cm.exception.__suppress_context__)
1154 with self.assertRaises(KeyError) as cm:
1156 self.assertIs(cm.exception.args[0], missing)
1157 self.assertTrue(cm.exception.__suppress_context__)
1159 def _test_environ_iteration(self, collection):
1170 self.assertEqual(os.environ[new_key], "test_environ_iteration")
1174 def test_iter_error_when_changing_os_environ(self):
1175 self._test_environ_iteration(os.environ)
1177 def test_iter_error_when_changing_os_environ_items(self):
1178 self._test_environ_iteration(os.environ.items())
1180 def test_iter_error_when_changing_os_environ_values(self):
1181 self._test_environ_iteration(os.environ.values())
1183 def _test_underlying_process_env(self, var, expected):
1192 self.assertEqual(expected, value)
1194 def test_or_operator(self):
1204 self.assertDictEqual(expected, actual)
1205 self.assertEqual('3', actual[overridden_key])
1208 self.assertIs(NotImplemented, os.environ.__or__(new_vars_items))
1210 self._test_underlying_process_env('_A_', '')
1211 self._test_underlying_process_env(overridden_key, original_value)
1213 def test_ior_operator(self):
1222 self.assertEqual(expected, os.environ)
1223 self.assertEqual('3', os.environ[overridden_key])
1225 self._test_underlying_process_env('_A_', '1')
1226 self._test_underlying_process_env(overridden_key, '3')
1228 def test_ior_operator_invalid_dicts(self):
1230 with self.assertRaises(TypeError):
1234 with self.assertRaises(TypeError):
1239 self.assertEqual(os_environ_copy, os.environ)
1241 def test_ior_operator_key_value_iterable(self):
1250 self.assertEqual(expected, os.environ)
1251 self.assertEqual('3', os.environ[overridden_key])
1253 self._test_underlying_process_env('_A_', '1')
1254 self._test_underlying_process_env(overridden_key, '3')
1256 def test_ror_operator(self):
1266 self.assertDictEqual(expected, actual)
1267 self.assertEqual(original_value, actual[overridden_key])
1270 self.assertIs(NotImplemented, os.environ.__ror__(new_vars_items))
1272 self._test_underlying_process_env('_A_', '')
1273 self._test_underlying_process_env(overridden_key, original_value)
1281 def walk(self, top, **kwargs):
1286 def setUp(self):
1288 self.addCleanup(os_helper.rmtree, os_helper.TESTFN)
1307 self.walk_path = join(os_helper.TESTFN, "TEST1")
1308 self.sub1_path = join(self.walk_path, "SUB1")
1309 self.sub11_path = join(self.sub1_path, "SUB11")
1310 sub2_path = join(self.walk_path, "SUB2")
1312 tmp1_path = join(self.walk_path, "tmp1")
1313 tmp2_path = join(self.sub1_path, "tmp2")
1316 self.link_path = join(sub2_path, "link")
1324 os.makedirs(self.sub11_path)
1334 os.symlink(os.path.abspath(t2_path), self.link_path)
1338 self.sub2_tree = (sub2_path, ["SUB21", "link"],
1342 self.sub2_tree = (sub2_path, ["SUB21"], ["tmp3"])
1350 self.addCleanup(os.chmod, sub21_path, stat.S_IRWXU)
1355 del self.sub2_tree[1][:1]
1357 def test_walk_topdown(self):
1359 all = list(self.walk(self.walk_path))
1361 self.assertEqual(len(all), 4)
1369 self.assertEqual(all[0], (self.walk_path, ["SUB1", "SUB2"], ["tmp1"]))
1370 self.assertEqual(all[1 + flipped], (self.sub1_path, ["SUB11"], ["tmp2"]))
1371 self.assertEqual(all[2 + flipped], (self.sub11_path, [], []))
1372 self.assertEqual(all[3 - 2 * flipped], self.sub2_tree)
1374 def test_walk_prune(self, walk_path=None):
1376 walk_path = self.walk_path
1379 for root, dirs, files in self.walk(walk_path):
1386 self.assertEqual(len(all), 2)
1387 self.assertEqual(all[0], (self.walk_path, ["SUB2"], ["tmp1"]))
1391 self.assertEqual(all[1], self.sub2_tree)
1393 def test_file_like_path(self):
1394 self.test_walk_prune(FakePath(self.walk_path))
1396 def test_walk_bottom_up(self):
1398 all = list(self.walk(self.walk_path, topdown=False))
1400 self.assertEqual(len(all), 4, all)
1408 self.assertEqual(all[3],
1409 (self.walk_path, ["SUB1", "SUB2"], ["tmp1"]))
1410 self.assertEqual(all[flipped],
1411 (self.sub11_path, [], []))
1412 self.assertEqual(all[flipped + 1],
1413 (self.sub1_path, ["SUB11"], ["tmp2"]))
1414 self.assertEqual(all[2 - 2 * flipped],
1415 self.sub2_tree)
1417 def test_walk_symlink(self):
1419 self.skipTest("need symlink support")
1422 walk_it = self.walk(self.walk_path, follow_symlinks=True)
1424 if root == self.link_path:
1425 self.assertEqual(dirs, [])
1426 self.assertEqual(files, ["tmp4"])
1429 self.fail("Didn't follow symlink with followlinks=True")
1431 def test_walk_bad_dir(self):
1434 walk_it = self.walk(self.walk_path, onerror=errors.append)
1436 self.assertEqual(errors, [])
1443 self.assertTrue(errors)
1444 self.assertNotIn(path1, roots)
1445 self.assertNotIn(path1new, roots)
1448 self.assertIn(os.path.join(root, dir2), roots)
1452 def test_walk_many_open_files(self):
1458 iters = [self.walk(base, topdown=False) for j in range(100)]
1462 self.assertEqual(next(it), expected)
1465 iters = [self.walk(base, topdown=True) for j in range(100)]
1470 self.assertEqual(next(it), expected)
1478 def walk(self, top, **kwargs):
1479 for root, dirs, files, root_fd in self.fwalk(top, **kwargs):
1482 def fwalk(self, *args, **kwargs):
1485 def _compare_to_walk(self, walk_kwargs, fwalk_kwargs):
1499 for root, dirs, files, rootfd in self.fwalk(**fwalk_kwargs):
1500 self.assertIn(root, expected)
1501 self.assertEqual(expected[root], (set(dirs), set(files)))
1503 def test_compare_to_walk(self):
1505 self._compare_to_walk(kwargs, kwargs)
1507 def test_dir_fd(self):
1513 self._compare_to_walk(walk_kwargs, fwalk_kwargs)
1517 def test_yields_correct_dir_fd(self):
1521 for root, dirs, files, rootfd in self.fwalk(*args, follow_symlinks=follow_symlinks):
1527 self.assertEqual(set(os.listdir(rootfd)), set(dirs) | set(files))
1532 def test_fd_leak(self):
1539 for x in self.fwalk(os_helper.TESTFN):
1542 self.addCleanup(os.close, newfd)
1543 self.assertEqual(newfd, minfd)
1551 def walk(self, top, **kwargs):
1565 def fwalk(self, top='.', *args, **kwargs):
1576 def setUp(self):
1579 def test_makedir(self):
1587 self.assertRaises(OSError, os.makedirs, os.curdir)
1598 def test_mode(self):
1604 self.assertTrue(os.path.exists(path))
1605 self.assertTrue(os.path.isdir(path))
1607 self.assertEqual(os.stat(path).st_mode & 0o777, 0o555)
1608 self.assertEqual(os.stat(parent).st_mode & 0o777, 0o775)
1614 def test_exist_ok_existing_directory(self):
1619 self.assertRaises(OSError, os.makedirs, path, mode)
1620 self.assertRaises(OSError, os.makedirs, path, mode, exist_ok=False)
1632 def test_exist_ok_s_isgid_directory(self):
1659 def test_exist_ok_existing_regular_file(self):
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)
1670 def test_win32_mkdir_700(self):
1676 self.assertEqual(
1681 def tearDown(self):
1700 def test_chown_uid_gid_arguments_must_be_index(self):
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))
1711 def test_chown_gid(self):
1714 self.skipTest("test needs at least 2 groups")
1721 self.assertEqual(gid, gid_1)
1725 self.assertEqual(gid, gid_2)
1729 def test_chown_with_root(self):
1734 self.assertEqual(uid, uid_1)
1737 self.assertEqual(uid, uid_2)
1741 def test_chown_without_permission(self):
1744 with self.assertRaises(PermissionError):
1754 def setUp(self):
1757 def tearDown(self):
1760 def test_remove_all(self):
1766 self.assertFalse(os.path.exists(dirb))
1767 self.assertFalse(os.path.exists(dira))
1768 self.assertFalse(os.path.exists(os_helper.TESTFN))
1770 def test_remove_partial(self):
1777 self.assertFalse(os.path.exists(dirb))
1778 self.assertTrue(os.path.exists(dira))
1779 self.assertTrue(os.path.exists(os_helper.TESTFN))
1781 def test_remove_nothing(self):
1787 with self.assertRaises(OSError):
1789 self.assertTrue(os.path.exists(dirb))
1790 self.assertTrue(os.path.exists(dira))
1791 self.assertTrue(os.path.exists(os_helper.TESTFN))
1796 def test_devnull(self):
1801 self.assertEqual(f.read(), b'')
1805 def test_urandom_length(self):
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)
1812 def test_urandom_value(self):
1814 self.assertIsInstance(data1, bytes)
1816 self.assertNotEqual(data1, data2)
1818 def get_urandom_subprocess(self, count):
1826 self.assertEqual(len(stdout), count)
1829 def test_urandom_subprocess(self):
1830 data1 = self.get_urandom_subprocess(16)
1831 data2 = self.get_urandom_subprocess(16)
1832 self.assertNotEqual(data1, data2)
1849 def test_getrandom_type(self):
1851 self.assertIsInstance(data, bytes)
1852 self.assertEqual(len(data), 16)
1854 def test_getrandom0(self):
1856 self.assertEqual(empty, b'')
1858 def test_getrandom_random(self):
1859 self.assertTrue(hasattr(os, 'GRND_RANDOM'))
1864 def test_getrandom_nonblock(self):
1872 def test_getrandom_value(self):
1875 self.assertNotEqual(data1, data2)
1891 def test_urandom_failure(self):
1913 def test_urandom_fd_closed(self):
1927 def test_urandom_fd_reopened(self):
1930 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
1959 self.assertEqual(len(out), 8)
1960 self.assertNotEqual(out[0:4], out[4:8])
1962 self.assertEqual(len(out2), 8)
1963 self.assertNotEqual(out2, out)
2004 def test_execvpe_with_bad_program(self):
2005 self.assertRaises(OSError, os.execvpe, 'no such app-',
2008 def test_execv_with_bad_arglist(self):
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', [''])
2014 def test_execvpe_with_bad_arglist(self):
2015 self.assertRaises(ValueError, os.execvpe, 'notepad', [], None)
2016 self.assertRaises(ValueError, os.execvpe, 'notepad', [], {})
2017 self.assertRaises(ValueError, os.execvpe, 'notepad', [''], {})
2021 def _test_internal_execvpe(self, test_type):
2040 self.assertRaises(RuntimeError,
2042 self.assertEqual(len(calls), 1)
2043 self.assertEqual(calls[0], ('execv', fullpath, (arguments,)))
2048 self.assertRaises(OSError,
2050 self.assertEqual(len(calls), 1)
2051 self.assertSequenceEqual(calls[0],
2062 self.assertRaises(OSError,
2064 self.assertEqual(len(calls), 1)
2065 self.assertSequenceEqual(calls[0],
2068 def test_internal_execvpe_str(self):
2069 self._test_internal_execvpe(str)
2071 self._test_internal_execvpe(bytes)
2073 def test_execve_invalid_env(self):
2079 with self.assertRaises(ValueError):
2085 with self.assertRaises(ValueError):
2091 with self.assertRaises(ValueError):
2095 def test_execve_with_empty_path(self):
2100 self.assertTrue(e.winerror is None or e.winerror != 0)
2102 self.fail('No OSError raised')
2107 def setUp(self):
2114 self.fail("file %s must not exist; os.stat failed with %s"
2117 self.fail("file %s must not exist" % os_helper.TESTFN)
2119 def test_rename(self):
2120 self.assertRaises(OSError, os.rename, os_helper.TESTFN, os_helper.TESTFN+".bak")
2122 def test_remove(self):
2123 self.assertRaises(OSError, os.remove, os_helper.TESTFN)
2125 def test_chdir(self):
2126 self.assertRaises(OSError, os.chdir, os_helper.TESTFN)
2128 def test_mkdir(self):
2129 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
2132 self.assertRaises(OSError, os.mkdir, os_helper.TESTFN)
2134 def test_utime(self):
2135 self.assertRaises(OSError, os.utime, os_helper.TESTFN, None)
2137 def test_chmod(self):
2138 self.assertRaises(OSError, os.chmod, os_helper.TESTFN, 0)
2148 def helper(self):
2150 self.check(getattr(os, f))
2155 def check(self, f, *args, **kwargs):
2159 self.assertEqual(e.errno, errno.EBADF)
2161 self.fail("%r didn't raise an OSError with a bad file descriptor"
2164 def test_fdopen(self):
2165 self.check(os.fdopen, encoding="utf-8")
2168 def test_isatty(self):
2169 self.assertEqual(os.isatty(os_helper.make_bad_fd()), False)
2172 def test_closerange(self):
2185 self.assertEqual(os.closerange(fd, fd + i-1), None)
2188 def test_dup2(self):
2189 self.check(os.dup2, 20)
2196 def test_dup2_negative_fd(self):
2198 self.addCleanup(os.close, valid_fd)
2206 with self.subTest(fd=fd, fd2=fd2):
2207 with self.assertRaises(OSError) as ctx:
2209 self.assertEqual(ctx.exception.errno, errno.EBADF)
2212 def test_fchmod(self):
2213 self.check(os.fchmod, 0)
2216 def test_fchown(self):
2217 self.check(os.fchown, -1, -1)
2224 def test_fpathconf(self):
2225 self.check(os.pathconf, "PC_NAME_MAX")
2226 self.check(os.fpathconf, "PC_NAME_MAX")
2229 def test_ftruncate(self):
2230 self.check(os.truncate, 0)
2231 self.check(os.ftruncate, 0)
2234 def test_lseek(self):
2235 self.check(os.lseek, 0, 0)
2238 def test_read(self):
2239 self.check(os.read, 1)
2242 def test_readv(self):
2244 self.check(os.readv, [buf])
2247 def test_tcsetpgrpt(self):
2248 self.check(os.tcsetpgrp, 0)
2251 def test_write(self):
2252 self.check(os.write, b" ")
2255 def test_writev(self):
2256 self.check(os.writev, [b'abc'])
2259 def test_inheritable(self):
2260 self.check(os.get_inheritable)
2261 self.check(os.set_inheritable, True)
2265 def test_blocking(self):
2266 self.check(os.get_blocking)
2267 self.check(os.set_blocking, True)
2272 def setUp(self):
2273 self.file1 = os_helper.TESTFN
2274 self.file2 = os.path.join(os_helper.TESTFN + "2")
2276 def tearDown(self):
2277 for file in (self.file1, self.file2):
2281 def _test_link(self, file1, file2):
2287 self.skipTest('os.link(): %s' % e)
2289 self.assertTrue(os.path.sameopenfile(f1.fileno(), f2.fileno()))
2291 def test_link(self):
2292 self._test_link(self.file1, self.file2)
2294 def test_link_bytes(self):
2295 self._test_link(bytes(self.file1, sys.getfilesystemencoding()),
2296 bytes(self.file2, sys.getfilesystemencoding()))
2298 def test_unicode_name(self):
2304 self.file1 += "\xf1"
2305 self.file2 = self.file1 + "2"
2306 self._test_link(self.file1, self.file2)
2315 def test_setuid(self):
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)
2322 def test_setgid(self):
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)
2329 def test_seteuid(self):
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)
2336 def test_setegid(self):
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)
2343 def test_setreuid(self):
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)
2353 def test_setreuid_neg1(self):
2362 def test_setregid(self):
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)
2372 def test_setregid_neg1(self):
2381 def setUp(self):
2383 self.dir = os_helper.TESTFN_UNENCODABLE
2385 self.dir = os_helper.TESTFN_NONASCII
2387 self.dir = os_helper.TESTFN
2388 self.bdir = os.fsencode(self.dir)
2403 self.skipTest("couldn't create any non-ascii filename")
2405 self.unicodefn = set()
2406 os.mkdir(self.dir)
2409 os_helper.create_empty_file(os.path.join(self.bdir, fn))
2411 if fn in self.unicodefn:
2413 self.unicodefn.add(fn)
2415 shutil.rmtree(self.dir)
2418 def tearDown(self):
2419 shutil.rmtree(self.dir)
2421 def test_listdir(self):
2422 expected = self.unicodefn
2423 found = set(os.listdir(self.dir))
2424 self.assertEqual(found, expected)
2429 self.assertEqual(set(os.listdir()), set(os.listdir(os.sep)))
2433 def test_open(self):
2434 for fn in self.unicodefn:
2435 f = open(os.path.join(self.dir, fn), 'rb')
2440 def test_statvfs(self):
2442 for fn in self.unicodefn:
2444 fullname = os.path.join(self.dir, fn)
2447 def test_stat(self):
2448 for fn in self.unicodefn:
2449 os.stat(os.path.join(self.dir, fn))
2453 def _kill(self, sig):
2483 self.addCleanup(proc.stdout.close)
2484 self.addCleanup(proc.stderr.close)
2485 self.addCleanup(proc.stdin.close)
2495 self.assertNotEqual(rslt, 0, "PeekNamedPipe failed")
2497 self.assertEqual(msg, buf.value.decode())
2502 self.fail("Did not receive communication from the subprocess")
2505 self.assertEqual(proc.wait(), sig)
2507 def test_kill_sigterm(self):
2509 self._kill(signal.SIGTERM)
2511 def test_kill_int(self):
2513 self._kill(100)
2516 def _kill_with_event(self, event, name):
2535 self.fail("Subprocess didn't finish initialization")
2543 self.fail("subprocess did not stop on {}".format(name))
2547 def test_CTRL_C_EVENT(self):
2563 self._kill_with_event(signal.CTRL_C_EVENT, "CTRL_C_EVENT")
2566 def test_CTRL_BREAK_EVENT(self):
2567 self._kill_with_event(signal.CTRL_BREAK_EVENT, "CTRL_BREAK_EVENT")
2574 def setUp(self):
2575 self.created_paths = []
2584 self.created_paths.extend([dir_name, file_name])
2585 self.created_paths.sort()
2587 def tearDown(self):
2590 def test_listdir_no_extended_path(self):
2593 self.assertEqual(
2595 self.created_paths)
2598 self.assertEqual(
2600 [os.fsencode(path) for path in self.created_paths])
2602 def test_listdir_extended_path(self):
2607 self.assertEqual(
2609 self.created_paths)
2613 self.assertEqual(
2615 [os.fsencode(path) for path in self.created_paths])
2625 def assertPathEqual(self, left, right):
2637 self.assertEqual(left, right)
2639 def setUp(self):
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))
2645 def test_not_symlink(self):
2646 filelink_target = FakePath(self.filelink_target)
2647 self.assertRaises(OSError, os.readlink, self.filelink_target)
2648 self.assertRaises(OSError, os.readlink, filelink_target)
2650 def test_missing_link(self):
2651 self.assertRaises(FileNotFoundError, os.readlink, 'missing-link')
2652 self.assertRaises(FileNotFoundError, os.readlink,
2656 def test_pathlike(self):
2657 os.symlink(self.filelink_target, self.filelink)
2658 self.addCleanup(os_helper.unlink, self.filelink)
2659 filelink = FakePath(self.filelink)
2660 self.assertPathEqual(os.readlink(filelink), self.filelink_target)
2663 def test_pathlike_bytes(self):
2664 os.symlink(self.filelinkb_target, self.filelinkb)
2665 self.addCleanup(os_helper.unlink, self.filelinkb)
2666 path = os.readlink(FakePath(self.filelinkb))
2667 self.assertPathEqual(path, self.filelinkb_target)
2668 self.assertIsInstance(path, bytes)
2671 def test_bytes(self):
2672 os.symlink(self.filelinkb_target, self.filelinkb)
2673 self.addCleanup(os_helper.unlink, self.filelinkb)
2674 path = os.readlink(self.filelinkb)
2675 self.assertPathEqual(path, self.filelinkb_target)
2676 self.assertIsInstance(path, bytes)
2688 def setUp(self):
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)
2695 def tearDown(self):
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)
2703 def test_directory_link(self):
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))
2708 self.check_stat(self.dirlink, self.dirlink_target)
2710 def test_file_link(self):
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))
2715 self.check_stat(self.filelink, self.filelink_target)
2717 def _create_missing_dir_link(self):
2719 linkname = self.missing_link
2727 def test_remove_directory_link_to_missing_target(self):
2728 self._create_missing_dir_link()
2732 os.remove(self.missing_link)
2734 def test_isdir_on_directory_link_to_missing_target(self):
2735 self._create_missing_dir_link()
2736 self.assertFalse(os.path.isdir(self.missing_link))
2738 def test_rmdir_on_directory_link_to_missing_target(self):
2739 self._create_missing_dir_link()
2740 os.rmdir(self.missing_link)
2742 def check_stat(self, link, target):
2743 self.assertEqual(os.stat(link), os.stat(target))
2744 self.assertNotEqual(os.lstat(link), os.stat(link))
2747 self.assertEqual(os.stat(bytes_link), os.stat(target))
2748 self.assertNotEqual(os.lstat(bytes_link), os.stat(bytes_link))
2750 def test_12084(self):
2754 self.addCleanup(os_helper.rmtree, level1)
2768 self.assertIn("link", os.listdir(os.getcwd()))
2771 self.assertEqual(os.stat(file1), os.stat("link"))
2775 self.assertEqual(os.stat(file1),
2780 self.assertEqual(os.stat(file1),
2788 def test_29248(self):
2798 self.assertTrue(os.path.samefile(target, r'C:\ProgramData'))
2800 def test_buffer_overflow(self):
2835 def test_appexeclink(self):
2838 self.skipTest("test requires a WindowsApps directory")
2848 self.assertEqual(st, os.stat(alias))
2849 self.assertFalse(stat.S_ISLNK(st.st_mode))
2850 self.assertEqual(st.st_reparse_tag, stat.IO_REPARSE_TAG_APPEXECLINK)
2854 self.skipTest("test requires an app execution alias")
2861 def setUp(self):
2862 assert os.path.exists(self.junction_target)
2863 assert not os.path.lexists(self.junction)
2865 def tearDown(self):
2866 if os.path.lexists(self.junction):
2867 os.unlink(self.junction)
2869 def test_create_junction(self):
2870 _winapi.CreateJunction(self.junction_target, 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)))
2882 def test_unlink_removes_junction(self):
2883 _winapi.CreateJunction(self.junction_target, 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))
2892 def test_getfinalpathname_handles(self):
2909 self.assertEqual(1, ok)
2934 self.assertEqual(1, ok)
2938 self.assertEqual(0, handle_delta)
2941 def test_stat_unlink_race(self):
2949 self.addCleanup(os_helper.unlink, filename)
2986 def setUp(self):
2995 def tearDown(self):
2998 def test_directory_link_nonlocal(self):
3016 def test_nop(self):
3017 self.assertEqual(os.fsencode(b'abc\xff'), b'abc\xff')
3018 self.assertEqual(os.fsdecode('abc\u0141'), 'abc\u0141')
3020 def test_identity(self):
3027 self.assertEqual(os.fsdecode(bytesfn), fn)
3033 def test_bad_fd(self):
3035 self.assertIsNone(os.device_encoding(123456))
3043 def test_device_encoding(self):
3045 self.assertIsNotNone(encoding)
3046 self.assertTrue(codecs.lookup(encoding))
3052 def test_getppid(self):
3058 self.assertEqual(int(stdout), os.getpid())
3060 def check_waitpid(self, code, exitcode, callback=None):
3075 self.assertEqual(os.waitstatus_to_exitcode(status), exitcode)
3076 self.assertEqual(pid2, pid)
3078 def test_waitpid(self):
3079 self.check_waitpid(code='pass', exitcode=0)
3081 def test_waitstatus_to_exitcode(self):
3084 self.check_waitpid(code, exitcode=exitcode)
3086 with self.assertRaises(TypeError):
3090 def test_waitpid_windows(self):
3095 self.check_waitpid(code, exitcode=STATUS_CONTROL_C_EXIT)
3098 def test_waitstatus_to_exitcode_windows(self):
3101 self.assertEqual(os.waitstatus_to_exitcode(exitcode << 8),
3105 with self.assertRaises(ValueError):
3107 with self.assertRaises(OverflowError):
3112 def test_waitstatus_to_exitcode_kill(self):
3119 self.check_waitpid(code, exitcode=-signum, callback=kill_process)
3132 def create_args(self, *, with_env=False, use_bytes=False):
3133 self.exitcode = 17
3136 self.addCleanup(os_helper.unlink, filename)
3139 code = 'import sys; sys.exit(%s)' % self.exitcode
3141 self.env = dict(os.environ)
3143 self.key = str(uuid.uuid4())
3144 self.env[self.key] = self.key
3147 % (self.key, self.exitcode))
3153 args = self.quote_args([program, filename])
3157 self.env = {os.fsencode(k): os.fsencode(v)
3158 for k, v in self.env.items()}
3163 def test_spawnl(self):
3164 program, args = self.create_args()
3166 self.assertEqual(exitcode, self.exitcode)
3169 def test_spawnle(self):
3170 program, args = self.create_args(with_env=True)
3171 exitcode = os.spawnle(os.P_WAIT, program, *args, self.env)
3172 self.assertEqual(exitcode, self.exitcode)
3175 def test_spawnlp(self):
3176 program, args = self.create_args()
3178 self.assertEqual(exitcode, self.exitcode)
3181 def test_spawnlpe(self):
3182 program, args = self.create_args(with_env=True)
3183 exitcode = os.spawnlpe(os.P_WAIT, program, *args, self.env)
3184 self.assertEqual(exitcode, self.exitcode)
3187 def test_spawnv(self):
3188 program, args = self.create_args()
3190 self.assertEqual(exitcode, self.exitcode)
3194 self.assertEqual(exitcode, self.exitcode)
3197 def test_spawnve(self):
3198 program, args = self.create_args(with_env=True)
3199 exitcode = os.spawnve(os.P_WAIT, program, args, self.env)
3200 self.assertEqual(exitcode, self.exitcode)
3203 def test_spawnvp(self):
3204 program, args = self.create_args()
3206 self.assertEqual(exitcode, self.exitcode)
3209 def test_spawnvpe(self):
3210 program, args = self.create_args(with_env=True)
3211 exitcode = os.spawnvpe(os.P_WAIT, program, args, self.env)
3212 self.assertEqual(exitcode, self.exitcode)
3215 def test_nowait(self):
3216 program, args = self.create_args()
3218 support.wait_process(pid, exitcode=self.exitcode)
3221 def test_spawnve_bytes(self):
3223 program, args = self.create_args(with_env=True, use_bytes=True)
3224 exitcode = os.spawnve(os.P_WAIT, program, args, self.env)
3225 self.assertEqual(exitcode, self.exitcode)
3228 def test_spawnl_noargs(self):
3229 program, __ = self.create_args()
3230 self.assertRaises(ValueError, os.spawnl, os.P_NOWAIT, program)
3231 self.assertRaises(ValueError, os.spawnl, os.P_NOWAIT, program, '')
3234 def test_spawnle_noargs(self):
3235 program, __ = self.create_args()
3236 self.assertRaises(ValueError, os.spawnle, os.P_NOWAIT, program, {})
3237 self.assertRaises(ValueError, os.spawnle, os.P_NOWAIT, program, '', {})
3240 def test_spawnv_noargs(self):
3241 program, __ = self.create_args()
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, [''])
3248 def test_spawnve_noargs(self):
3249 program, __ = self.create_args()
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, [''], {})
3255 def _test_invalid_env(self, spawn):
3257 args = self.quote_args([program, '-c', 'pass'])
3267 self.assertEqual(exitcode, 127)
3277 self.assertEqual(exitcode, 127)
3287 self.assertEqual(exitcode, 127)
3291 self.addCleanup(os_helper.unlink, filename)
3297 args = self.quote_args([program, filename])
3301 self.assertEqual(exitcode, 0)
3304 def test_spawnve_invalid_env(self):
3305 self._test_invalid_env(os.spawnve)
3308 def test_spawnvpe_invalid_env(self):
3309 self._test_invalid_env(os.spawnvpe)
3317 def test_getlogin(self):
3319 self.assertNotEqual(len(user_name), 0)
3327 def test_set_get_priority(self):
3337 self.assertEqual(new_prio, base + 1)
3371 async def handle_new_client(self, reader, writer):
3372 self.server_buffer = b''.join([x async for x in self.chunks(reader)])
3374 self.server.close() # The test server processes a single client only
3376 async def asyncSetUp(self):
3377 self.server_buffer = b''
3378 self.server = await asyncio.start_server(self.handle_new_client,
3380 server_name = self.server.sockets[0].getsockname()
3381 self.client = socket.socket()
3382 self.client.setblocking(False)
3383 await asyncio.get_running_loop().sock_connect(self.client, server_name)
3384 self.sockno = self.client.fileno()
3385 self.file = open(os_helper.TESTFN, 'rb')
3386 self.fileno = self.file.fileno()
3388 async def asyncTearDown(self):
3389 self.file.close()
3390 self.client.close()
3391 await self.server.wait_closed()
3416 async def test_send_whole_file(self):
3421 while total_sent < len(self.DATA):
3422 sent = await self.sendfile_wrapper(self.sockno, self.fileno,
3428 self.assertTrue(sent <= nbytes)
3429 self.assertEqual(offset, total_sent)
3431 self.assertEqual(total_sent, len(self.DATA))
3432 self.client.shutdown(socket.SHUT_RDWR)
3433 self.client.close()
3434 await self.server.wait_closed()
3435 self.assertEqual(len(self.server_buffer), len(self.DATA))
3436 self.assertEqual(self.server_buffer, self.DATA)
3438 async def test_send_at_certain_offset(self):
3441 offset = len(self.DATA) // 2
3442 must_send = len(self.DATA) - offset
3445 sent = await self.sendfile_wrapper(self.sockno, self.fileno,
3451 self.assertTrue(sent <= nbytes)
3453 self.client.shutdown(socket.SHUT_RDWR)
3454 self.client.close()
3455 await self.server.wait_closed()
3456 expected = self.DATA[len(self.DATA) // 2:]
3457 self.assertEqual(total_sent, len(expected))
3458 self.assertEqual(len(self.server_buffer), len(expected))
3459 self.assertEqual(self.server_buffer, expected)
3461 async def test_offset_overflow(self):
3463 offset = len(self.DATA) + 4096
3465 sent = await self.async_sendfile(self.sockno, self.fileno,
3472 self.assertEqual(sent, 0)
3473 self.client.shutdown(socket.SHUT_RDWR)
3474 self.client.close()
3475 await self.server.wait_closed()
3476 self.assertEqual(self.server_buffer, b'')
3478 async def test_invalid_offset(self):
3479 with self.assertRaises(OSError) as cm:
3480 await self.async_sendfile(self.sockno, self.fileno, -1, 4096)
3481 self.assertEqual(cm.exception.errno, errno.EINVAL)
3483 async def test_keywords(self):
3485 await self.async_sendfile(out_fd=self.sockno, in_fd=self.fileno,
3487 if self.SUPPORT_HEADERS_TRAILERS:
3488 await self.async_sendfile(out_fd=self.sockno, in_fd=self.fileno,
3495 async def test_headers(self):
3497 expected_data = b"x" * 512 + b"y" * 256 + self.DATA[:-1]
3498 sent = await self.async_sendfile(self.sockno, self.fileno, 0, 4096,
3500 self.assertLessEqual(sent, 512 + 256 + 4096)
3505 sent = await self.sendfile_wrapper(self.sockno, self.fileno,
3509 self.assertLessEqual(sent, nbytes)
3513 self.assertEqual(total_sent, len(expected_data))
3514 self.client.close()
3515 await self.server.wait_closed()
3516 self.assertEqual(hash(self.server_buffer), hash(expected_data))
3519 async def test_trailers(self):
3523 self.addCleanup(os_helper.unlink, TESTFN2)
3527 await self.async_sendfile(self.sockno, f.fileno(), 0, 5,
3529 self.client.close()
3530 await self.server.wait_closed()
3531 self.assertEqual(self.server_buffer, b"abcde123456789")
3535 async def test_headers_overflow_32bits(self):
3536 self.server.handler_instance.accumulate = False
3537 with self.assertRaises(OSError) as cm:
3538 await self.async_sendfile(self.sockno, self.fileno, 0, 0,
3540 self.assertEqual(cm.exception.errno, errno.EINVAL)
3544 async def test_trailers_overflow_32bits(self):
3545 self.server.handler_instance.accumulate = False
3546 with self.assertRaises(OSError) as cm:
3547 await self.async_sendfile(self.sockno, self.fileno, 0, 0,
3549 self.assertEqual(cm.exception.errno, errno.EINVAL)
3554 async def test_flags(self):
3556 await self.async_sendfile(self.sockno, self.fileno, 0, 4096,
3585 def _check_xattrs_str(self, s, getxattr, setxattr, removexattr, listxattr, **kwargs):
3587 self.addCleanup(os_helper.unlink, fn)
3590 with self.assertRaises(OSError) as cm:
3592 self.assertEqual(cm.exception.errno, errno.ENODATA)
3595 self.assertIsInstance(init_xattr, list)
3600 self.assertEqual(set(listxattr(fn)), xattr)
3601 self.assertEqual(getxattr(fn, b"user.test", **kwargs), b"")
3603 self.assertEqual(getxattr(fn, b"user.test", **kwargs), b"hello")
3605 with self.assertRaises(OSError) as cm:
3607 self.assertEqual(cm.exception.errno, errno.EEXIST)
3609 with self.assertRaises(OSError) as cm:
3611 self.assertEqual(cm.exception.errno, errno.ENODATA)
3615 self.assertEqual(set(listxattr(fn)), xattr)
3618 with self.assertRaises(OSError) as cm:
3620 self.assertEqual(cm.exception.errno, errno.ENODATA)
3623 self.assertEqual(set(listxattr(fn)), xattr)
3624 self.assertEqual(getxattr(fn, s("user.test2"), **kwargs), b"foo")
3626 self.assertEqual(getxattr(fn, s("user.test"), **kwargs), b"a"*1024)
3631 self.assertEqual(set(listxattr(fn)), set(init_xattr) | set(many))
3633 def _check_xattrs(self, *args, **kwargs):
3634 self._check_xattrs_str(str, *args, **kwargs)
3637 self._check_xattrs_str(os.fsencode, *args, **kwargs)
3640 def test_simple(self):
3641 self._check_xattrs(os.getxattr, os.setxattr, os.removexattr,
3644 def test_lpath(self):
3645 self._check_xattrs(os.getxattr, os.setxattr, os.removexattr,
3648 def test_fds(self):
3661 self._check_xattrs(getxattr, setxattr, removexattr, listxattr)
3666 def test_does_not_crash(self):
3678 self.skipTest("failed to query terminal size")
3681 self.assertGreaterEqual(size.columns, 0)
3682 self.assertGreaterEqual(size.lines, 0)
3684 def test_stty_match(self):
3699 self.skipTest("stty invocation failed")
3708 self.skipTest("failed to query terminal size")
3710 self.assertEqual(expected, actual)
3716 def test_memfd_create(self):
3718 self.assertNotEqual(fd, -1)
3719 self.addCleanup(os.close, fd)
3720 self.assertFalse(os.get_inheritable(fd))
3723 self.assertEqual(f.tell(), 12)
3726 self.addCleanup(os.close, fd2)
3727 self.assertFalse(os.get_inheritable(fd2))
3733 def test_eventfd_initval(self):
3741 self.assertNotEqual(fd, -1)
3742 self.addCleanup(os.close, fd)
3743 self.assertFalse(os.get_inheritable(fd))
3747 self.assertEqual(res, pack(initval))
3751 self.assertEqual(res, pack(23))
3756 self.assertEqual(res, pack(42))
3762 self.assertEqual(res, 23)
3764 def test_eventfd_semaphore(self):
3768 self.assertNotEqual(fd, -1)
3769 self.addCleanup(os.close, fd)
3773 self.assertEqual(res, 1)
3775 self.assertEqual(res, 1)
3777 with self.assertRaises(BlockingIOError):
3779 with self.assertRaises(BlockingIOError):
3785 self.assertEqual(res, 1)
3787 with self.assertRaises(BlockingIOError):
3790 def test_eventfd_select(self):
3793 self.assertNotEqual(fd, -1)
3794 self.addCleanup(os.close, fd)
3798 self.assertEqual((rfd, wfd, xfd), ([], [fd], []))
3803 self.assertEqual((rfd, wfd, xfd), ([fd], [fd], []))
3804 self.assertEqual(os.eventfd_read(fd), 23)
3809 self.assertEqual((rfd, wfd, xfd), ([fd], [], []))
3814 def setUp(self):
3818 self.bytes_filenames = []
3819 self.unicode_filenames = []
3824 self.unicode_filenames.append(decoded)
3825 self.unicode_filenames.append(Str(decoded))
3830 self.bytes_filenames.append(encoded)
3831 self.bytes_filenames.append(bytearray(encoded))
3832 self.bytes_filenames.append(memoryview(encoded))
3834 self.filenames = self.bytes_filenames + self.unicode_filenames
3836 def test_oserror_filename(self):
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))
3862 funcs.append((self.filenames, os.chown, 0, 0))
3864 funcs.append((self.filenames, os.lchown, 0, 0))
3866 funcs.append((self.filenames, os.truncate, 0))
3868 funcs.append((self.filenames, os.chflags, 0))
3870 funcs.append((self.filenames, os.lchflags, 0))
3872 funcs.append((self.filenames, os.chroot,))
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"))
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"),
3887 funcs.append((self.filenames, os.lchmod, 0o777))
3889 funcs.append((self.filenames, os.readlink,))
3898 with self.assertWarnsRegex(DeprecationWarning, 'should be'):
3901 self.assertIs(err.filename, name, str(func))
3905 self.fail("No exception thrown by {}".format(func))
3908 def test_cpu_count(self):
3911 self.assertIsInstance(cpus, int)
3912 self.assertGreater(cpus, 0)
3914 self.skipTest("Could not determine the number of CPUs")
3920 def test_get_set_inheritable(self):
3922 self.addCleanup(os.close, fd)
3923 self.assertEqual(os.get_inheritable(fd), False)
3926 self.assertEqual(os.get_inheritable(fd), True)
3929 def test_get_inheritable_cloexec(self):
3931 self.addCleanup(os.close, fd)
3932 self.assertEqual(os.get_inheritable(fd), False)
3939 self.assertEqual(os.get_inheritable(fd), True)
3942 def test_set_inheritable_cloexec(self):
3944 self.addCleanup(os.close, fd)
3945 self.assertEqual(fcntl.fcntl(fd, fcntl.F_GETFD) & fcntl.FD_CLOEXEC,
3949 self.assertEqual(fcntl.fcntl(fd, fcntl.F_GETFD) & fcntl.FD_CLOEXEC,
3953 def test_get_set_inheritable_o_path(self):
3955 self.addCleanup(os.close, fd)
3956 self.assertEqual(os.get_inheritable(fd), False)
3959 self.assertEqual(os.get_inheritable(fd), True)
3962 self.assertEqual(os.get_inheritable(fd), False)
3964 def test_get_set_inheritable_badf(self):
3967 with self.assertRaises(OSError) as ctx:
3969 self.assertEqual(ctx.exception.errno, errno.EBADF)
3971 with self.assertRaises(OSError) as ctx:
3973 self.assertEqual(ctx.exception.errno, errno.EBADF)
3975 with self.assertRaises(OSError) as ctx:
3977 self.assertEqual(ctx.exception.errno, errno.EBADF)
3979 def test_open(self):
3981 self.addCleanup(os.close, fd)
3982 self.assertEqual(os.get_inheritable(fd), False)
3985 def test_pipe(self):
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)
3992 def test_dup(self):
3994 self.addCleanup(os.close, fd1)
3997 self.addCleanup(os.close, fd2)
3998 self.assertEqual(os.get_inheritable(fd2), False)
4000 def test_dup_standard_stream(self):
4002 self.addCleanup(os.close, fd)
4003 self.assertGreater(fd, 0)
4006 def test_dup_nul(self):
4009 self.addCleanup(os.close, fd1)
4011 self.addCleanup(os.close, fd2)
4012 self.assertFalse(os.get_inheritable(fd2))
4015 def test_dup2(self):
4017 self.addCleanup(os.close, fd)
4021 self.addCleanup(os.close, fd2)
4022 self.assertEqual(os.dup2(fd, fd2), fd2)
4023 self.assertTrue(os.get_inheritable(fd2))
4027 self.addCleanup(os.close, fd3)
4028 self.assertEqual(os.dup2(fd, fd3, inheritable=False), fd3)
4029 self.assertFalse(os.get_inheritable(fd3))
4032 def test_openpty(self):
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)
4052 def test_path_t_converter(self):
4060 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
4061 self.addCleanup(os.close, fd)
4066 for name, allow_fd, extra_args, cleanup_fn in self.functions:
4067 with self.subTest(name=name):
4077 with self.subTest(name=name, path=path):
4082 with self.assertRaisesRegex(
4091 with self.assertRaisesRegex(
4096 def test_path_t_converter_and_custom_class(self):
4098 with self.assertRaisesRegex(TypeError, msg % r'int'):
4100 with self.assertRaisesRegex(TypeError, msg % r'float'):
4102 with self.assertRaisesRegex(TypeError, msg % r'object'):
4110 def test_blocking(self):
4112 self.addCleanup(os.close, fd)
4113 self.assertEqual(os.get_blocking(fd), True)
4116 self.assertEqual(os.get_blocking(fd), False)
4119 self.assertEqual(os.get_blocking(fd), True)
4124 def test_os_all(self):
4125 self.assertIn('open', os.__all__)
4126 self.assertIn('walk', os.__all__)
4130 def setUp(self):
4131 self.path = os.path.realpath(os_helper.TESTFN)
4132 self.addCleanup(os_helper.rmtree, self.path)
4133 os.mkdir(self.path)
4135 def test_uninstantiable(self):
4136 self.assertRaises(TypeError, os.DirEntry)
4138 def test_unpickable(self):
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)
4142 self.assertEqual(entry.name, "file.txt")
4144 self.assertRaises(TypeError, pickle.dumps, entry, filename)
4150 def setUp(self):
4151 self.path = os.path.realpath(os_helper.TESTFN)
4152 self.bytes_path = os.fsencode(self.path)
4153 self.addCleanup(os_helper.rmtree, self.path)
4154 os.mkdir(self.path)
4156 def create_file(self, name="file.txt"):
4157 path = self.bytes_path if isinstance(name, bytes) else self.path
4162 def get_entries(self, names):
4164 for entry in os.scandir(self.path))
4165 self.assertEqual(sorted(entries.keys()), names)
4168 def assert_stat_equal(self, stat1, stat2, skip_fields):
4175 self.assertEqual(getattr(stat1, attr),
4179 self.assertEqual(stat1, stat2)
4181 def test_uninstantiable(self):
4182 scandir_iter = os.scandir(self.path)
4183 self.assertRaises(TypeError, type(scandir_iter))
4186 def test_unpickable(self):
4187 filename = self.create_file("file.txt")
4188 scandir_iter = os.scandir(self.path)
4190 self.assertRaises(TypeError, pickle.dumps, scandir_iter, filename)
4193 def check_entry(self, entry, name, is_dir, is_file, is_symlink):
4194 self.assertIsInstance(entry, os.DirEntry)
4195 self.assertEqual(entry.name, name)
4196 self.assertEqual(entry.path, os.path.join(self.path, name))
4197 self.assertEqual(entry.inode(),
4201 self.assertEqual(entry.is_dir(),
4203 self.assertEqual(entry.is_file(),
4205 self.assertEqual(entry.is_symlink(),
4209 self.assertEqual(entry.is_dir(follow_symlinks=False),
4211 self.assertEqual(entry.is_file(follow_symlinks=False),
4214 self.assert_stat_equal(entry.stat(),
4217 self.assert_stat_equal(entry.stat(follow_symlinks=False),
4221 def test_attributes(self):
4225 dirname = os.path.join(self.path, "dir")
4227 filename = self.create_file("file.txt")
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"))
4243 entries = self.get_entries(names)
4246 self.check_entry(entry, 'dir', True, False, False)
4249 self.check_entry(entry, 'file.txt', False, True, False)
4253 self.check_entry(entry, 'link_file.txt', False, True, False)
4257 self.check_entry(entry, 'symlink_dir', True, False, True)
4260 self.check_entry(entry, 'symlink_file.txt', False, True, True)
4262 def get_entry(self, name):
4263 path = self.bytes_path if isinstance(name, bytes) else self.path
4265 self.assertEqual(len(entries), 1)
4268 self.assertEqual(entry.name, name)
4271 def create_file_entry(self, name='file.txt'):
4272 filename = self.create_file(name=name)
4273 return self.get_entry(os.path.basename(filename))
4275 def test_current_directory(self):
4276 filename = self.create_file()
4279 os.chdir(self.path)
4284 self.assertEqual(sorted(entries.keys()),
4289 def test_repr(self):
4290 entry = self.create_file_entry()
4291 self.assertEqual(repr(entry), "<DirEntry 'file.txt'>")
4293 def test_fspath_protocol(self):
4294 entry = self.create_file_entry()
4295 self.assertEqual(os.fspath(entry), os.path.join(self.path, 'file.txt'))
4297 def test_fspath_protocol_bytes(self):
4299 bytes_entry = self.create_file_entry(name=bytes_filename)
4301 self.assertIsInstance(fspath, bytes)
4302 self.assertEqual(fspath,
4303 os.path.join(os.fsencode(self.path),bytes_filename))
4305 def test_removed_dir(self):
4306 path = os.path.join(self.path, 'dir')
4309 entry = self.get_entry('dir')
4314 self.assertTrue(entry.is_dir())
4315 self.assertFalse(entry.is_file())
4316 self.assertFalse(entry.is_symlink())
4318 self.assertRaises(FileNotFoundError, entry.inode)
4323 self.assertGreater(entry.inode(), 0)
4324 self.assertRaises(FileNotFoundError, entry.stat)
4325 self.assertRaises(FileNotFoundError, entry.stat, follow_symlinks=False)
4327 def test_removed_file(self):
4328 entry = self.create_file_entry()
4331 self.assertFalse(entry.is_dir())
4334 self.assertTrue(entry.is_file())
4335 self.assertFalse(entry.is_symlink())
4337 self.assertRaises(FileNotFoundError, entry.inode)
4342 self.assertGreater(entry.inode(), 0)
4343 self.assertRaises(FileNotFoundError, entry.stat)
4344 self.assertRaises(FileNotFoundError, entry.stat, follow_symlinks=False)
4346 def test_broken_symlink(self):
4348 return self.skipTest('cannot create symbolic link')
4350 filename = self.create_file("file.txt")
4352 os.path.join(self.path, "symlink.txt"))
4353 entries = self.get_entries(['file.txt', 'symlink.txt'])
4357 self.assertGreater(entry.inode(), 0)
4358 self.assertFalse(entry.is_dir())
4359 self.assertFalse(entry.is_file()) # broken symlink returns False
4360 self.assertFalse(entry.is_dir(follow_symlinks=False))
4361 self.assertFalse(entry.is_file(follow_symlinks=False))
4362 self.assertTrue(entry.is_symlink())
4363 self.assertRaises(FileNotFoundError, entry.stat)
4367 def test_bytes(self):
4368 self.create_file("file.txt")
4370 path_bytes = os.fsencode(self.path)
4372 self.assertEqual(len(entries), 1, entries)
4375 self.assertEqual(entry.name, b'file.txt')
4376 self.assertEqual(entry.path,
4377 os.fsencode(os.path.join(self.path, 'file.txt')))
4379 def test_bytes_like(self):
4380 self.create_file("file.txt")
4383 path_bytes = cls(os.fsencode(self.path))
4384 with self.assertWarns(DeprecationWarning):
4386 self.assertEqual(len(entries), 1, entries)
4389 self.assertEqual(entry.name, b'file.txt')
4390 self.assertEqual(entry.path,
4391 os.fsencode(os.path.join(self.path, 'file.txt')))
4392 self.assertIs(type(entry.name), bytes)
4393 self.assertIs(type(entry.path), bytes)
4397 def test_fd(self):
4398 self.assertIn(os.scandir, os.supports_fd)
4399 self.create_file('file.txt')
4402 os.symlink('file.txt', os.path.join(self.path, 'link'))
4405 with os_helper.open_dir_fd(self.path) as fd:
4409 self.assertEqual(sorted(names), expected_names)
4410 self.assertEqual(names, os.listdir(fd))
4412 self.assertEqual(entry.path, entry.name)
4413 self.assertEqual(os.fspath(entry), entry.name)
4414 self.assertEqual(entry.is_symlink(), entry.name == 'link')
4417 self.assertEqual(entry.stat(), st)
4419 self.assertEqual(entry.stat(follow_symlinks=False), st)
4422 def test_empty_path(self):
4423 self.assertRaises(FileNotFoundError, os.scandir, '')
4425 def test_consume_iterator_twice(self):
4426 self.create_file("file.txt")
4427 iterator = os.scandir(self.path)
4430 self.assertEqual(len(entries), 1, entries)
4434 self.assertEqual(len(entries2), 0, entries2)
4436 def test_bad_path_type(self):
4438 self.assertRaises(TypeError, os.scandir, obj)
4440 def test_close(self):
4441 self.create_file("file.txt")
4442 self.create_file("file2.txt")
4443 iterator = os.scandir(self.path)
4448 with self.check_no_resource_warning():
4451 def test_context_manager(self):
4452 self.create_file("file.txt")
4453 self.create_file("file2.txt")
4454 with os.scandir(self.path) as iterator:
4456 with self.check_no_resource_warning():
4459 def test_context_manager_close(self):
4460 self.create_file("file.txt")
4461 self.create_file("file2.txt")
4462 with os.scandir(self.path) as iterator:
4466 def test_context_manager_exception(self):
4467 self.create_file("file.txt")
4468 self.create_file("file2.txt")
4469 with self.assertRaises(ZeroDivisionError):
4470 with os.scandir(self.path) as iterator:
4473 with self.check_no_resource_warning():
4476 def test_resource_warning(self):
4477 self.create_file("file.txt")
4478 self.create_file("file2.txt")
4479 iterator = os.scandir(self.path)
4481 with self.assertWarns(ResourceWarning):
4485 iterator = os.scandir(self.path)
4487 with self.check_no_resource_warning():
4497 def test_return_bytes(self):
4499 self.assertEqual(b, self.fspath(b))
4501 def test_return_string(self):
4503 self.assertEqual(s, self.fspath(s))
4505 def test_fsencode_fsdecode(self):
4509 self.assertEqual(p, self.fspath(pathlike))
4510 self.assertEqual(b"path/like/object", os.fsencode(pathlike))
4511 self.assertEqual("path/like/object", os.fsdecode(pathlike))
4513 def test_pathlike(self):
4514 self.assertEqual('#feelthegil', self.fspath(FakePath('#feelthegil')))
4515 self.assertTrue(issubclass(FakePath, os.PathLike))
4516 self.assertTrue(isinstance(FakePath('x'), os.PathLike))
4518 def test_garbage_in_exception_out(self):
4521 self.assertRaises(TypeError, self.fspath, o)
4523 def test_argument_required(self):
4524 self.assertRaises(TypeError, self.fspath)
4526 def test_bad_pathlike(self):
4528 self.assertRaises(TypeError, self.fspath, FakePath(42))
4532 self.assertRaises(TypeError, self.fspath, c())
4534 self.assertRaises(ZeroDivisionError, self.fspath,
4537 def test_pathlike_subclasshook(self):
4542 self.assertFalse(issubclass(FakePath, A))
4543 self.assertTrue(issubclass(FakePath, os.PathLike))
4545 def test_pathlike_class_getitem(self):
4546 self.assertIsInstance(os.PathLike[bytes], types.GenericAlias)
4550 def test_times(self):
4552 self.assertIsInstance(times, os.times_result)
4557 self.assertIsInstance(value, float)
4560 self.assertEqual(times.children_user, 0)
4561 self.assertEqual(times.children_system, 0)
4562 self.assertEqual(times.elapsed, 0)
4567 def test_fork(self):