| # As a test suite for the os module, this is woefully inadequate, but this |
| # does add tests for a few functions which have been determined to be more |
| # portable than they had been thought to be. |
| |
| import os |
| import errno |
| import unittest |
| import warnings |
| import sys |
| import signal |
| import subprocess |
| import time |
| import shutil |
| from test import support |
| import contextlib |
| import mmap |
| import uuid |
| import asyncore |
| import asynchat |
| import socket |
| try: |
| import threading |
| except ImportError: |
| threading = None |
| |
| # Detect whether we're on a Linux system that uses the (now outdated |
| # and unmaintained) linuxthreads threading library. There's an issue |
| # when combining linuxthreads with a failed execv call: see |
| # http://bugs.python.org/issue4970. |
| if hasattr(sys, 'thread_info') and sys.thread_info.version: |
| USING_LINUXTHREADS = sys.thread_info.version.startswith("linuxthreads") |
| else: |
| USING_LINUXTHREADS = False |
| |
| # Tests creating TESTFN |
| class FileTests(unittest.TestCase): |
| def setUp(self): |
| if os.path.exists(support.TESTFN): |
| os.unlink(support.TESTFN) |
| tearDown = setUp |
| |
| def test_access(self): |
| f = os.open(support.TESTFN, os.O_CREAT|os.O_RDWR) |
| os.close(f) |
| self.assertTrue(os.access(support.TESTFN, os.W_OK)) |
| |
| def test_closerange(self): |
| first = os.open(support.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 = support.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(support.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") |
| |
| def test_write(self): |
| # os.write() accepts bytes- and buffer-like objects but not strings |
| fd = os.open(support.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(support.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', |
| 'test specific to the Windows console') |
| 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) |
| |
| |
| class TemporaryFileTests(unittest.TestCase): |
| def setUp(self): |
| self.files = [] |
| os.mkdir(support.TESTFN) |
| |
| def tearDown(self): |
| for name in self.files: |
| os.unlink(name) |
| os.rmdir(support.TESTFN) |
| |
| def check_tempfile(self, name): |
| # make sure it doesn't already exist: |
| self.assertFalse(os.path.exists(name), |
| "file already exists for temporary file") |
| # make sure we can create the file |
| open(name, "w") |
| self.files.append(name) |
| |
| def test_tempnam(self): |
| if not hasattr(os, "tempnam"): |
| return |
| warnings.filterwarnings("ignore", "tempnam", RuntimeWarning, |
| r"test_os$") |
| self.check_tempfile(os.tempnam()) |
| |
| name = os.tempnam(support.TESTFN) |
| self.check_tempfile(name) |
| |
| name = os.tempnam(support.TESTFN, "pfx") |
| self.assertTrue(os.path.basename(name)[:3] == "pfx") |
| self.check_tempfile(name) |
| |
| def test_tmpfile(self): |
| if not hasattr(os, "tmpfile"): |
| return |
| # As with test_tmpnam() below, the Windows implementation of tmpfile() |
| # attempts to create a file in the root directory of the current drive. |
| # On Vista and Server 2008, this test will always fail for normal users |
| # as writing to the root directory requires elevated privileges. With |
| # XP and below, the semantics of tmpfile() are the same, but the user |
| # running the test is more likely to have administrative privileges on |
| # their account already. If that's the case, then os.tmpfile() should |
| # work. In order to make this test as useful as possible, rather than |
| # trying to detect Windows versions or whether or not the user has the |
| # right permissions, just try and create a file in the root directory |
| # and see if it raises a 'Permission denied' OSError. If it does, then |
| # test that a subsequent call to os.tmpfile() raises the same error. If |
| # it doesn't, assume we're on XP or below and the user running the test |
| # has administrative privileges, and proceed with the test as normal. |
| if sys.platform == 'win32': |
| name = '\\python_test_os_test_tmpfile.txt' |
| if os.path.exists(name): |
| os.remove(name) |
| try: |
| fp = open(name, 'w') |
| except IOError as first: |
| # open() failed, assert tmpfile() fails in the same way. |
| # Although open() raises an IOError and os.tmpfile() raises an |
| # OSError(), 'args' will be (13, 'Permission denied') in both |
| # cases. |
| try: |
| fp = os.tmpfile() |
| except OSError as second: |
| self.assertEqual(first.args, second.args) |
| else: |
| self.fail("expected os.tmpfile() to raise OSError") |
| return |
| else: |
| # open() worked, therefore, tmpfile() should work. Close our |
| # dummy file and proceed with the test as normal. |
| fp.close() |
| os.remove(name) |
| |
| fp = os.tmpfile() |
| fp.write("foobar") |
| fp.seek(0,0) |
| s = fp.read() |
| fp.close() |
| self.assertTrue(s == "foobar") |
| |
| def test_tmpnam(self): |
| if not hasattr(os, "tmpnam"): |
| return |
| warnings.filterwarnings("ignore", "tmpnam", RuntimeWarning, |
| r"test_os$") |
| name = os.tmpnam() |
| if sys.platform in ("win32",): |
| # The Windows tmpnam() seems useless. From the MS docs: |
| # |
| # The character string that tmpnam creates consists of |
| # the path prefix, defined by the entry P_tmpdir in the |
| # file STDIO.H, followed by a sequence consisting of the |
| # digit characters '0' through '9'; the numerical value |
| # of this string is in the range 1 - 65,535. Changing the |
| # definitions of L_tmpnam or P_tmpdir in STDIO.H does not |
| # change the operation of tmpnam. |
| # |
| # The really bizarre part is that, at least under MSVC6, |
| # P_tmpdir is "\\". That is, the path returned refers to |
| # the root of the current drive. That's a terrible place to |
| # put temp files, and, depending on privileges, the user |
| # may not even be able to open a file in the root directory. |
| self.assertFalse(os.path.exists(name), |
| "file already exists for temporary file") |
| else: |
| self.check_tempfile(name) |
| |
| def fdopen_helper(self, *args): |
| fd = os.open(support.TESTFN, os.O_RDONLY) |
| fp2 = os.fdopen(fd, *args) |
| fp2.close() |
| |
| def test_fdopen(self): |
| self.fdopen_helper() |
| self.fdopen_helper('r') |
| self.fdopen_helper('r', 100) |
| |
| # Test attributes on return values from os.*stat* family. |
| class StatAttributeTests(unittest.TestCase): |
| def setUp(self): |
| os.mkdir(support.TESTFN) |
| self.fname = os.path.join(support.TESTFN, "f1") |
| f = open(self.fname, 'wb') |
| f.write(b"ABC") |
| f.close() |
| |
| def tearDown(self): |
| os.unlink(self.fname) |
| os.rmdir(support.TESTFN) |
| |
| def check_stat_attributes(self, fname): |
| if not hasattr(os, "stat"): |
| return |
| |
| import stat |
| 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) |
| |
| try: |
| result[200] |
| self.fail("No exception thrown") |
| except IndexError: |
| pass |
| |
| # Make sure that assignment fails |
| try: |
| result.st_mode = 1 |
| self.fail("No exception thrown") |
| except AttributeError: |
| pass |
| |
| try: |
| result.st_rdev = 1 |
| self.fail("No exception thrown") |
| except (AttributeError, TypeError): |
| pass |
| |
| try: |
| result.parrot = 1 |
| self.fail("No exception thrown") |
| except AttributeError: |
| pass |
| |
| # Use the stat_result constructor with a too-short tuple. |
| try: |
| result2 = os.stat_result((10,)) |
| self.fail("No exception thrown") |
| 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_statvfs_attributes(self): |
| if not hasattr(os, "statvfs"): |
| return |
| |
| try: |
| result = os.statvfs(self.fname) |
| except OSError as e: |
| # On AtheOS, glibc always returns ENOSYS |
| if e.errno == errno.ENOSYS: |
| return |
| |
| # 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]) |
| |
| # Make sure that assignment really fails |
| try: |
| result.f_bfree = 1 |
| self.fail("No exception thrown") |
| except AttributeError: |
| pass |
| |
| try: |
| result.parrot = 1 |
| self.fail("No exception thrown") |
| except AttributeError: |
| pass |
| |
| # Use the constructor with a too-short tuple. |
| try: |
| result2 = os.statvfs_result((10,)) |
| self.fail("No exception thrown") |
| 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 |
| |
| def test_utime_dir(self): |
| delta = 1000000 |
| st = os.stat(support.TESTFN) |
| # round to int, because some systems may support sub-second |
| # time stamps in stat, but not in utime. |
| os.utime(support.TESTFN, (st.st_atime, int(st.st_mtime-delta))) |
| st2 = os.stat(support.TESTFN) |
| self.assertEqual(st2.st_mtime, int(st.st_mtime-delta)) |
| |
| # Restrict test to Win32, since there is no guarantee other |
| # systems support centiseconds |
| if sys.platform == 'win32': |
| def get_file_system(path): |
| root = os.path.splitdrive(os.path.abspath(path))[0] + '\\' |
| import ctypes |
| kernel32 = ctypes.windll.kernel32 |
| buf = ctypes.create_unicode_buffer("", 100) |
| if kernel32.GetVolumeInformationW(root, None, 0, None, None, None, buf, len(buf)): |
| return buf.value |
| |
| if get_file_system(support.TESTFN) == "NTFS": |
| def test_1565150(self): |
| t1 = 1159195039.25 |
| os.utime(self.fname, (t1, t1)) |
| self.assertEqual(os.stat(self.fname).st_mtime, t1) |
| |
| def test_large_time(self): |
| t1 = 5000000000 # some day in 2128 |
| os.utime(self.fname, (t1, t1)) |
| self.assertEqual(os.stat(self.fname).st_mtime, t1) |
| |
| def test_1686475(self): |
| # Verify that an open file can be stat'ed |
| try: |
| os.stat(r"c:\pagefile.sys") |
| except WindowsError as e: |
| if e.errno == 2: # file does not exist; cannot run test |
| return |
| self.fail("Could not stat pagefile.sys") |
| |
| from test import mapping_tests |
| |
| class EnvironTests(mapping_tests.BasicTestMappingProtocol): |
| """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: |
| os.environb.clear() |
| os.environb.update(self.__saveb) |
| |
| def _reference(self): |
| return {"KEY1":"VALUE1", "KEY2":"VALUE2", "KEY3":"VALUE3"} |
| |
| def _empty_mapping(self): |
| os.environ.clear() |
| return os.environ |
| |
| # Bug 1110478 |
| def test_update2(self): |
| os.environ.clear() |
| if os.path.exists("/bin/sh"): |
| os.environ.update(HELLO="World") |
| with os.popen("/bin/sh -c 'echo $HELLO'") as popen: |
| value = popen.read().strip() |
| self.assertEqual(value, "World") |
| |
| def test_os_popen_iter(self): |
| if os.path.exists("/bin/sh"): |
| with os.popen( |
| "/bin/sh -c 'echo \"line1\nline2\nline3\"'") as popen: |
| it = iter(popen) |
| self.assertEqual(next(it), "line1\n") |
| self.assertEqual(next(it), "line2\n") |
| self.assertEqual(next(it), "line3\n") |
| self.assertRaises(StopIteration, next, it) |
| |
| # Verify environ keys and values from the OS are of the |
| # correct str type. |
| def test_keyvalue_types(self): |
| for key, val in os.environ.items(): |
| self.assertEqual(type(key), str) |
| self.assertEqual(type(val), str) |
| |
| def test_items(self): |
| for key, value in self._reference().items(): |
| self.assertEqual(os.environ.get(key), value) |
| |
| # Issue 7310 |
| def test___repr__(self): |
| """Check that the repr() of os.environ looks like environ({...}).""" |
| env = os.environ |
| self.assertEqual(repr(env), 'environ({{{}}})'.format(', '.join( |
| '{!r}: {!r}'.format(key, value) |
| for key, value in env.items()))) |
| |
| def test_get_exec_path(self): |
| defpath_list = os.defpath.split(os.pathsep) |
| test_path = ['/monty', '/python', '', '/flying/circus'] |
| test_env = {'PATH': os.pathsep.join(test_path)} |
| |
| saved_environ = os.environ |
| try: |
| os.environ = dict(test_env) |
| # Test that defaulting to os.environ works. |
| self.assertSequenceEqual(test_path, os.get_exec_path()) |
| self.assertSequenceEqual(test_path, os.get_exec_path(env=None)) |
| finally: |
| os.environ = saved_environ |
| |
| # No PATH environment variable |
| self.assertSequenceEqual(defpath_list, os.get_exec_path({})) |
| # Empty PATH environment variable |
| self.assertSequenceEqual(('',), os.get_exec_path({'PATH':''})) |
| # Supplied PATH environment variable |
| self.assertSequenceEqual(test_path, os.get_exec_path(test_env)) |
| |
| if os.supports_bytes_environ: |
| # env cannot contain 'PATH' and b'PATH' keys |
| try: |
| # ignore BytesWarning warning |
| with warnings.catch_warnings(record=True): |
| mixed_env = {'PATH': '1', b'PATH': b'2'} |
| except BytesWarning: |
| # mixed_env cannot be created with python -bb |
| pass |
| else: |
| self.assertRaises(ValueError, os.get_exec_path, mixed_env) |
| |
| # bytes key and/or value |
| self.assertSequenceEqual(os.get_exec_path({b'PATH': b'abc'}), |
| ['abc']) |
| self.assertSequenceEqual(os.get_exec_path({b'PATH': 'abc'}), |
| ['abc']) |
| self.assertSequenceEqual(os.get_exec_path({'PATH': b'abc'}), |
| ['abc']) |
| |
| @unittest.skipUnless(os.supports_bytes_environ, |
| "os.environb required for this test.") |
| def test_environb(self): |
| # os.environ -> os.environb |
| value = 'euro\u20ac' |
| try: |
| value_bytes = value.encode(sys.getfilesystemencoding(), |
| 'surrogateescape') |
| except UnicodeEncodeError: |
| msg = "U+20AC character is not encodable to %s" % ( |
| sys.getfilesystemencoding(),) |
| self.skipTest(msg) |
| os.environ['unicode'] = value |
| self.assertEqual(os.environ['unicode'], value) |
| self.assertEqual(os.environb[b'unicode'], value_bytes) |
| |
| # os.environb -> os.environ |
| value = b'\xff' |
| os.environb[b'bytes'] = value |
| self.assertEqual(os.environb[b'bytes'], value) |
| value_str = value.decode(sys.getfilesystemencoding(), 'surrogateescape') |
| self.assertEqual(os.environ['bytes'], value_str) |
| |
| class WalkTests(unittest.TestCase): |
| """Tests for os.walk().""" |
| |
| def test_traversal(self): |
| import os |
| from os.path import join |
| |
| # Build: |
| # TESTFN/ |
| # TEST1/ a file kid and two directory kids |
| # tmp1 |
| # SUB1/ a file kid and a directory kid |
| # tmp2 |
| # SUB11/ no kids |
| # SUB2/ a file kid and a dirsymlink kid |
| # tmp3 |
| # link/ a symlink to TESTFN.2 |
| # TEST2/ |
| # tmp4 a lone file |
| walk_path = join(support.TESTFN, "TEST1") |
| sub1_path = join(walk_path, "SUB1") |
| sub11_path = join(sub1_path, "SUB11") |
| sub2_path = join(walk_path, "SUB2") |
| tmp1_path = join(walk_path, "tmp1") |
| tmp2_path = join(sub1_path, "tmp2") |
| tmp3_path = join(sub2_path, "tmp3") |
| link_path = join(sub2_path, "link") |
| t2_path = join(support.TESTFN, "TEST2") |
| tmp4_path = join(support.TESTFN, "TEST2", "tmp4") |
| |
| # Create stuff. |
| os.makedirs(sub11_path) |
| os.makedirs(sub2_path) |
| os.makedirs(t2_path) |
| for path in tmp1_path, tmp2_path, tmp3_path, tmp4_path: |
| f = open(path, "w") |
| f.write("I'm " + path + " and proud of it. Blame test_os.\n") |
| f.close() |
| if support.can_symlink(): |
| os.symlink(os.path.abspath(t2_path), link_path) |
| sub2_tree = (sub2_path, ["link"], ["tmp3"]) |
| else: |
| sub2_tree = (sub2_path, [], ["tmp3"]) |
| |
| # Walk top-down. |
| all = list(os.walk(walk_path)) |
| self.assertEqual(len(all), 4) |
| # We can't know which order SUB1 and SUB2 will appear in. |
| # Not flipped: TESTFN, SUB1, SUB11, SUB2 |
| # flipped: TESTFN, SUB2, SUB1, SUB11 |
| flipped = all[0][1][0] != "SUB1" |
| all[0][1].sort() |
| self.assertEqual(all[0], (walk_path, ["SUB1", "SUB2"], ["tmp1"])) |
| self.assertEqual(all[1 + flipped], (sub1_path, ["SUB11"], ["tmp2"])) |
| self.assertEqual(all[2 + flipped], (sub11_path, [], [])) |
| self.assertEqual(all[3 - 2 * flipped], sub2_tree) |
| |
| # Prune the search. |
| all = [] |
| for root, dirs, files in os.walk(walk_path): |
| all.append((root, dirs, files)) |
| # Don't descend into SUB1. |
| if 'SUB1' in dirs: |
| # Note that this also mutates the dirs we appended to all! |
| dirs.remove('SUB1') |
| self.assertEqual(len(all), 2) |
| self.assertEqual(all[0], (walk_path, ["SUB2"], ["tmp1"])) |
| self.assertEqual(all[1], sub2_tree) |
| |
| # Walk bottom-up. |
| all = list(os.walk(walk_path, topdown=False)) |
| self.assertEqual(len(all), 4) |
| # We can't know which order SUB1 and SUB2 will appear in. |
| # Not flipped: SUB11, SUB1, SUB2, TESTFN |
| # flipped: SUB2, SUB11, SUB1, TESTFN |
| flipped = all[3][1][0] != "SUB1" |
| all[3][1].sort() |
| self.assertEqual(all[3], (walk_path, ["SUB1", "SUB2"], ["tmp1"])) |
| self.assertEqual(all[flipped], (sub11_path, [], [])) |
| self.assertEqual(all[flipped + 1], (sub1_path, ["SUB11"], ["tmp2"])) |
| self.assertEqual(all[2 - 2 * flipped], sub2_tree) |
| |
| if support.can_symlink(): |
| # Walk, following symlinks. |
| for root, dirs, files in os.walk(walk_path, followlinks=True): |
| if root == link_path: |
| self.assertEqual(dirs, []) |
| self.assertEqual(files, ["tmp4"]) |
| break |
| else: |
| self.fail("Didn't follow symlink with followlinks=True") |
| |
| def tearDown(self): |
| # Tear everything down. This is a decent use for bottom-up on |
| # Windows, which doesn't have a recursive delete command. The |
| # (not so) subtlety is that rmdir will fail unless the dir's |
| # kids are removed first, so bottom up is essential. |
| for root, dirs, files in os.walk(support.TESTFN, topdown=False): |
| for name in files: |
| os.remove(os.path.join(root, name)) |
| for name in dirs: |
| dirname = os.path.join(root, name) |
| if not os.path.islink(dirname): |
| os.rmdir(dirname) |
| else: |
| os.remove(dirname) |
| os.rmdir(support.TESTFN) |
| |
| class MakedirTests(unittest.TestCase): |
| def setUp(self): |
| os.mkdir(support.TESTFN) |
| |
| def test_makedir(self): |
| base = support.TESTFN |
| path = os.path.join(base, 'dir1', 'dir2', 'dir3') |
| os.makedirs(path) # Should work |
| path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4') |
| os.makedirs(path) |
| |
| # Try paths with a '.' in them |
| self.assertRaises(OSError, os.makedirs, os.curdir) |
| path = os.path.join(base, 'dir1', 'dir2', 'dir3', 'dir4', 'dir5', os.curdir) |
| os.makedirs(path) |
| path = os.path.join(base, 'dir1', os.curdir, 'dir2', 'dir3', 'dir4', |
| 'dir5', 'dir6') |
| os.makedirs(path) |
| |
| def test_exist_ok_existing_directory(self): |
| path = os.path.join(support.TESTFN, 'dir1') |
| mode = 0o777 |
| old_mask = os.umask(0o022) |
| os.makedirs(path, mode) |
| self.assertRaises(OSError, os.makedirs, path, mode) |
| self.assertRaises(OSError, os.makedirs, path, mode, exist_ok=False) |
| self.assertRaises(OSError, os.makedirs, path, 0o776, exist_ok=True) |
| os.makedirs(path, mode=mode, exist_ok=True) |
| os.umask(old_mask) |
| |
| def test_exist_ok_existing_regular_file(self): |
| base = support.TESTFN |
| path = os.path.join(support.TESTFN, 'dir1') |
| f = open(path, 'w') |
| f.write('abc') |
| f.close() |
| self.assertRaises(OSError, os.makedirs, path) |
| self.assertRaises(OSError, os.makedirs, path, exist_ok=False) |
| self.assertRaises(OSError, os.makedirs, path, exist_ok=True) |
| os.remove(path) |
| |
| def tearDown(self): |
| path = os.path.join(support.TESTFN, 'dir1', 'dir2', 'dir3', |
| 'dir4', 'dir5', 'dir6') |
| # If the tests failed, the bottom-most directory ('../dir6') |
| # may not have been created, so we look for the outermost directory |
| # that exists. |
| while not os.path.exists(path) and path != support.TESTFN: |
| path = os.path.dirname(path) |
| |
| os.removedirs(path) |
| |
| class DevNullTests(unittest.TestCase): |
| def test_devnull(self): |
| f = open(os.devnull, 'w') |
| f.write('hello') |
| f.close() |
| f = open(os.devnull, 'r') |
| self.assertEqual(f.read(), '') |
| f.close() |
| |
| class URandomTests(unittest.TestCase): |
| def test_urandom(self): |
| try: |
| self.assertEqual(len(os.urandom(1)), 1) |
| self.assertEqual(len(os.urandom(10)), 10) |
| self.assertEqual(len(os.urandom(100)), 100) |
| self.assertEqual(len(os.urandom(1000)), 1000) |
| except NotImplementedError: |
| pass |
| |
| @contextlib.contextmanager |
| def _execvpe_mockup(defpath=None): |
| """ |
| Stubs out execv and execve functions when used as context manager. |
| Records exec calls. The mock execv and execve functions always raise an |
| exception as they would normally never return. |
| """ |
| # A list of tuples containing (function name, first arg, args) |
| # of calls to execv or execve that have been made. |
| calls = [] |
| |
| def mock_execv(name, *args): |
| calls.append(('execv', name, args)) |
| raise RuntimeError("execv called") |
| |
| def mock_execve(name, *args): |
| calls.append(('execve', name, args)) |
| raise OSError(errno.ENOTDIR, "execve called") |
| |
| try: |
| orig_execv = os.execv |
| orig_execve = os.execve |
| orig_defpath = os.defpath |
| os.execv = mock_execv |
| os.execve = mock_execve |
| if defpath is not None: |
| os.defpath = defpath |
| yield calls |
| finally: |
| os.execv = orig_execv |
| os.execve = orig_execve |
| os.defpath = orig_defpath |
| |
| class ExecTests(unittest.TestCase): |
| @unittest.skipIf(USING_LINUXTHREADS, |
| "avoid triggering a linuxthreads bug: see issue #4970") |
| def test_execvpe_with_bad_program(self): |
| self.assertRaises(OSError, os.execvpe, 'no such app-', |
| ['no such app-'], None) |
| |
| def test_execvpe_with_bad_arglist(self): |
| self.assertRaises(ValueError, os.execvpe, 'notepad', [], None) |
| |
| @unittest.skipUnless(hasattr(os, '_execvpe'), |
| "No internal os._execvpe function to test.") |
| def _test_internal_execvpe(self, test_type): |
| program_path = os.sep + 'absolutepath' |
| if test_type is bytes: |
| program = b'executable' |
| fullpath = os.path.join(os.fsencode(program_path), program) |
| native_fullpath = fullpath |
| arguments = [b'progname', 'arg1', 'arg2'] |
| else: |
| program = 'executable' |
| arguments = ['progname', 'arg1', 'arg2'] |
| fullpath = os.path.join(program_path, program) |
| if os.name != "nt": |
| native_fullpath = os.fsencode(fullpath) |
| else: |
| native_fullpath = fullpath |
| env = {'spam': 'beans'} |
| |
| # test os._execvpe() with an absolute path |
| with _execvpe_mockup() as calls: |
| self.assertRaises(RuntimeError, |
| os._execvpe, fullpath, arguments) |
| self.assertEqual(len(calls), 1) |
| self.assertEqual(calls[0], ('execv', fullpath, (arguments,))) |
| |
| # test os._execvpe() with a relative path: |
| # os.get_exec_path() returns defpath |
| with _execvpe_mockup(defpath=program_path) as calls: |
| self.assertRaises(OSError, |
| os._execvpe, program, arguments, env=env) |
| self.assertEqual(len(calls), 1) |
| self.assertSequenceEqual(calls[0], |
| ('execve', native_fullpath, (arguments, env))) |
| |
| # test os._execvpe() with a relative path: |
| # os.get_exec_path() reads the 'PATH' variable |
| with _execvpe_mockup() as calls: |
| env_path = env.copy() |
| if test_type is bytes: |
| env_path[b'PATH'] = program_path |
| else: |
| env_path['PATH'] = program_path |
| self.assertRaises(OSError, |
| os._execvpe, program, arguments, env=env_path) |
| self.assertEqual(len(calls), 1) |
| self.assertSequenceEqual(calls[0], |
| ('execve', native_fullpath, (arguments, env_path))) |
| |
| def test_internal_execvpe_str(self): |
| self._test_internal_execvpe(str) |
| if os.name != "nt": |
| self._test_internal_execvpe(bytes) |
| |
| |
| class Win32ErrorTests(unittest.TestCase): |
| def test_rename(self): |
| self.assertRaises(WindowsError, os.rename, support.TESTFN, support.TESTFN+".bak") |
| |
| def test_remove(self): |
| self.assertRaises(WindowsError, os.remove, support.TESTFN) |
| |
| def test_chdir(self): |
| self.assertRaises(WindowsError, os.chdir, support.TESTFN) |
| |
| def test_mkdir(self): |
| f = open(support.TESTFN, "w") |
| try: |
| self.assertRaises(WindowsError, os.mkdir, support.TESTFN) |
| finally: |
| f.close() |
| os.unlink(support.TESTFN) |
| |
| def test_utime(self): |
| self.assertRaises(WindowsError, os.utime, support.TESTFN, None) |
| |
| def test_chmod(self): |
| self.assertRaises(WindowsError, os.chmod, support.TESTFN, 0) |
| |
| class TestInvalidFD(unittest.TestCase): |
| singles = ["fchdir", "dup", "fdopen", "fdatasync", "fstat", |
| "fstatvfs", "fsync", "tcgetpgrp", "ttyname"] |
| #singles.append("close") |
| #We omit close because it doesn'r raise an exception on some platforms |
| def get_single(f): |
| def helper(self): |
| if hasattr(os, f): |
| self.check(getattr(os, f)) |
| return helper |
| for f in singles: |
| locals()["test_"+f] = get_single(f) |
| |
| def check(self, f, *args): |
| try: |
| f(support.make_bad_fd(), *args) |
| except OSError as e: |
| self.assertEqual(e.errno, errno.EBADF) |
| else: |
| self.fail("%r didn't raise a OSError with a bad file descriptor" |
| % f) |
| |
| def test_isatty(self): |
| if hasattr(os, "isatty"): |
| self.assertEqual(os.isatty(support.make_bad_fd()), False) |
| |
| def test_closerange(self): |
| if hasattr(os, "closerange"): |
| fd = support.make_bad_fd() |
| # Make sure none of the descriptors we are about to close are |
| # currently valid (issue 6542). |
| for i in range(10): |
| try: os.fstat(fd+i) |
| except OSError: |
| pass |
| else: |
| break |
| if i < 2: |
| raise unittest.SkipTest( |
| "Unable to acquire a range of invalid file descriptors") |
| self.assertEqual(os.closerange(fd, fd + i-1), None) |
| |
| def test_dup2(self): |
| if hasattr(os, "dup2"): |
| self.check(os.dup2, 20) |
| |
| def test_fchmod(self): |
| if hasattr(os, "fchmod"): |
| self.check(os.fchmod, 0) |
| |
| def test_fchown(self): |
| if hasattr(os, "fchown"): |
| self.check(os.fchown, -1, -1) |
| |
| def test_fpathconf(self): |
| if hasattr(os, "fpathconf"): |
| self.check(os.fpathconf, "PC_NAME_MAX") |
| |
| def test_ftruncate(self): |
| if hasattr(os, "ftruncate"): |
| self.check(os.ftruncate, 0) |
| |
| def test_lseek(self): |
| if hasattr(os, "lseek"): |
| self.check(os.lseek, 0, 0) |
| |
| def test_read(self): |
| if hasattr(os, "read"): |
| self.check(os.read, 1) |
| |
| def test_tcsetpgrpt(self): |
| if hasattr(os, "tcsetpgrp"): |
| self.check(os.tcsetpgrp, 0) |
| |
| def test_write(self): |
| if hasattr(os, "write"): |
| self.check(os.write, b" ") |
| |
| |
| class LinkTests(unittest.TestCase): |
| def setUp(self): |
| self.file1 = support.TESTFN |
| self.file2 = os.path.join(support.TESTFN + "2") |
| |
| def tearDown(self): |
| for file in (self.file1, self.file2): |
| if os.path.exists(file): |
| os.unlink(file) |
| |
| def _test_link(self, file1, file2): |
| with open(file1, "w") as f1: |
| f1.write("test") |
| |
| os.link(file1, file2) |
| with open(file1, "r") as f1, open(file2, "r") as f2: |
| self.assertTrue(os.path.sameopenfile(f1.fileno(), f2.fileno())) |
| |
| def test_link(self): |
| self._test_link(self.file1, self.file2) |
| |
| def test_link_bytes(self): |
| self._test_link(bytes(self.file1, sys.getfilesystemencoding()), |
| bytes(self.file2, sys.getfilesystemencoding())) |
| |
| def test_unicode_name(self): |
| try: |
| os.fsencode("\xf1") |
| except UnicodeError: |
| raise unittest.SkipTest("Unable to encode for this platform.") |
| |
| self.file1 += "\xf1" |
| self.file2 = self.file1 + "2" |
| self._test_link(self.file1, self.file2) |
| |
| if sys.platform != 'win32': |
| class Win32ErrorTests(unittest.TestCase): |
| pass |
| |
| class PosixUidGidTests(unittest.TestCase): |
| if hasattr(os, 'setuid'): |
| def test_setuid(self): |
| if os.getuid() != 0: |
| self.assertRaises(os.error, os.setuid, 0) |
| self.assertRaises(OverflowError, os.setuid, 1<<32) |
| |
| if hasattr(os, 'setgid'): |
| def test_setgid(self): |
| if os.getuid() != 0: |
| self.assertRaises(os.error, os.setgid, 0) |
| self.assertRaises(OverflowError, os.setgid, 1<<32) |
| |
| if hasattr(os, 'seteuid'): |
| def test_seteuid(self): |
| if os.getuid() != 0: |
| self.assertRaises(os.error, os.seteuid, 0) |
| self.assertRaises(OverflowError, os.seteuid, 1<<32) |
| |
| if hasattr(os, 'setegid'): |
| def test_setegid(self): |
| if os.getuid() != 0: |
| self.assertRaises(os.error, os.setegid, 0) |
| self.assertRaises(OverflowError, os.setegid, 1<<32) |
| |
| if hasattr(os, 'setreuid'): |
| def test_setreuid(self): |
| if os.getuid() != 0: |
| self.assertRaises(os.error, os.setreuid, 0, 0) |
| self.assertRaises(OverflowError, os.setreuid, 1<<32, 0) |
| self.assertRaises(OverflowError, os.setreuid, 0, 1<<32) |
| |
| def test_setreuid_neg1(self): |
| # Needs to accept -1. We run this in a subprocess to avoid |
| # altering the test runner's process state (issue8045). |
| subprocess.check_call([ |
| sys.executable, '-c', |
| 'import os,sys;os.setreuid(-1,-1);sys.exit(0)']) |
| |
| if hasattr(os, 'setregid'): |
| def test_setregid(self): |
| if os.getuid() != 0: |
| self.assertRaises(os.error, os.setregid, 0, 0) |
| self.assertRaises(OverflowError, os.setregid, 1<<32, 0) |
| self.assertRaises(OverflowError, os.setregid, 0, 1<<32) |
| |
| def test_setregid_neg1(self): |
| # Needs to accept -1. We run this in a subprocess to avoid |
| # altering the test runner's process state (issue8045). |
| subprocess.check_call([ |
| sys.executable, '-c', |
| 'import os,sys;os.setregid(-1,-1);sys.exit(0)']) |
| |
| class Pep383Tests(unittest.TestCase): |
| def setUp(self): |
| if support.TESTFN_UNENCODABLE: |
| self.dir = support.TESTFN_UNENCODABLE |
| else: |
| self.dir = support.TESTFN |
| self.bdir = os.fsencode(self.dir) |
| |
| bytesfn = [] |
| def add_filename(fn): |
| try: |
| fn = os.fsencode(fn) |
| except UnicodeEncodeError: |
| return |
| bytesfn.append(fn) |
| add_filename(support.TESTFN_UNICODE) |
| if support.TESTFN_UNENCODABLE: |
| add_filename(support.TESTFN_UNENCODABLE) |
| if not bytesfn: |
| self.skipTest("couldn't create any non-ascii filename") |
| |
| self.unicodefn = set() |
| os.mkdir(self.dir) |
| try: |
| for fn in bytesfn: |
| f = open(os.path.join(self.bdir, fn), "w") |
| f.close() |
| fn = os.fsdecode(fn) |
| if fn in self.unicodefn: |
| raise ValueError("duplicate filename") |
| self.unicodefn.add(fn) |
| except: |
| shutil.rmtree(self.dir) |
| raise |
| |
| def tearDown(self): |
| shutil.rmtree(self.dir) |
| |
| def test_listdir(self): |
| expected = self.unicodefn |
| found = set(os.listdir(self.dir)) |
| self.assertEqual(found, expected) |
| |
| def test_open(self): |
| for fn in self.unicodefn: |
| f = open(os.path.join(self.dir, fn)) |
| f.close() |
| |
| def test_stat(self): |
| for fn in self.unicodefn: |
| os.stat(os.path.join(self.dir, fn)) |
| else: |
| class PosixUidGidTests(unittest.TestCase): |
| pass |
| class Pep383Tests(unittest.TestCase): |
| pass |
| |
| @unittest.skipUnless(sys.platform == "win32", "Win32 specific tests") |
| class Win32KillTests(unittest.TestCase): |
| def _kill(self, sig): |
| # Start sys.executable as a subprocess and communicate from the |
| # subprocess to the parent that the interpreter is ready. When it |
| # becomes ready, send *sig* via os.kill to the subprocess and check |
| # that the return code is equal to *sig*. |
| import ctypes |
| from ctypes import wintypes |
| import msvcrt |
| |
| # Since we can't access the contents of the process' stdout until the |
| # process has exited, use PeekNamedPipe to see what's inside stdout |
| # without waiting. This is done so we can tell that the interpreter |
| # is started and running at a point where it could handle a signal. |
| PeekNamedPipe = ctypes.windll.kernel32.PeekNamedPipe |
| PeekNamedPipe.restype = wintypes.BOOL |
| PeekNamedPipe.argtypes = (wintypes.HANDLE, # Pipe handle |
| ctypes.POINTER(ctypes.c_char), # stdout buf |
| wintypes.DWORD, # Buffer size |
| ctypes.POINTER(wintypes.DWORD), # bytes read |
| ctypes.POINTER(wintypes.DWORD), # bytes avail |
| ctypes.POINTER(wintypes.DWORD)) # bytes left |
| msg = "running" |
| proc = subprocess.Popen([sys.executable, "-c", |
| "import sys;" |
| "sys.stdout.write('{}');" |
| "sys.stdout.flush();" |
| "input()".format(msg)], |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| stdin=subprocess.PIPE) |
| self.addCleanup(proc.stdout.close) |
| self.addCleanup(proc.stderr.close) |
| self.addCleanup(proc.stdin.close) |
| |
| count, max = 0, 100 |
| while count < max and proc.poll() is None: |
| # Create a string buffer to store the result of stdout from the pipe |
| buf = ctypes.create_string_buffer(len(msg)) |
| # Obtain the text currently in proc.stdout |
| # Bytes read/avail/left are left as NULL and unused |
| rslt = PeekNamedPipe(msvcrt.get_osfhandle(proc.stdout.fileno()), |
| buf, ctypes.sizeof(buf), None, None, None) |
| self.assertNotEqual(rslt, 0, "PeekNamedPipe failed") |
| if buf.value: |
| self.assertEqual(msg, buf.value.decode()) |
| break |
| time.sleep(0.1) |
| count += 1 |
| else: |
| self.fail("Did not receive communication from the subprocess") |
| |
| os.kill(proc.pid, sig) |
| self.assertEqual(proc.wait(), sig) |
| |
| def test_kill_sigterm(self): |
| # SIGTERM doesn't mean anything special, but make sure it works |
| self._kill(signal.SIGTERM) |
| |
| def test_kill_int(self): |
| # os.kill on Windows can take an int which gets set as the exit code |
| self._kill(100) |
| |
| def _kill_with_event(self, event, name): |
| tagname = "test_os_%s" % uuid.uuid1() |
| m = mmap.mmap(-1, 1, tagname) |
| m[0] = 0 |
| # Run a script which has console control handling enabled. |
| proc = subprocess.Popen([sys.executable, |
| os.path.join(os.path.dirname(__file__), |
| "win_console_handler.py"), tagname], |
| creationflags=subprocess.CREATE_NEW_PROCESS_GROUP) |
| # Let the interpreter startup before we send signals. See #3137. |
| count, max = 0, 100 |
| while count < max and proc.poll() is None: |
| if m[0] == 1: |
| break |
| time.sleep(0.1) |
| count += 1 |
| else: |
| # Forcefully kill the process if we weren't able to signal it. |
| os.kill(proc.pid, signal.SIGINT) |
| self.fail("Subprocess didn't finish initialization") |
| os.kill(proc.pid, event) |
| # proc.send_signal(event) could also be done here. |
| # Allow time for the signal to be passed and the process to exit. |
| time.sleep(0.5) |
| if not proc.poll(): |
| # Forcefully kill the process if we weren't able to signal it. |
| os.kill(proc.pid, signal.SIGINT) |
| self.fail("subprocess did not stop on {}".format(name)) |
| |
| @unittest.skip("subprocesses aren't inheriting CTRL+C property") |
| def test_CTRL_C_EVENT(self): |
| from ctypes import wintypes |
| import ctypes |
| |
| # Make a NULL value by creating a pointer with no argument. |
| NULL = ctypes.POINTER(ctypes.c_int)() |
| SetConsoleCtrlHandler = ctypes.windll.kernel32.SetConsoleCtrlHandler |
| SetConsoleCtrlHandler.argtypes = (ctypes.POINTER(ctypes.c_int), |
| wintypes.BOOL) |
| SetConsoleCtrlHandler.restype = wintypes.BOOL |
| |
| # Calling this with NULL and FALSE causes the calling process to |
| # handle CTRL+C, rather than ignore it. This property is inherited |
| # by subprocesses. |
| SetConsoleCtrlHandler(NULL, 0) |
| |
| self._kill_with_event(signal.CTRL_C_EVENT, "CTRL_C_EVENT") |
| |
| def test_CTRL_BREAK_EVENT(self): |
| self._kill_with_event(signal.CTRL_BREAK_EVENT, "CTRL_BREAK_EVENT") |
| |
| |
| @unittest.skipUnless(sys.platform == "win32", "Win32 specific tests") |
| @support.skip_unless_symlink |
| class Win32SymlinkTests(unittest.TestCase): |
| filelink = 'filelinktest' |
| filelink_target = os.path.abspath(__file__) |
| dirlink = 'dirlinktest' |
| dirlink_target = os.path.dirname(filelink_target) |
| missing_link = 'missing link' |
| |
| def setUp(self): |
| assert os.path.exists(self.dirlink_target) |
| assert os.path.exists(self.filelink_target) |
| assert not os.path.exists(self.dirlink) |
| assert not os.path.exists(self.filelink) |
| assert not os.path.exists(self.missing_link) |
| |
| def tearDown(self): |
| if os.path.exists(self.filelink): |
| os.remove(self.filelink) |
| if os.path.exists(self.dirlink): |
| os.rmdir(self.dirlink) |
| if os.path.lexists(self.missing_link): |
| os.remove(self.missing_link) |
| |
| def test_directory_link(self): |
| os.symlink(self.dirlink_target, self.dirlink) |
| self.assertTrue(os.path.exists(self.dirlink)) |
| self.assertTrue(os.path.isdir(self.dirlink)) |
| self.assertTrue(os.path.islink(self.dirlink)) |
| self.check_stat(self.dirlink, self.dirlink_target) |
| |
| def test_file_link(self): |
| os.symlink(self.filelink_target, self.filelink) |
| self.assertTrue(os.path.exists(self.filelink)) |
| self.assertTrue(os.path.isfile(self.filelink)) |
| self.assertTrue(os.path.islink(self.filelink)) |
| self.check_stat(self.filelink, self.filelink_target) |
| |
| def _create_missing_dir_link(self): |
| 'Create a "directory" link to a non-existent target' |
| linkname = self.missing_link |
| if os.path.lexists(linkname): |
| os.remove(linkname) |
| target = r'c:\\target does not exist.29r3c740' |
| assert not os.path.exists(target) |
| target_is_dir = True |
| os.symlink(target, linkname, target_is_dir) |
| |
| def test_remove_directory_link_to_missing_target(self): |
| self._create_missing_dir_link() |
| # For compatibility with Unix, os.remove will check the |
| # directory status and call RemoveDirectory if the symlink |
| # was created with target_is_dir==True. |
| os.remove(self.missing_link) |
| |
| @unittest.skip("currently fails; consider for improvement") |
| def test_isdir_on_directory_link_to_missing_target(self): |
| self._create_missing_dir_link() |
| # consider having isdir return true for directory links |
| self.assertTrue(os.path.isdir(self.missing_link)) |
| |
| @unittest.skip("currently fails; consider for improvement") |
| def test_rmdir_on_directory_link_to_missing_target(self): |
| self._create_missing_dir_link() |
| # consider allowing rmdir to remove directory links |
| os.rmdir(self.missing_link) |
| |
| def check_stat(self, link, target): |
| self.assertEqual(os.stat(link), os.stat(target)) |
| self.assertNotEqual(os.lstat(link), os.stat(link)) |
| |
| |
| class FSEncodingTests(unittest.TestCase): |
| def test_nop(self): |
| self.assertEqual(os.fsencode(b'abc\xff'), b'abc\xff') |
| self.assertEqual(os.fsdecode('abc\u0141'), 'abc\u0141') |
| |
| def test_identity(self): |
| # assert fsdecode(fsencode(x)) == x |
| for fn in ('unicode\u0141', 'latin\xe9', 'ascii'): |
| try: |
| bytesfn = os.fsencode(fn) |
| except UnicodeEncodeError: |
| continue |
| self.assertEqual(os.fsdecode(bytesfn), fn) |
| |
| |
| class PidTests(unittest.TestCase): |
| @unittest.skipUnless(hasattr(os, 'getppid'), "test needs os.getppid") |
| def test_getppid(self): |
| p = subprocess.Popen([sys.executable, '-c', |
| 'import os; print(os.getppid())'], |
| stdout=subprocess.PIPE) |
| stdout, _ = p.communicate() |
| # We are the parent of our subprocess |
| self.assertEqual(int(stdout), os.getpid()) |
| |
| |
| # The introduction of this TestCase caused at least two different errors on |
| # *nix buildbots. Temporarily skip this to let the buildbots move along. |
| @unittest.skip("Skip due to platform/environment differences on *NIX buildbots") |
| @unittest.skipUnless(hasattr(os, 'getlogin'), "test needs os.getlogin") |
| class LoginTests(unittest.TestCase): |
| def test_getlogin(self): |
| user_name = os.getlogin() |
| self.assertNotEqual(len(user_name), 0) |
| |
| |
| @unittest.skipUnless(hasattr(os, 'getpriority') and hasattr(os, 'setpriority'), |
| "needs os.getpriority and os.setpriority") |
| class ProgramPriorityTests(unittest.TestCase): |
| """Tests for os.getpriority() and os.setpriority().""" |
| |
| def test_set_get_priority(self): |
| |
| base = os.getpriority(os.PRIO_PROCESS, os.getpid()) |
| os.setpriority(os.PRIO_PROCESS, os.getpid(), base + 1) |
| try: |
| new_prio = os.getpriority(os.PRIO_PROCESS, os.getpid()) |
| if base >= 19 and new_prio <= 19: |
| raise unittest.SkipTest( |
| "unable to reliably test setpriority at current nice level of %s" % base) |
| else: |
| self.assertEqual(new_prio, base + 1) |
| finally: |
| try: |
| os.setpriority(os.PRIO_PROCESS, os.getpid(), base) |
| except OSError as err: |
| if err.errno != errno.EACCES: |
| raise |
| |
| |
| class SendfileTestServer(asyncore.dispatcher, threading.Thread): |
| |
| class Handler(asynchat.async_chat): |
| |
| def __init__(self, conn): |
| asynchat.async_chat.__init__(self, conn) |
| self.in_buffer = [] |
| self.closed = False |
| self.push(b"220 ready\r\n") |
| |
| def handle_read(self): |
| data = self.recv(4096) |
| self.in_buffer.append(data) |
| |
| def get_data(self): |
| return b''.join(self.in_buffer) |
| |
| def handle_close(self): |
| self.close() |
| self.closed = True |
| |
| def handle_error(self): |
| raise |
| |
| def __init__(self, address): |
| threading.Thread.__init__(self) |
| asyncore.dispatcher.__init__(self) |
| self.create_socket(socket.AF_INET, socket.SOCK_STREAM) |
| self.bind(address) |
| self.listen(5) |
| self.host, self.port = self.socket.getsockname()[:2] |
| self.handler_instance = None |
| self._active = False |
| self._active_lock = threading.Lock() |
| |
| # --- public API |
| |
| @property |
| def running(self): |
| return self._active |
| |
| def start(self): |
| assert not self.running |
| self.__flag = threading.Event() |
| threading.Thread.start(self) |
| self.__flag.wait() |
| |
| def stop(self): |
| assert self.running |
| self._active = False |
| self.join() |
| |
| def wait(self): |
| # wait for handler connection to be closed, then stop the server |
| while not getattr(self.handler_instance, "closed", False): |
| time.sleep(0.001) |
| self.stop() |
| |
| # --- internals |
| |
| def run(self): |
| self._active = True |
| self.__flag.set() |
| while self._active and asyncore.socket_map: |
| self._active_lock.acquire() |
| asyncore.loop(timeout=0.001, count=1) |
| self._active_lock.release() |
| asyncore.close_all() |
| |
| def handle_accept(self): |
| conn, addr = self.accept() |
| self.handler_instance = self.Handler(conn) |
| |
| def handle_connect(self): |
| self.close() |
| handle_read = handle_connect |
| |
| def writable(self): |
| return 0 |
| |
| def handle_error(self): |
| raise |
| |
| |
| @unittest.skipUnless(threading is not None, "test needs threading module") |
| @unittest.skipUnless(hasattr(os, 'sendfile'), "test needs os.sendfile()") |
| class TestSendfile(unittest.TestCase): |
| |
| DATA = b"12345abcde" * 16 * 1024 # 160 KB |
| SUPPORT_HEADERS_TRAILERS = not sys.platform.startswith("linux") and \ |
| not sys.platform.startswith("solaris") and \ |
| not sys.platform.startswith("sunos") |
| |
| @classmethod |
| def setUpClass(cls): |
| with open(support.TESTFN, "wb") as f: |
| f.write(cls.DATA) |
| |
| @classmethod |
| def tearDownClass(cls): |
| support.unlink(support.TESTFN) |
| |
| def setUp(self): |
| self.server = SendfileTestServer((support.HOST, 0)) |
| self.server.start() |
| self.client = socket.socket() |
| self.client.connect((self.server.host, self.server.port)) |
| self.client.settimeout(1) |
| # synchronize by waiting for "220 ready" response |
| self.client.recv(1024) |
| self.sockno = self.client.fileno() |
| self.file = open(support.TESTFN, 'rb') |
| self.fileno = self.file.fileno() |
| |
| def tearDown(self): |
| self.file.close() |
| self.client.close() |
| if self.server.running: |
| self.server.stop() |
| |
| def sendfile_wrapper(self, sock, file, offset, nbytes, headers=[], trailers=[]): |
| """A higher level wrapper representing how an application is |
| supposed to use sendfile(). |
| """ |
| while 1: |
| try: |
| if self.SUPPORT_HEADERS_TRAILERS: |
| return os.sendfile(sock, file, offset, nbytes, headers, |
| trailers) |
| else: |
| return os.sendfile(sock, file, offset, nbytes) |
| except OSError as err: |
| if err.errno == errno.ECONNRESET: |
| # disconnected |
| raise |
| elif err.errno in (errno.EAGAIN, errno.EBUSY): |
| # we have to retry send data |
| continue |
| else: |
| raise |
| |
| def test_send_whole_file(self): |
| # normal send |
| total_sent = 0 |
| offset = 0 |
| nbytes = 4096 |
| while total_sent < len(self.DATA): |
| sent = self.sendfile_wrapper(self.sockno, self.fileno, offset, nbytes) |
| if sent == 0: |
| break |
| offset += sent |
| total_sent += sent |
| self.assertTrue(sent <= nbytes) |
| self.assertEqual(offset, total_sent) |
| |
| self.assertEqual(total_sent, len(self.DATA)) |
| self.client.shutdown(socket.SHUT_RDWR) |
| self.client.close() |
| self.server.wait() |
| data = self.server.handler_instance.get_data() |
| self.assertEqual(len(data), len(self.DATA)) |
| self.assertEqual(data, self.DATA) |
| |
| def test_send_at_certain_offset(self): |
| # start sending a file at a certain offset |
| total_sent = 0 |
| offset = len(self.DATA) // 2 |
| must_send = len(self.DATA) - offset |
| nbytes = 4096 |
| while total_sent < must_send: |
| sent = self.sendfile_wrapper(self.sockno, self.fileno, offset, nbytes) |
| if sent == 0: |
| break |
| offset += sent |
| total_sent += sent |
| self.assertTrue(sent <= nbytes) |
| |
| self.client.shutdown(socket.SHUT_RDWR) |
| self.client.close() |
| self.server.wait() |
| data = self.server.handler_instance.get_data() |
| expected = self.DATA[len(self.DATA) // 2:] |
| self.assertEqual(total_sent, len(expected)) |
| self.assertEqual(len(data), len(expected)) |
| self.assertEqual(data, expected) |
| |
| def test_offset_overflow(self): |
| # specify an offset > file size |
| offset = len(self.DATA) + 4096 |
| try: |
| sent = os.sendfile(self.sockno, self.fileno, offset, 4096) |
| except OSError as e: |
| # Solaris can raise EINVAL if offset >= file length, ignore. |
| if e.errno != errno.EINVAL: |
| raise |
| else: |
| self.assertEqual(sent, 0) |
| self.client.shutdown(socket.SHUT_RDWR) |
| self.client.close() |
| self.server.wait() |
| data = self.server.handler_instance.get_data() |
| self.assertEqual(data, b'') |
| |
| def test_invalid_offset(self): |
| with self.assertRaises(OSError) as cm: |
| os.sendfile(self.sockno, self.fileno, -1, 4096) |
| self.assertEqual(cm.exception.errno, errno.EINVAL) |
| |
| # --- headers / trailers tests |
| |
| if SUPPORT_HEADERS_TRAILERS: |
| |
| def test_headers(self): |
| total_sent = 0 |
| sent = os.sendfile(self.sockno, self.fileno, 0, 4096, |
| headers=[b"x" * 512]) |
| total_sent += sent |
| offset = 4096 |
| nbytes = 4096 |
| while 1: |
| sent = self.sendfile_wrapper(self.sockno, self.fileno, |
| offset, nbytes) |
| if sent == 0: |
| break |
| total_sent += sent |
| offset += sent |
| |
| expected_data = b"x" * 512 + self.DATA |
| self.assertEqual(total_sent, len(expected_data)) |
| self.client.close() |
| self.server.wait() |
| data = self.server.handler_instance.get_data() |
| self.assertEqual(hash(data), hash(expected_data)) |
| |
| def test_trailers(self): |
| TESTFN2 = support.TESTFN + "2" |
| with open(TESTFN2, 'wb') as f: |
| f.write(b"abcde") |
| with open(TESTFN2, 'rb')as f: |
| self.addCleanup(os.remove, TESTFN2) |
| os.sendfile(self.sockno, f.fileno(), 0, 4096, |
| trailers=[b"12345"]) |
| self.client.close() |
| self.server.wait() |
| data = self.server.handler_instance.get_data() |
| self.assertEqual(data, b"abcde12345") |
| |
| if hasattr(os, "SF_NODISKIO"): |
| def test_flags(self): |
| try: |
| os.sendfile(self.sockno, self.fileno, 0, 4096, |
| flags=os.SF_NODISKIO) |
| except OSError as err: |
| if err.errno not in (errno.EBUSY, errno.EAGAIN): |
| raise |
| |
| |
| def test_main(): |
| support.run_unittest( |
| FileTests, |
| StatAttributeTests, |
| EnvironTests, |
| WalkTests, |
| MakedirTests, |
| DevNullTests, |
| URandomTests, |
| ExecTests, |
| Win32ErrorTests, |
| TestInvalidFD, |
| PosixUidGidTests, |
| Pep383Tests, |
| Win32KillTests, |
| Win32SymlinkTests, |
| FSEncodingTests, |
| PidTests, |
| LoginTests, |
| LinkTests, |
| TestSendfile, |
| ProgramPriorityTests, |
| ) |
| |
| if __name__ == "__main__": |
| test_main() |