From 1259e1317e28c29f728a4782208a02738c5a6827 Mon Sep 17 00:00:00 2001 From: Padraic Fanning Date: Fri, 19 Feb 2021 17:54:54 -0500 Subject: [PATCH 1/3] Add test_genericpath from CPython 3.8.7 --- Lib/test/test_genericpath.py | 572 +++++++++++++++++++++++++++++++++++ 1 file changed, 572 insertions(+) create mode 100644 Lib/test/test_genericpath.py diff --git a/Lib/test/test_genericpath.py b/Lib/test/test_genericpath.py new file mode 100644 index 000000000..9d5ac44b6 --- /dev/null +++ b/Lib/test/test_genericpath.py @@ -0,0 +1,572 @@ +""" +Tests common to genericpath, ntpath and posixpath +""" + +import genericpath +import os +import sys +import unittest +import warnings +from test import support +from test.support.script_helper import assert_python_ok +from test.support import FakePath + + +def create_file(filename, data=b'foo'): + with open(filename, 'xb', 0) as fp: + fp.write(data) + + +class GenericTest: + common_attributes = ['commonprefix', 'getsize', 'getatime', 'getctime', + 'getmtime', 'exists', 'isdir', 'isfile'] + attributes = [] + + def test_no_argument(self): + for attr in self.common_attributes + self.attributes: + with self.assertRaises(TypeError): + getattr(self.pathmodule, attr)() + raise self.fail("{}.{}() did not raise a TypeError" + .format(self.pathmodule.__name__, attr)) + + def test_commonprefix(self): + commonprefix = self.pathmodule.commonprefix + self.assertEqual( + commonprefix([]), + "" + ) + self.assertEqual( + commonprefix(["/home/swenson/spam", "/home/swen/spam"]), + "/home/swen" + ) + self.assertEqual( + commonprefix(["/home/swen/spam", "/home/swen/eggs"]), + "/home/swen/" + ) + self.assertEqual( + commonprefix(["/home/swen/spam", "/home/swen/spam"]), + "/home/swen/spam" + ) + self.assertEqual( + commonprefix(["home:swenson:spam", "home:swen:spam"]), + "home:swen" + ) + self.assertEqual( + commonprefix([":home:swen:spam", ":home:swen:eggs"]), + ":home:swen:" + ) + self.assertEqual( + commonprefix([":home:swen:spam", ":home:swen:spam"]), + ":home:swen:spam" + ) + + self.assertEqual( + commonprefix([b"/home/swenson/spam", b"/home/swen/spam"]), + b"/home/swen" + ) + self.assertEqual( + commonprefix([b"/home/swen/spam", b"/home/swen/eggs"]), + b"/home/swen/" + ) + self.assertEqual( + commonprefix([b"/home/swen/spam", b"/home/swen/spam"]), + b"/home/swen/spam" + ) + self.assertEqual( + commonprefix([b"home:swenson:spam", b"home:swen:spam"]), + b"home:swen" + ) + self.assertEqual( + commonprefix([b":home:swen:spam", b":home:swen:eggs"]), + b":home:swen:" + ) + self.assertEqual( + commonprefix([b":home:swen:spam", b":home:swen:spam"]), + b":home:swen:spam" + ) + + testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd', + 'aXc', 'abd', 'ab', 'aX', 'abcX'] + for s1 in testlist: + for s2 in testlist: + p = commonprefix([s1, s2]) + self.assertTrue(s1.startswith(p)) + self.assertTrue(s2.startswith(p)) + if s1 != s2: + n = len(p) + self.assertNotEqual(s1[n:n+1], s2[n:n+1]) + + def test_getsize(self): + filename = support.TESTFN + self.addCleanup(support.unlink, filename) + + create_file(filename, b'Hello') + self.assertEqual(self.pathmodule.getsize(filename), 5) + os.remove(filename) + + create_file(filename, b'Hello World!') + self.assertEqual(self.pathmodule.getsize(filename), 12) + + def test_filetime(self): + filename = support.TESTFN + self.addCleanup(support.unlink, filename) + + create_file(filename, b'foo') + + with open(filename, "ab", 0) as f: + f.write(b"bar") + + with open(filename, "rb", 0) as f: + data = f.read() + self.assertEqual(data, b"foobar") + + self.assertLessEqual( + self.pathmodule.getctime(filename), + self.pathmodule.getmtime(filename) + ) + + def test_exists(self): + filename = support.TESTFN + bfilename = os.fsencode(filename) + self.addCleanup(support.unlink, filename) + + self.assertIs(self.pathmodule.exists(filename), False) + self.assertIs(self.pathmodule.exists(bfilename), False) + + create_file(filename) + + self.assertIs(self.pathmodule.exists(filename), True) + self.assertIs(self.pathmodule.exists(bfilename), True) + + self.assertIs(self.pathmodule.exists(filename + '\udfff'), False) + self.assertIs(self.pathmodule.exists(bfilename + b'\xff'), False) + self.assertIs(self.pathmodule.exists(filename + '\x00'), False) + self.assertIs(self.pathmodule.exists(bfilename + b'\x00'), False) + + if self.pathmodule is not genericpath: + self.assertIs(self.pathmodule.lexists(filename), True) + self.assertIs(self.pathmodule.lexists(bfilename), True) + + self.assertIs(self.pathmodule.lexists(filename + '\udfff'), False) + self.assertIs(self.pathmodule.lexists(bfilename + b'\xff'), False) + self.assertIs(self.pathmodule.lexists(filename + '\x00'), False) + self.assertIs(self.pathmodule.lexists(bfilename + b'\x00'), False) + + @unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()") + def test_exists_fd(self): + r, w = os.pipe() + try: + self.assertTrue(self.pathmodule.exists(r)) + finally: + os.close(r) + os.close(w) + self.assertFalse(self.pathmodule.exists(r)) + + def test_isdir(self): + filename = support.TESTFN + bfilename = os.fsencode(filename) + self.assertIs(self.pathmodule.isdir(filename), False) + self.assertIs(self.pathmodule.isdir(bfilename), False) + + self.assertIs(self.pathmodule.isdir(filename + '\udfff'), False) + self.assertIs(self.pathmodule.isdir(bfilename + b'\xff'), False) + self.assertIs(self.pathmodule.isdir(filename + '\x00'), False) + self.assertIs(self.pathmodule.isdir(bfilename + b'\x00'), False) + + try: + create_file(filename) + self.assertIs(self.pathmodule.isdir(filename), False) + self.assertIs(self.pathmodule.isdir(bfilename), False) + finally: + support.unlink(filename) + + try: + os.mkdir(filename) + self.assertIs(self.pathmodule.isdir(filename), True) + self.assertIs(self.pathmodule.isdir(bfilename), True) + finally: + support.rmdir(filename) + + def test_isfile(self): + filename = support.TESTFN + bfilename = os.fsencode(filename) + self.assertIs(self.pathmodule.isfile(filename), False) + self.assertIs(self.pathmodule.isfile(bfilename), False) + + self.assertIs(self.pathmodule.isfile(filename + '\udfff'), False) + self.assertIs(self.pathmodule.isfile(bfilename + b'\xff'), False) + self.assertIs(self.pathmodule.isfile(filename + '\x00'), False) + self.assertIs(self.pathmodule.isfile(bfilename + b'\x00'), False) + + try: + create_file(filename) + self.assertIs(self.pathmodule.isfile(filename), True) + self.assertIs(self.pathmodule.isfile(bfilename), True) + finally: + support.unlink(filename) + + try: + os.mkdir(filename) + self.assertIs(self.pathmodule.isfile(filename), False) + self.assertIs(self.pathmodule.isfile(bfilename), False) + finally: + support.rmdir(filename) + + def test_samefile(self): + file1 = support.TESTFN + file2 = support.TESTFN + "2" + self.addCleanup(support.unlink, file1) + self.addCleanup(support.unlink, file2) + + create_file(file1) + self.assertTrue(self.pathmodule.samefile(file1, file1)) + + create_file(file2) + self.assertFalse(self.pathmodule.samefile(file1, file2)) + + self.assertRaises(TypeError, self.pathmodule.samefile) + + def _test_samefile_on_link_func(self, func): + test_fn1 = support.TESTFN + test_fn2 = support.TESTFN + "2" + self.addCleanup(support.unlink, test_fn1) + self.addCleanup(support.unlink, test_fn2) + + create_file(test_fn1) + + func(test_fn1, test_fn2) + self.assertTrue(self.pathmodule.samefile(test_fn1, test_fn2)) + os.remove(test_fn2) + + create_file(test_fn2) + self.assertFalse(self.pathmodule.samefile(test_fn1, test_fn2)) + + @support.skip_unless_symlink + def test_samefile_on_symlink(self): + self._test_samefile_on_link_func(os.symlink) + + def test_samefile_on_link(self): + try: + self._test_samefile_on_link_func(os.link) + except PermissionError as e: + self.skipTest('os.link(): %s' % e) + + def test_samestat(self): + test_fn1 = support.TESTFN + test_fn2 = support.TESTFN + "2" + self.addCleanup(support.unlink, test_fn1) + self.addCleanup(support.unlink, test_fn2) + + create_file(test_fn1) + stat1 = os.stat(test_fn1) + self.assertTrue(self.pathmodule.samestat(stat1, os.stat(test_fn1))) + + create_file(test_fn2) + stat2 = os.stat(test_fn2) + self.assertFalse(self.pathmodule.samestat(stat1, stat2)) + + self.assertRaises(TypeError, self.pathmodule.samestat) + + def _test_samestat_on_link_func(self, func): + test_fn1 = support.TESTFN + "1" + test_fn2 = support.TESTFN + "2" + self.addCleanup(support.unlink, test_fn1) + self.addCleanup(support.unlink, test_fn2) + + create_file(test_fn1) + func(test_fn1, test_fn2) + self.assertTrue(self.pathmodule.samestat(os.stat(test_fn1), + os.stat(test_fn2))) + os.remove(test_fn2) + + create_file(test_fn2) + self.assertFalse(self.pathmodule.samestat(os.stat(test_fn1), + os.stat(test_fn2))) + + @support.skip_unless_symlink + def test_samestat_on_symlink(self): + self._test_samestat_on_link_func(os.symlink) + + def test_samestat_on_link(self): + try: + self._test_samestat_on_link_func(os.link) + except PermissionError as e: + self.skipTest('os.link(): %s' % e) + + def test_sameopenfile(self): + filename = support.TESTFN + self.addCleanup(support.unlink, filename) + create_file(filename) + + with open(filename, "rb", 0) as fp1: + fd1 = fp1.fileno() + with open(filename, "rb", 0) as fp2: + fd2 = fp2.fileno() + self.assertTrue(self.pathmodule.sameopenfile(fd1, fd2)) + + +class TestGenericTest(GenericTest, unittest.TestCase): + # Issue 16852: GenericTest can't inherit from unittest.TestCase + # for test discovery purposes; CommonTest inherits from GenericTest + # and is only meant to be inherited by others. + pathmodule = genericpath + + def test_invalid_paths(self): + for attr in GenericTest.common_attributes: + # os.path.commonprefix doesn't raise ValueError + if attr == 'commonprefix': + continue + func = getattr(self.pathmodule, attr) + with self.subTest(attr=attr): + if attr in ('exists', 'isdir', 'isfile'): + func('/tmp\udfffabcds') + func(b'/tmp\xffabcds') + func('/tmp\x00abcds') + func(b'/tmp\x00abcds') + else: + with self.assertRaises((OSError, UnicodeEncodeError)): + func('/tmp\udfffabcds') + with self.assertRaises((OSError, UnicodeDecodeError)): + func(b'/tmp\xffabcds') + with self.assertRaisesRegex(ValueError, 'embedded null'): + func('/tmp\x00abcds') + with self.assertRaisesRegex(ValueError, 'embedded null'): + func(b'/tmp\x00abcds') + +# Following TestCase is not supposed to be run from test_genericpath. +# It is inherited by other test modules (ntpath, posixpath). + +class CommonTest(GenericTest): + common_attributes = GenericTest.common_attributes + [ + # Properties + 'curdir', 'pardir', 'extsep', 'sep', + 'pathsep', 'defpath', 'altsep', 'devnull', + # Methods + 'normcase', 'splitdrive', 'expandvars', 'normpath', 'abspath', + 'join', 'split', 'splitext', 'isabs', 'basename', 'dirname', + 'lexists', 'islink', 'ismount', 'expanduser', 'normpath', 'realpath', + ] + + def test_normcase(self): + normcase = self.pathmodule.normcase + # check that normcase() is idempotent + for p in ["FoO/./BaR", b"FoO/./BaR"]: + p = normcase(p) + self.assertEqual(p, normcase(p)) + + self.assertEqual(normcase(''), '') + self.assertEqual(normcase(b''), b'') + + # check that normcase raises a TypeError for invalid types + for path in (None, True, 0, 2.5, [], bytearray(b''), {'o','o'}): + self.assertRaises(TypeError, normcase, path) + + def test_splitdrive(self): + # splitdrive for non-NT paths + splitdrive = self.pathmodule.splitdrive + self.assertEqual(splitdrive("/foo/bar"), ("", "/foo/bar")) + self.assertEqual(splitdrive("foo:bar"), ("", "foo:bar")) + self.assertEqual(splitdrive(":foo:bar"), ("", ":foo:bar")) + + self.assertEqual(splitdrive(b"/foo/bar"), (b"", b"/foo/bar")) + self.assertEqual(splitdrive(b"foo:bar"), (b"", b"foo:bar")) + self.assertEqual(splitdrive(b":foo:bar"), (b"", b":foo:bar")) + + def test_expandvars(self): + expandvars = self.pathmodule.expandvars + with support.EnvironmentVarGuard() as env: + env.clear() + env["foo"] = "bar" + env["{foo"] = "baz1" + env["{foo}"] = "baz2" + self.assertEqual(expandvars("foo"), "foo") + self.assertEqual(expandvars("$foo bar"), "bar bar") + self.assertEqual(expandvars("${foo}bar"), "barbar") + self.assertEqual(expandvars("$[foo]bar"), "$[foo]bar") + self.assertEqual(expandvars("$bar bar"), "$bar bar") + self.assertEqual(expandvars("$?bar"), "$?bar") + self.assertEqual(expandvars("$foo}bar"), "bar}bar") + self.assertEqual(expandvars("${foo"), "${foo") + self.assertEqual(expandvars("${{foo}}"), "baz1}") + self.assertEqual(expandvars("$foo$foo"), "barbar") + self.assertEqual(expandvars("$bar$bar"), "$bar$bar") + + self.assertEqual(expandvars(b"foo"), b"foo") + self.assertEqual(expandvars(b"$foo bar"), b"bar bar") + self.assertEqual(expandvars(b"${foo}bar"), b"barbar") + self.assertEqual(expandvars(b"$[foo]bar"), b"$[foo]bar") + self.assertEqual(expandvars(b"$bar bar"), b"$bar bar") + self.assertEqual(expandvars(b"$?bar"), b"$?bar") + self.assertEqual(expandvars(b"$foo}bar"), b"bar}bar") + self.assertEqual(expandvars(b"${foo"), b"${foo") + self.assertEqual(expandvars(b"${{foo}}"), b"baz1}") + self.assertEqual(expandvars(b"$foo$foo"), b"barbar") + self.assertEqual(expandvars(b"$bar$bar"), b"$bar$bar") + + @unittest.skipUnless(support.FS_NONASCII, 'need support.FS_NONASCII') + def test_expandvars_nonascii(self): + expandvars = self.pathmodule.expandvars + def check(value, expected): + self.assertEqual(expandvars(value), expected) + with support.EnvironmentVarGuard() as env: + env.clear() + nonascii = support.FS_NONASCII + env['spam'] = nonascii + env[nonascii] = 'ham' + nonascii + check(nonascii, nonascii) + check('$spam bar', '%s bar' % nonascii) + check('${spam}bar', '%sbar' % nonascii) + check('${%s}bar' % nonascii, 'ham%sbar' % nonascii) + check('$bar%s bar' % nonascii, '$bar%s bar' % nonascii) + check('$spam}bar', '%s}bar' % nonascii) + + check(os.fsencode(nonascii), os.fsencode(nonascii)) + check(b'$spam bar', os.fsencode('%s bar' % nonascii)) + check(b'${spam}bar', os.fsencode('%sbar' % nonascii)) + check(os.fsencode('${%s}bar' % nonascii), + os.fsencode('ham%sbar' % nonascii)) + check(os.fsencode('$bar%s bar' % nonascii), + os.fsencode('$bar%s bar' % nonascii)) + check(b'$spam}bar', os.fsencode('%s}bar' % nonascii)) + + def test_abspath(self): + self.assertIn("foo", self.pathmodule.abspath("foo")) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", DeprecationWarning) + self.assertIn(b"foo", self.pathmodule.abspath(b"foo")) + + # avoid UnicodeDecodeError on Windows + undecodable_path = b'' if sys.platform == 'win32' else b'f\xf2\xf2' + + # Abspath returns bytes when the arg is bytes + with warnings.catch_warnings(): + warnings.simplefilter("ignore", DeprecationWarning) + for path in (b'', b'foo', undecodable_path, b'/foo', b'C:\\'): + self.assertIsInstance(self.pathmodule.abspath(path), bytes) + + def test_realpath(self): + self.assertIn("foo", self.pathmodule.realpath("foo")) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", DeprecationWarning) + self.assertIn(b"foo", self.pathmodule.realpath(b"foo")) + + def test_normpath_issue5827(self): + # Make sure normpath preserves unicode + for path in ('', '.', '/', '\\', '///foo/.//bar//'): + self.assertIsInstance(self.pathmodule.normpath(path), str) + + def test_abspath_issue3426(self): + # Check that abspath returns unicode when the arg is unicode + # with both ASCII and non-ASCII cwds. + abspath = self.pathmodule.abspath + for path in ('', 'fuu', 'f\xf9\xf9', '/fuu', 'U:\\'): + self.assertIsInstance(abspath(path), str) + + unicwd = '\xe7w\xf0' + try: + os.fsencode(unicwd) + except (AttributeError, UnicodeEncodeError): + # FS encoding is probably ASCII + pass + else: + with support.temp_cwd(unicwd): + for path in ('', 'fuu', 'f\xf9\xf9', '/fuu', 'U:\\'): + self.assertIsInstance(abspath(path), str) + + def test_nonascii_abspath(self): + if (support.TESTFN_UNDECODABLE + # Mac OS X denies the creation of a directory with an invalid + # UTF-8 name. Windows allows creating a directory with an + # arbitrary bytes name, but fails to enter this directory + # (when the bytes name is used). + and sys.platform not in ('win32', 'darwin')): + name = support.TESTFN_UNDECODABLE + elif support.TESTFN_NONASCII: + name = support.TESTFN_NONASCII + else: + self.skipTest("need support.TESTFN_NONASCII") + + with warnings.catch_warnings(): + warnings.simplefilter("ignore", DeprecationWarning) + with support.temp_cwd(name): + self.test_abspath() + + def test_join_errors(self): + # Check join() raises friendly TypeErrors. + with support.check_warnings(('', BytesWarning), quiet=True): + errmsg = "Can't mix strings and bytes in path components" + with self.assertRaisesRegex(TypeError, errmsg): + self.pathmodule.join(b'bytes', 'str') + with self.assertRaisesRegex(TypeError, errmsg): + self.pathmodule.join('str', b'bytes') + # regression, see #15377 + with self.assertRaisesRegex(TypeError, 'int'): + self.pathmodule.join(42, 'str') + with self.assertRaisesRegex(TypeError, 'int'): + self.pathmodule.join('str', 42) + with self.assertRaisesRegex(TypeError, 'int'): + self.pathmodule.join(42) + with self.assertRaisesRegex(TypeError, 'list'): + self.pathmodule.join([]) + with self.assertRaisesRegex(TypeError, 'bytearray'): + self.pathmodule.join(bytearray(b'foo'), bytearray(b'bar')) + + def test_relpath_errors(self): + # Check relpath() raises friendly TypeErrors. + with support.check_warnings(('', (BytesWarning, DeprecationWarning)), + quiet=True): + errmsg = "Can't mix strings and bytes in path components" + with self.assertRaisesRegex(TypeError, errmsg): + self.pathmodule.relpath(b'bytes', 'str') + with self.assertRaisesRegex(TypeError, errmsg): + self.pathmodule.relpath('str', b'bytes') + with self.assertRaisesRegex(TypeError, 'int'): + self.pathmodule.relpath(42, 'str') + with self.assertRaisesRegex(TypeError, 'int'): + self.pathmodule.relpath('str', 42) + with self.assertRaisesRegex(TypeError, 'bytearray'): + self.pathmodule.relpath(bytearray(b'foo'), bytearray(b'bar')) + + def test_import(self): + assert_python_ok('-S', '-c', 'import ' + self.pathmodule.__name__) + + +class PathLikeTests(unittest.TestCase): + + def setUp(self): + self.file_name = support.TESTFN.lower() + self.file_path = FakePath(support.TESTFN) + self.addCleanup(support.unlink, self.file_name) + create_file(self.file_name, b"test_genericpath.PathLikeTests") + + def assertPathEqual(self, func): + self.assertEqual(func(self.file_path), func(self.file_name)) + + def test_path_exists(self): + self.assertPathEqual(os.path.exists) + + def test_path_isfile(self): + self.assertPathEqual(os.path.isfile) + + def test_path_isdir(self): + self.assertPathEqual(os.path.isdir) + + def test_path_commonprefix(self): + self.assertEqual(os.path.commonprefix([self.file_path, self.file_name]), + self.file_name) + + def test_path_getsize(self): + self.assertPathEqual(os.path.getsize) + + def test_path_getmtime(self): + self.assertPathEqual(os.path.getatime) + + def test_path_getctime(self): + self.assertPathEqual(os.path.getctime) + + def test_path_samefile(self): + self.assertTrue(os.path.samefile(self.file_path, self.file_name)) + + +if __name__ == "__main__": + unittest.main() From e327039db5b2018a10cf26334b5c65df5f86c61f Mon Sep 17 00:00:00 2001 From: Padraic Fanning Date: Fri, 19 Feb 2021 17:56:21 -0500 Subject: [PATCH 2/3] Mark erroring test --- Lib/test/test_genericpath.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Lib/test/test_genericpath.py b/Lib/test/test_genericpath.py index 9d5ac44b6..fd2e88403 100644 --- a/Lib/test/test_genericpath.py +++ b/Lib/test/test_genericpath.py @@ -311,6 +311,8 @@ class TestGenericTest(GenericTest, unittest.TestCase): # and is only meant to be inherited by others. pathmodule = genericpath + # TODO: RUSTPYTHON + @unittest.expectedFailure def test_invalid_paths(self): for attr in GenericTest.common_attributes: # os.path.commonprefix doesn't raise ValueError From 49513be025008bf3335ac7a3cf2ee472db8e41cd Mon Sep 17 00:00:00 2001 From: Padraic Fanning Date: Sun, 21 Feb 2021 16:09:47 -0500 Subject: [PATCH 3/3] Skip erroring/failing tests on Windows --- Lib/test/test_genericpath.py | 42 ++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/Lib/test/test_genericpath.py b/Lib/test/test_genericpath.py index fd2e88403..06234a2c2 100644 --- a/Lib/test/test_genericpath.py +++ b/Lib/test/test_genericpath.py @@ -311,6 +311,48 @@ class TestGenericTest(GenericTest, unittest.TestCase): # and is only meant to be inherited by others. pathmodule = genericpath + # TODO: RUSTPYTHON + if sys.platform == "win32": + @unittest.expectedFailure + def test_exists(self): + super().test_exists() + + # TODO: RUSTPYTHON + if sys.platform == "win32": + @unittest.expectedFailure + def test_isdir(self): + super().test_isdir() + + # TODO: RUSTPYTHON + if sys.platform == "win32": + @unittest.expectedFailure + def test_isfile(self): + super().test_isfile() + + # TODO: RUSTPYTHON + if sys.platform == "win32": + @unittest.expectedFailure + def test_samefile(self): + super().test_samefile() + + # TODO: RUSTPYTHON + if sys.platform == "win32": + @unittest.expectedFailure + def test_samefile_on_link(self): + super().test_samefile_on_link() + + # TODO: RUSTPYTHON + if sys.platform == "win32": + @unittest.expectedFailure + def test_samestat(self): + super().test_samestat() + + # TODO: RUSTPYTHON + if sys.platform == "win32": + @unittest.expectedFailure + def test_samestat_on_link(self): + super().test_samestat_on_link() + # TODO: RUSTPYTHON @unittest.expectedFailure def test_invalid_paths(self):