def test_getcwd(self):

cwd = os.getcwd()

self.assertIsInstance(cwd, str)

def test_getcwd_long_path(self):

# bpo-37412: On Linux, PATH_MAX is usually around 4096 bytes. On

# Windows, MAX_PATH is defined as 260 characters, but Windows supports

# longer path if longer paths support is enabled. Internally, the os

# module uses MAXPATHLEN which is at least 1024.

#

# Use a directory name of 200 characters to fit into Windows MAX_PATH

# limit.

#

# On Windows, the test can stop when trying to create a path longer

# than MAX_PATH if long paths support is disabled:

# see RtlAreLongPathsEnabled().

min_len = 2000 # characters

# On VxWorks, PATH_MAX is defined as 1024 bytes. Creating a path

# longer than PATH_MAX will fail.

if sys.platform == 'vxworks':

min_len = 1000

dirlen = 200 # characters

dirname = 'python_test_dir_'

dirname = dirname + ('a' * (dirlen - len(dirname)))

with tempfile.TemporaryDirectory() as tmpdir:

with os_helper.change_cwd(tmpdir) as path:

expected = path

while True:

cwd = os.getcwd()

self.assertEqual(cwd, expected)

need = min_len - (len(cwd) + len(os.path.sep))

if need <= 0:

break

if len(dirname) > need and need > 0:

dirname = dirname[:need]

path = os.path.join(path, dirname)

try:

os.mkdir(path)

# On Windows, chdir() can fail

# even if mkdir() succeeded

os.chdir(path)

except FileNotFoundError:

# On Windows, catch ERROR_PATH_NOT_FOUND (3) and

# ERROR_FILENAME_EXCED_RANGE (206) errors

# ("The filename or extension is too long")

break

except OSError as exc:

if exc.errno == errno.ENAMETOOLONG:

break

else:

raise

expected = path

if support.verbose:

print(f"Tested current directory length: {len(cwd)}")

def test_getcwdb(self):

cwd = os.getcwdb()

self.assertIsInstance(cwd, bytes)

def setUp(self):

if os.path.lexists(os_helper.TESTFN):

os.unlink(os_helper.TESTFN)

tearDown = setUp

def test_access(self):

f = os.open(os_helper.TESTFN, os.O_CREAT|os.O_RDWR)

os.close(f)

self.assertTrue(os.access(os_helper.TESTFN, os.W_OK))

@unittest.skipIf(

@unittest.skipIf(

def test_closerange(self):

first = os.open(os_helper.TESTFN, os.O_CREAT|os.O_RDWR)

# We must allocate two consecutive file descriptors, otherwise

# it will mess up other file descriptors (perhaps even the three

# standard ones).

second = os.dup(first)

try:

retries = 0

while second != first + 1:

os.close(first)

retries += 1

if retries > 10:

# XXX test skipped

self.skipTest("couldn't allocate two consecutive fds")

first, second = second, os.dup(second)

finally:

os.close(second)

# close a fd that is open, and one that isn't

os.closerange(first, first + 2)

self.assertRaises(OSError, os.write, first, b"a")

@support.cpython_only

def test_rename(self):

path = os_helper.TESTFN

old = sys.getrefcount(path)

self.assertRaises(TypeError, os.rename, path, 0)

new = sys.getrefcount(path)

self.assertEqual(old, new)

def test_read(self):

with open(os_helper.TESTFN, "w+b") as fobj:

fobj.write(b"spam")

fobj.flush()

fd = fobj.fileno()

os.lseek(fd, 0, 0)

s = os.read(fd, 4)

self.assertEqual(type(s), bytes)

self.assertEqual(s, b"spam")

@support.cpython_only

# Skip the test on 32-bit platforms: the number of bytes must fit in a

# Py_ssize_t type

@unittest.skipUnless(INT_MAX < PY_SSIZE_T_MAX,

@support.bigmemtest(size=INT_MAX + 10, memuse=1, dry_run=False)

def test_large_read(self, size):

self.addCleanup(os_helper.unlink, os_helper.TESTFN)

create_file(os_helper.TESTFN, b'test')

# Issue #21932: Make sure that os.read() does not raise an

# OverflowError for size larger than INT_MAX

with open(os_helper.TESTFN, "rb") as fp:

data = os.read(fp.fileno(), size)

# The test does not try to read more than 2 GiB at once because the

# operating system is free to return less bytes than requested.

self.assertEqual(data, b'test')

def test_write(self):

# os.write() accepts bytes- and buffer-like objects but not strings

fd = os.open(os_helper.TESTFN, os.O_CREAT | os.O_WRONLY)

self.assertRaises(TypeError, os.write, fd, "beans")

os.write(fd, b"bacon\n")

os.write(fd, bytearray(b"eggs\n"))

os.write(fd, memoryview(b"spam\n"))

os.close(fd)

with open(os_helper.TESTFN, "rb") as fobj:

self.assertEqual(fobj.read().splitlines(),

[b"bacon", b"eggs", b"spam"])

def write_windows_console(self, *args):

retcode = subprocess.call(args,

# use a new console to not flood the test output

creationflags=subprocess.CREATE_NEW_CONSOLE,

# use a shell to hide the console window (SW_HIDE)

shell=True)

self.assertEqual(retcode, 0)

@unittest.skipUnless(sys.platform == 'win32',

def test_write_windows_console(self):

# Issue #11395: the Windows console returns an error (12: not enough

# space error) on writing into stdout if stdout mode is binary and the

# length is greater than 66,000 bytes (or less, depending on heap

# usage).

code = "print('x' * 100000)"

self.write_windows_console(sys.executable, "-c", code)

self.write_windows_console(sys.executable, "-u", "-c", code)

def fdopen_helper(self, *args):

fd = os.open(os_helper.TESTFN, os.O_RDONLY)

f = os.fdopen(fd, *args, encoding="utf-8")

f.close()

def test_fdopen(self):

fd = os.open(os_helper.TESTFN, os.O_CREAT|os.O_RDWR)

os.close(fd)

self.fdopen_helper()

self.fdopen_helper('r')

self.fdopen_helper('r', 100)

def test_replace(self):

TESTFN2 = os_helper.TESTFN + ".2"

self.addCleanup(os_helper.unlink, os_helper.TESTFN)

self.addCleanup(os_helper.unlink, TESTFN2)

create_file(os_helper.TESTFN, b"1")

create_file(TESTFN2, b"2")

os.replace(os_helper.TESTFN, TESTFN2)

self.assertRaises(FileNotFoundError, os.stat, os_helper.TESTFN)

with open(TESTFN2, 'r', encoding='utf-8') as f:

self.assertEqual(f.read(), "1")

def test_open_keywords(self):

f = os.open(path=__file__, flags=os.O_RDONLY, mode=0o777,

dir_fd=None)

os.close(f)

def test_symlink_keywords(self):

symlink = support.get_attribute(os, "symlink")

try:

symlink(src='target', dst=os_helper.TESTFN,

target_is_directory=False, dir_fd=None)

except (NotImplementedError, OSError):

pass # No OS support or unprivileged user

@unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')

def test_copy_file_range_invalid_values(self):

with self.assertRaises(ValueError):

os.copy_file_range(0, 1, -10)

@unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')

def test_copy_file_range(self):

TESTFN2 = os_helper.TESTFN + ".3"

data = b'0123456789'

create_file(os_helper.TESTFN, data)

self.addCleanup(os_helper.unlink, os_helper.TESTFN)

in_file = open(os_helper.TESTFN, 'rb')

self.addCleanup(in_file.close)

in_fd = in_file.fileno()

out_file = open(TESTFN2, 'w+b')

self.addCleanup(os_helper.unlink, TESTFN2)

self.addCleanup(out_file.close)

out_fd = out_file.fileno()

try:

i = os.copy_file_range(in_fd, out_fd, 5)

except OSError as e:

# Handle the case in which Python was compiled

# in a system with the syscall but without support

# in the kernel.

if e.errno != errno.ENOSYS:

raise

self.skipTest(e)

else:

# The number of copied bytes can be less than

# the number of bytes originally requested.

self.assertIn(i, range(0, 6));

with open(TESTFN2, 'rb') as in_file:

self.assertEqual(in_file.read(), data[:i])

@unittest.skipUnless(hasattr(os, 'copy_file_range'), 'test needs os.copy_file_range()')

def test_copy_file_range_offset(self):

TESTFN4 = os_helper.TESTFN + ".4"

data = b'0123456789'

bytes_to_copy = 6

in_skip = 3

out_seek = 5

create_file(os_helper.TESTFN, data)

self.addCleanup(os_helper.unlink, os_helper.TESTFN)

in_file = open(os_helper.TESTFN, 'rb')

self.addCleanup(in_file.close)

in_fd = in_file.fileno()

out_file = open(TESTFN4, 'w+b')

self.addCleanup(os_helper.unlink, TESTFN4)

self.addCleanup(out_file.close)

out_fd = out_file.fileno()

try:

i = os.copy_file_range(in_fd, out_fd, bytes_to_copy,

offset_src=in_skip,

offset_dst=out_seek)

except OSError as e:

# Handle the case in which Python was compiled

# in a system with the syscall but without support

# in the kernel.

if e.errno != errno.ENOSYS:

raise

self.skipTest(e)

else:

# The number of copied bytes can be less than

# the number of bytes originally requested.

self.assertIn(i, range(0, bytes_to_copy+1));

with open(TESTFN4, 'rb') as in_file:

read = in_file.read()

# seeked bytes (5) are zero'ed

self.assertEqual(read[:out_seek], b'\x00'*out_seek)

# 012 are skipped (in_skip)

# 345678 are copied in the file (in_skip + bytes_to_copy)

self.assertEqual(read[out_seek:],

data[in_skip:in_skip+i])

@unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')

def test_splice_invalid_values(self):

with self.assertRaises(ValueError):

os.splice(0, 1, -10)

@unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')

@requires_splice_pipe

def test_splice(self):

TESTFN2 = os_helper.TESTFN + ".3"

data = b'0123456789'

create_file(os_helper.TESTFN, data)

self.addCleanup(os_helper.unlink, os_helper.TESTFN)

in_file = open(os_helper.TESTFN, 'rb')

self.addCleanup(in_file.close)

in_fd = in_file.fileno()

read_fd, write_fd = os.pipe()

self.addCleanup(lambda: os.close(read_fd))

self.addCleanup(lambda: os.close(write_fd))

try:

i = os.splice(in_fd, write_fd, 5)

except OSError as e:

# Handle the case in which Python was compiled

# in a system with the syscall but without support

# in the kernel.

if e.errno != errno.ENOSYS:

raise

self.skipTest(e)

else:

# The number of copied bytes can be less than

# the number of bytes originally requested.

self.assertIn(i, range(0, 6));

self.assertEqual(os.read(read_fd, 100), data[:i])

@unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')

@requires_splice_pipe

def test_splice_offset_in(self):

TESTFN4 = os_helper.TESTFN + ".4"

data = b'0123456789'

bytes_to_copy = 6

in_skip = 3

create_file(os_helper.TESTFN, data)

self.addCleanup(os_helper.unlink, os_helper.TESTFN)

in_file = open(os_helper.TESTFN, 'rb')

self.addCleanup(in_file.close)

in_fd = in_file.fileno()

read_fd, write_fd = os.pipe()

self.addCleanup(lambda: os.close(read_fd))

self.addCleanup(lambda: os.close(write_fd))

try:

i = os.splice(in_fd, write_fd, bytes_to_copy, offset_src=in_skip)

except OSError as e:

# Handle the case in which Python was compiled

# in a system with the syscall but without support

# in the kernel.

if e.errno != errno.ENOSYS:

raise

self.skipTest(e)

else:

# The number of copied bytes can be less than

# the number of bytes originally requested.

self.assertIn(i, range(0, bytes_to_copy+1));

read = os.read(read_fd, 100)

# 012 are skipped (in_skip)

# 345678 are copied in the file (in_skip + bytes_to_copy)

self.assertEqual(read, data[in_skip:in_skip+i])

@unittest.skipUnless(hasattr(os, 'splice'), 'test needs os.splice()')

@requires_splice_pipe

def test_splice_offset_out(self):

TESTFN4 = os_helper.TESTFN + ".4"

data = b'0123456789'

bytes_to_copy = 6

out_seek = 3

create_file(os_helper.TESTFN, data)

self.addCleanup(os_helper.unlink, os_helper.TESTFN)

read_fd, write_fd = os.pipe()

self.addCleanup(lambda: os.close(read_fd))

self.addCleanup(lambda: os.close(write_fd))

os.write(write_fd, data)

out_file = open(TESTFN4, 'w+b')

self.addCleanup(os_helper.unlink, TESTFN4)

self.addCleanup(out_file.close)

out_fd = out_file.fileno()

try:

i = os.splice(read_fd, out_fd, bytes_to_copy, offset_dst=out_seek)

except OSError as e:

# Handle the case in which Python was compiled

# in a system with the syscall but without support

# in the kernel.

if e.errno != errno.ENOSYS:

raise

self.skipTest(e)

else:

# The number of copied bytes can be less than

# the number of bytes originally requested.

self.assertIn(i, range(0, bytes_to_copy+1));

with open(TESTFN4, 'rb') as in_file:

read = in_file.read()

# seeked bytes (5) are zero'ed

self.assertEqual(read[:out_seek], b'\x00'*out_seek)

# 012 are skipped (in_skip)

# 345678 are copied in the file (in_skip + bytes_to_copy)

def setUp(self):

self.fname = os_helper.TESTFN

self.addCleanup(os_helper.unlink, self.fname)

create_file(self.fname, b"ABC")

def check_stat_attributes(self, fname):

result = os.stat(fname)

# Make sure direct access works

self.assertEqual(result[stat.ST_SIZE], 3)

self.assertEqual(result.st_size, 3)

# Make sure all the attributes are there

members = dir(result)

for name in dir(stat):

if name[:3] == 'ST_':

attr = name.lower()

if name.endswith("TIME"):

def trunc(x): return int(x)

else:

def trunc(x): return x

self.assertEqual(trunc(getattr(result, attr)),

result[getattr(stat, name)])

self.assertIn(attr, members)

# Make sure that the st_?time and st_?time_ns fields roughly agree

# (they should always agree up to around tens-of-microseconds)

for name in 'st_atime st_mtime st_ctime'.split():

floaty = int(getattr(result, name) * 100000)

nanosecondy = getattr(result, name + "_ns") // 10000

self.assertAlmostEqual(floaty, nanosecondy, delta=2)

# Ensure both birthtime and birthtime_ns roughly agree, if present

try:

floaty = int(result.st_birthtime * 100000)

nanosecondy = result.st_birthtime_ns // 10000

except AttributeError:

pass

else:

self.assertAlmostEqual(floaty, nanosecondy, delta=2)

try:

result[200]

self.fail("No exception raised")

except IndexError:

pass

# Make sure that assignment fails

try:

result.st_mode = 1

self.fail("No exception raised")

except AttributeError:

pass

try:

result.st_rdev = 1

self.fail("No exception raised")

except (AttributeError, TypeError):

pass

try:

result.parrot = 1

self.fail("No exception raised")

except AttributeError:

pass

# Use the stat_result constructor with a too-short tuple.

try:

result2 = os.stat_result((10,))

self.fail("No exception raised")

except TypeError:

pass

# Use the constructor with a too-long tuple.

try:

result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))

except TypeError:

pass

def test_stat_attributes(self):

self.check_stat_attributes(self.fname)

def test_stat_attributes_bytes(self):

try:

fname = self.fname.encode(sys.getfilesystemencoding())

except UnicodeEncodeError:

self.skipTest("cannot encode %a for the filesystem" % self.fname)

self.check_stat_attributes(fname)

def test_stat_result_pickle(self):

result = os.stat(self.fname)

for proto in range(pickle.HIGHEST_PROTOCOL + 1):

with self.subTest(f'protocol {proto}'):

p = pickle.dumps(result, proto)

self.assertIn(b'stat_result', p)

if proto < 4:

self.assertIn(b'cos\nstat_result\n', p)

unpickled = pickle.loads(p)

self.assertEqual(result, unpickled)

@unittest.skipUnless(hasattr(os, 'statvfs'), 'test needs os.statvfs()')

def test_statvfs_attributes(self):

result = os.statvfs(self.fname)

# Make sure direct access works

self.assertEqual(result.f_bfree, result[3])

# Make sure all the attributes are there.

members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files',

'ffree', 'favail', 'flag', 'namemax')

for value, member in enumerate(members):

self.assertEqual(getattr(result, 'f_' + member), result[value])

self.assertTrue(isinstance(result.f_fsid, int))

# Test that the size of the tuple doesn't change

self.assertEqual(len(result), 10)

# Make sure that assignment really fails

try:

result.f_bfree = 1

self.fail("No exception raised")

except AttributeError:

pass

try:

result.parrot = 1

self.fail("No exception raised")

except AttributeError:

pass

# Use the constructor with a too-short tuple.

try:

result2 = os.statvfs_result((10,))

self.fail("No exception raised")

except TypeError:

pass

# Use the constructor with a too-long tuple.

try:

result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))

except TypeError:

pass

@unittest.skipUnless(hasattr(os, 'statvfs'),

def test_statvfs_result_pickle(self):

result = os.statvfs(self.fname)

for proto in range(pickle.HIGHEST_PROTOCOL + 1):

p = pickle.dumps(result, proto)

self.assertIn(b'statvfs_result', p)

if proto < 4:

self.assertIn(b'cos\nstatvfs_result\n', p)

unpickled = pickle.loads(p)

self.assertEqual(result, unpickled)

@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")

def test_1686475(self):

# Verify that an open file can be stat'ed

try:

os.stat(r"c:\pagefile.sys")

except FileNotFoundError:

self.skipTest(r'c:\pagefile.sys does not exist')

except OSError as e:

self.fail("Could not stat pagefile.sys")

@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")

@unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")

def test_15261(self):

# Verify that stat'ing a closed fd does not cause crash

r, w = os.pipe()

try:

os.stat(r) # should not raise error

finally:

os.close(r)

os.close(w)

with self.assertRaises(OSError) as ctx:

os.stat(r)

self.assertEqual(ctx.exception.errno, errno.EBADF)

def check_file_attributes(self, result):

self.assertTrue(hasattr(result, 'st_file_attributes'))

self.assertTrue(isinstance(result.st_file_attributes, int))

self.assertTrue(0 <= result.st_file_attributes <= 0xFFFFFFFF)

@unittest.skipUnless(sys.platform == "win32",

def test_file_attributes(self):

# test file st_file_attributes (FILE_ATTRIBUTE_DIRECTORY not set)

result = os.stat(self.fname)

self.check_file_attributes(result)

self.assertEqual(

result.st_file_attributes & stat.FILE_ATTRIBUTE_DIRECTORY,

0)

# test directory st_file_attributes (FILE_ATTRIBUTE_DIRECTORY set)

dirname = os_helper.TESTFN + "dir"

os.mkdir(dirname)

self.addCleanup(os.rmdir, dirname)

result = os.stat(dirname)

self.check_file_attributes(result)

self.assertEqual(

result.st_file_attributes & stat.FILE_ATTRIBUTE_DIRECTORY,

stat.FILE_ATTRIBUTE_DIRECTORY)

@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")

def test_access_denied(self):

# Default to FindFirstFile WIN32_FIND_DATA when access is

# denied. See issue 28075.

# os.environ['TEMP'] should be located on a volume that

# supports file ACLs.

fname = os.path.join(os.environ['TEMP'], self.fname + "_access")

self.addCleanup(os_helper.unlink, fname)

create_file(fname, b'ABC')

# Deny the right to [S]YNCHRONIZE on the file to

# force CreateFile to fail with ERROR_ACCESS_DENIED.

DETACHED_PROCESS = 8

subprocess.check_call(

# bpo-30584: Use security identifier *S-1-5-32-545 instead

# of localized "Users" to not depend on the locale.

['icacls.exe', fname, '/deny', '*S-1-5-32-545:(S)'],

creationflags=DETACHED_PROCESS

)

result = os.stat(fname)

self.assertNotEqual(result.st_size, 0)

self.assertTrue(os.path.isfile(fname))

@unittest.skipUnless(sys.platform == "win32", "Win32 specific tests")

def test_stat_block_device(self):

# bpo-38030: os.stat fails for block devices

# Test a filename like "//./C:"

fname = "//./" + os.path.splitdrive(os.getcwd())[0]

result = os.stat(fname)

def setUp(self):

self.dirname = os_helper.TESTFN

self.fname = os.path.join(self.dirname, "f1")

self.addCleanup(os_helper.rmtree, self.dirname)

os.mkdir(self.dirname)

create_file(self.fname)

def support_subsecond(self, filename):

# Heuristic to check if the filesystem supports timestamp with

# subsecond resolution: check if float and int timestamps are different

st = os.stat(filename)

return ((st.st_atime != st[7])

or (st.st_mtime != st[8])

or (st.st_ctime != st[9]))

def _test_utime(self, set_time, filename=None):

if not filename:

filename = self.fname

support_subsecond = self.support_subsecond(filename)

if support_subsecond:

# Timestamp with a resolution of 1 microsecond (10^-6).

#

# The resolution of the C internal function used by os.utime()

# depends on the platform: 1 sec, 1 us, 1 ns. Writing a portable

# test with a resolution of 1 ns requires more work:

# see the issue #15745.

atime_ns = 1002003000 # 1.002003 seconds

mtime_ns = 4005006000 # 4.005006 seconds

else:

# use a resolution of 1 second

atime_ns = 5 * 10**9

mtime_ns = 8 * 10**9

set_time(filename, (atime_ns, mtime_ns))

st = os.stat(filename)

if support_subsecond:

self.assertAlmostEqual(st.st_atime, atime_ns * 1e-9, delta=1e-6)

self.assertAlmostEqual(st.st_mtime, mtime_ns * 1e-9, delta=1e-6)

else:

self.assertEqual(st.st_atime, atime_ns * 1e-9)

self.assertEqual(st.st_mtime, mtime_ns * 1e-9)

self.assertEqual(st.st_atime_ns, atime_ns)

self.assertEqual(st.st_mtime_ns, mtime_ns)

def test_utime(self):

def set_time(filename, ns):

# test the ns keyword parameter

os.utime(filename, ns=ns)

self._test_utime(set_time)

@staticmethod

def ns_to_sec(ns):

# Convert a number of nanosecond (int) to a number of seconds (float).

# Round towards infinity by adding 0.5 nanosecond to avoid rounding

# issue, os.utime() rounds towards minus infinity.

return (ns * 1e-9) + 0.5e-9

def test_utime_by_indexed(self):

# pass times as floating point seconds as the second indexed parameter

def set_time(filename, ns):

atime_ns, mtime_ns = ns

atime = self.ns_to_sec(atime_ns)

mtime = self.ns_to_sec(mtime_ns)

# test utimensat(timespec), utimes(timeval), utime(utimbuf)

# or utime(time_t)

os.utime(filename, (atime, mtime))

self._test_utime(set_time)

def test_utime_by_times(self):

def set_time(filename, ns):

atime_ns, mtime_ns = ns

atime = self.ns_to_sec(atime_ns)

mtime = self.ns_to_sec(mtime_ns)

# test the times keyword parameter

os.utime(filename, times=(atime, mtime))

self._test_utime(set_time)

@unittest.skipUnless(os.utime in os.supports_follow_symlinks,

def test_utime_nofollow_symlinks(self):

def set_time(filename, ns):

# use follow_symlinks=False to test utimensat(timespec)

# or lutimes(timeval)

os.utime(filename, ns=ns, follow_symlinks=False)

self._test_utime(set_time)

@unittest.skipUnless(os.utime in os.supports_fd,

def test_utime_fd(self):

def set_time(filename, ns):

with open(filename, 'wb', 0) as fp:

# use a file descriptor to test futimens(timespec)

# or futimes(timeval)

os.utime(fp.fileno(), ns=ns)

self._test_utime(set_time)

@unittest.skipUnless(os.utime in os.supports_dir_fd,

def test_utime_dir_fd(self):

def set_time(filename, ns):

dirname, name = os.path.split(filename)

with os_helper.open_dir_fd(dirname) as dirfd:

# pass dir_fd to test utimensat(timespec) or futimesat(timeval)

os.utime(name, dir_fd=dirfd, ns=ns)

self._test_utime(set_time)

def test_utime_directory(self):

def set_time(filename, ns):

# test calling os.utime() on a directory

os.utime(filename, ns=ns)

self._test_utime(set_time, filename=self.dirname)

def _test_utime_current(self, set_time):

# Get the system clock

current = time.time()

# Call os.utime() to set the timestamp to the current system clock

set_time(self.fname)

if not self.support_subsecond(self.fname):

delta = 1.0

else:

# On Windows, the usual resolution of time.time() is 15.6 ms.

# bpo-30649: Tolerate 50 ms for slow Windows buildbots.

#

# x86 Gentoo Refleaks 3.x once failed with dt=20.2 ms. So use

# also 50 ms on other platforms.

delta = 0.050

st = os.stat(self.fname)

msg = ("st_time=%r, current=%r, dt=%r"

% (st.st_mtime, current, st.st_mtime - current))

self.assertAlmostEqual(st.st_mtime, current,

delta=delta, msg=msg)

def test_utime_current(self):

def set_time(filename):

# Set to the current time in the new way

os.utime(self.fname)

self._test_utime_current(set_time)

def test_utime_current_old(self):

def set_time(filename):

# Set to the current time in the old explicit way.

os.utime(self.fname, None)

self._test_utime_current(set_time)

def get_file_system(self, path):

if sys.platform == 'win32':

root = os.path.splitdrive(os.path.abspath(path))[0] + '\\'

import ctypes

kernel32 = ctypes.windll.kernel32

buf = ctypes.create_unicode_buffer("", 100)

ok = kernel32.GetVolumeInformationW(root, None, 0,

None, None, None,

buf, len(buf))

if ok:

return buf.value

# return None if the filesystem is unknown

def test_large_time(self):

# Many filesystems are limited to the year 2038. At least, the test

# pass with NTFS filesystem.

if self.get_file_system(self.dirname) != "NTFS":

self.skipTest("requires NTFS")

large = 5000000000 # some day in 2128

os.utime(self.fname, (large, large))

self.assertEqual(os.stat(self.fname).st_mtime, large)

def test_utime_invalid_arguments(self):

# seconds and nanoseconds parameters are mutually exclusive

with self.assertRaises(ValueError):

os.utime(self.fname, (5, 5), ns=(5, 5))

with self.assertRaises(TypeError):

os.utime(self.fname, [5, 5])

with self.assertRaises(TypeError):

os.utime(self.fname, (5,))

with self.assertRaises(TypeError):

os.utime(self.fname, (5, 5, 5))

with self.assertRaises(TypeError):

os.utime(self.fname, ns=[5, 5])

with self.assertRaises(TypeError):

os.utime(self.fname, ns=(5,))

with self.assertRaises(TypeError):

os.utime(self.fname, ns=(5, 5, 5))

if os.utime not in os.supports_follow_symlinks:

with self.assertRaises(NotImplementedError):

os.utime(self.fname, (5, 5), follow_symlinks=False)

if os.utime not in os.supports_fd:

with open(self.fname, 'wb', 0) as fp:

with self.assertRaises(TypeError):

os.utime(fp.fileno(), (5, 5))

if os.utime not in os.supports_dir_fd:

with self.assertRaises(NotImplementedError):

os.utime(self.fname, (5, 5), dir_fd=0)

@support.cpython_only

def test_issue31577(self):

# The interpreter shouldn't crash in case utime() received a bad

# ns argument.

def get_bad_int(divmod_ret_val):

class BadInt:

def __divmod__(*args):

return divmod_ret_val

return BadInt()

with self.assertRaises(TypeError):

os.utime(self.fname, ns=(get_bad_int(42), 1))

with self.assertRaises(TypeError):

os.utime(self.fname, ns=(get_bad_int(()), 1))

with self.assertRaises(TypeError):

"""check that os.environ object conform to mapping protocol"""

type2test = None

def setUp(self):

self.__save = dict(os.environ)

if os.supports_bytes_environ:

self.__saveb = dict(os.environb)

for key, value in self._reference().items():

os.environ[key] = value

def tearDown(self):

os.environ.clear()

os.environ.update(self.__save)

if os.supports_bytes_environ: