Snap for 10843824 from ee132a3ba2a7295008913e19af9328d0954f240e to 24Q1-releaseandroid-14.0.0_r37android-14.0.0_r36android-14.0.0_r35android-14.0.0_r34android-14.0.0_r33android-14.0.0_r32android-14.0.0_r31android-14.0.0_r30android-14.0.0_r29android14-qpr2-s5-releaseandroid14-qpr2-s4-releaseandroid14-qpr2-s3-releaseandroid14-qpr2-s2-releaseandroid14-qpr2-s1-releaseandroid14-qpr2-release

Change-Id: I60abe1d180cfce33615c248c2f4f7691274bd387

1 files changed, 267 insertions, 240 deletions

diff --git a/pyfakefs/tests/fake_filesystem_vs_real_test.py b/pyfakefs/tests/fake_filesystem_vs_real_test.py
index 3be1076..3cc8f6c 100644
--- a/pyfakefs/tests/fake_filesystem_vs_real_test.py
+++ b/pyfakefs/tests/fake_filesystem_vs_real_test.py
@@ -22,14 +22,14 @@ import tempfile
 import time
 import unittest
 
-from pyfakefs import fake_filesystem
+from pyfakefs import fake_filesystem, fake_os, fake_open
 from pyfakefs.helpers import IS_PYPY
 
 
 def sep(path):
-    """Converts slashes in the path to the architecture's path seperator."""
+    """Converts slashes in the path to the architecture's path separator."""
     if isinstance(path, str):
-        return path.replace('/', os.sep)
+        return path.replace("/", os.sep)
     return path
 
 
@@ -42,8 +42,8 @@ def _get_errno(raised_error):
 
 
 class TestCase(unittest.TestCase):
-    is_windows = sys.platform.startswith('win')
-    _FAKE_FS_BASE = sep('/fakefs')
+    is_windows = sys.platform.startswith("win")
+    _FAKE_FS_BASE = "C:\\fakefs" if is_windows else "/fakefs"
 
 
 class FakeFilesystemVsRealTest(TestCase):
@@ -51,43 +51,45 @@ class FakeFilesystemVsRealTest(TestCase):
         """For a given path, return paths in the real and fake filesystems."""
         if not path:
             return None, None
-        return (os.path.join(self.real_base, path),
-                os.path.join(self.fake_base, path))
+        return (
+            os.path.join(self.real_base, path),
+            os.path.join(self.fake_base, path),
+        )
 
     def _create_test_file(self, file_type, path, contents=None):
         """Create a dir, file, or link in both the real fs and the fake."""
         path = sep(path)
         self._created_files.append([file_type, path, contents])
         real_path, fake_path = self._paths(path)
-        if file_type == 'd':
+        if file_type == "d":
             os.mkdir(real_path)
             self.fake_os.mkdir(fake_path)
-        if file_type == 'f':
-            fh = open(real_path, 'w')
-            fh.write(contents or '')
+        if file_type == "f":
+            fh = open(real_path, "w")
+            fh.write(contents or "")
             fh.close()
-            fh = self.fake_open(fake_path, 'w')
-            fh.write(contents or '')
+            fh = self.fake_open(fake_path, "w")
+            fh.write(contents or "")
             fh.close()
         # b for binary file
-        if file_type == 'b':
-            fh = open(real_path, 'wb')
-            fh.write(contents or '')
+        if file_type == "b":
+            fh = open(real_path, "wb")
+            fh.write(contents or "")
             fh.close()
-            fh = self.fake_open(fake_path, 'wb')
-            fh.write(contents or '')
+            fh = self.fake_open(fake_path, "wb")
+            fh.write(contents or "")
             fh.close()
         # l for symlink, h for hard link
-        if file_type in ('l', 'h'):
+        if file_type in ("l", "h"):
             real_target, fake_target = (contents, contents)
             # If it begins with '/', make it relative to the base. You can't go
             # creating files in / for the real file system.
             if contents.startswith(os.sep):
                 real_target, fake_target = self._paths(contents[1:])
-            if file_type == 'l':
+            if file_type == "l":
                 os.symlink(real_target, real_path)
                 self.fake_os.symlink(fake_target, fake_path)
-            elif file_type == 'h':
+            elif file_type == "h":
                 os.link(real_target, real_path)
                 self.fake_os.link(fake_target, fake_path)
 
@@ -95,11 +97,10 @@ class FakeFilesystemVsRealTest(TestCase):
         # Base paths in the real and test file systems. We keep them different
         # so that missing features in the fake don't fall through to the base
         # operations and magically succeed.
-        tsname = 'fakefs.%s' % time.time()
+        tsname = "fakefs.%s" % time.time()
         self.cwd = os.getcwd()
         # Fully expand the base_path - required on OS X.
-        self.real_base = os.path.realpath(
-            os.path.join(tempfile.gettempdir(), tsname))
+        self.real_base = os.path.realpath(os.path.join(tempfile.gettempdir(), tsname))
         os.chdir(tempfile.gettempdir())
         if os.path.isdir(self.real_base):
             shutil.rmtree(self.real_base)
@@ -111,8 +112,8 @@ class FakeFilesystemVsRealTest(TestCase):
 
         self.fake_filesystem = fake_filesystem.FakeFilesystem()
         self.fake_filesystem.create_dir(self.fake_base)
-        self.fake_os = fake_filesystem.FakeOsModule(self.fake_filesystem)
-        self.fake_open = fake_filesystem.FakeFileOpen(self.fake_filesystem)
+        self.fake_os = fake_os.FakeOsModule(self.fake_filesystem)
+        self.fake_open = fake_open.FakeFileOpen(self.fake_filesystem)
         self._created_files = []
 
         os.chdir(self.real_base)
@@ -127,25 +128,28 @@ class FakeFilesystemVsRealTest(TestCase):
             rev_files.reverse()
             for info in rev_files:
                 real_path, fake_path = self._paths(info[1])
-                if info[0] == 'd':
+                if info[0] == "d":
                     try:
                         os.rmdir(real_path)
                     except OSError as e:
-                        if 'Directory not empty' in e:
-                            self.fail('Real path %s not empty: %s : %s' % (
-                                real_path, e, os.listdir(real_path)))
+                        if "Directory not empty" in e:
+                            self.fail(
+                                "Real path %s not empty: %s : %s"
+                                % (real_path, e, os.listdir(real_path))
+                            )
                         else:
                             raise
                     self.fake_os.rmdir(fake_path)
-                if info[0] == 'f' or info[0] == 'l':
+                if info[0] == "f" or info[0] == "l":
                     os.remove(real_path)
                     self.fake_os.remove(fake_path)
         finally:
             shutil.rmtree(self.real_base)
             os.chdir(self.cwd)
 
-    def _compare_behaviors(self, method_name, path, real, fake,
-                           method_returns_path=False):
+    def _compare_behaviors(
+        self, method_name, path, real, fake, method_returns_path=False
+    ):
         """Invoke an os method in both real and fake contexts and compare
         results.
 
@@ -174,44 +178,63 @@ class FakeFilesystemVsRealTest(TestCase):
 
         def _error_class(exc):
             if exc:
-                if hasattr(exc, 'errno'):
-                    return '{}({})'.format(exc.__class__.__name__, exc.errno)
+                if hasattr(exc, "errno"):
+                    return "{}({})".format(exc.__class__.__name__, exc.errno)
                 return exc.__class__.__name__
-            return 'None'
+            return "None"
 
         real_err, real_value = self._get_real_value(method_name, path, real)
         fake_err, fake_value = self._get_fake_value(method_name, path, fake)
 
-        method_call = f'{method_name}'
-        method_call += '()' if path == () else '({path})'
-        # We only compare on the error class because the acutal error contents
+        method_call = f"{method_name}"
+        method_call += "()" if path == () else "({path})"
+        # We only compare on the error class because the actual error contents
         # is almost always different because of the file paths.
         if _error_class(real_err) != _error_class(fake_err):
             if real_err is None:
-                return '%s: real version returned %s, fake raised %s' % (
-                    method_call, real_value, _error_class(fake_err))
+                return "%s: real version returned %s, fake raised %s" % (
+                    method_call,
+                    real_value,
+                    _error_class(fake_err),
+                )
             if fake_err is None:
-                return '%s: real version raised %s, fake returned %s' % (
-                    method_call, _error_class(real_err), fake_value)
-            return '%s: real version raised %s, fake raised %s' % (
-                method_call, _error_class(real_err), _error_class(fake_err))
+                return "%s: real version raised %s, fake returned %s" % (
+                    method_call,
+                    _error_class(real_err),
+                    fake_value,
+                )
+            return "%s: real version raised %s, fake raised %s" % (
+                method_call,
+                _error_class(real_err),
+                _error_class(fake_err),
+            )
         real_errno = _get_errno(real_err)
         fake_errno = _get_errno(fake_err)
         if real_errno != fake_errno:
-            return '%s(%s): both raised %s, real errno %s, fake errno %s' % (
-                method_name, path, _error_class(real_err),
-                real_errno, fake_errno)
+            return "%s(%s): both raised %s, real errno %s, fake errno %s" % (
+                method_name,
+                path,
+                _error_class(real_err),
+                real_errno,
+                fake_errno,
+            )
         # If the method is supposed to return a full path AND both values
         # begin with the expected full path, then trim it off.
         if method_returns_path:
-            if (real_value and fake_value
-                    and real_value.startswith(self.real_base)
-                    and fake_value.startswith(self.fake_base)):
-                real_value = real_value[len(self.real_base):]
-                fake_value = fake_value[len(self.fake_base):]
+            if (
+                real_value
+                and fake_value
+                and real_value.startswith(self.real_base)
+                and fake_value.startswith(self.fake_base)
+            ):
+                real_value = real_value[len(self.real_base) :]
+                fake_value = fake_value[len(self.fake_base) :]
         if real_value != fake_value:
-            return '%s: real return %s, fake returned %s' % (
-                method_call, real_value, fake_value)
+            return "%s: real return %s, fake returned %s" % (
+                method_call,
+                real_value,
+                fake_value,
+            )
         return None
 
     @staticmethod
@@ -251,8 +274,9 @@ class FakeFilesystemVsRealTest(TestCase):
             real_err = e
         return real_err, real_value
 
-    def assertOsMethodBehaviorMatches(self, method_name, path,
-                                      method_returns_path=False):
+    def assertOsMethodBehaviorMatches(
+        self, method_name, path, method_returns_path=False
+    ):
         """Invoke an os method in both real and fake contexts and compare.
 
         For a given method name (from the os module) and a path, compare the
@@ -270,11 +294,13 @@ class FakeFilesystemVsRealTest(TestCase):
             A description of the difference in behavior, or None.
         """
         path = sep(path)
-        return self._compare_behaviors(method_name, path, os, self.fake_os,
-                                       method_returns_path)
+        return self._compare_behaviors(
+            method_name, path, os, self.fake_os, method_returns_path
+        )
 
-    def diff_open_method_behavior(self, method_name, path, mode, data,
-                                  method_returns_data=True):
+    def diff_open_method_behavior(
+        self, method_name, path, mode, data, method_returns_data=True
+    ):
         """Invoke an open method in both real and fkae contexts and compare.
 
         Args:
@@ -295,10 +321,12 @@ class FakeFilesystemVsRealTest(TestCase):
         with open(path, mode) as real_fh:
             with self.fake_open(path, mode) as fake_fh:
                 return self._compare_behaviors(
-                    method_name, data, real_fh, fake_fh, method_returns_data)
+                    method_name, data, real_fh, fake_fh, method_returns_data
+                )
 
-    def diff_os_path_method_behavior(self, method_name, path,
-                                     method_returns_path=False):
+    def diff_os_path_method_behavior(
+        self, method_name, path, method_returns_path=False
+    ):
         """Invoke an os.path method in both real and fake contexts and compare.
 
         For a given method name (from the os.path module) and a path, compare
@@ -315,12 +343,13 @@ class FakeFilesystemVsRealTest(TestCase):
         Returns:
             A description of the difference in behavior, or None.
         """
-        return self._compare_behaviors(method_name, path, os.path,
-                                       self.fake_os.path,
-                                       method_returns_path)
+        return self._compare_behaviors(
+            method_name, path, os.path, self.fake_os.path, method_returns_path
+        )
 
-    def assertOsPathMethodBehaviorMatches(self, method_name, path,
-                                          method_returns_path=False):
+    def assertOsPathMethodBehaviorMatches(
+        self, method_name, path, method_returns_path=False
+    ):
         """Assert that an os.path behaves the same in both real and
         fake contexts.
 
@@ -337,25 +366,24 @@ class FakeFilesystemVsRealTest(TestCase):
             AssertionError if there is any difference in behavior.
         """
         path = sep(path)
-        diff = self.diff_os_path_method_behavior(
-            method_name, path, method_returns_path)
+        diff = self.diff_os_path_method_behavior(method_name, path, method_returns_path)
         if diff:
             self.fail(diff)
 
     def assertAllOsBehaviorsMatch(self, path):
         path = sep(path)
-        os_method_names = [] if self.is_windows else ['readlink']
-        os_method_names_no_args = ['getcwd']
-        os_path_method_names = ['isabs', 'isdir']
+        os_method_names = [] if self.is_windows else ["readlink"]
+        os_method_names_no_args = ["getcwd"]
+        os_path_method_names = ["isabs", "isdir"]
         if not self.is_windows:
-            os_path_method_names += ['islink', 'lexists']
+            os_path_method_names += ["islink", "lexists"]
         if not self.is_windows or not IS_PYPY:
-            os_path_method_names += ['isfile', 'exists']
+            os_path_method_names += ["isfile", "exists"]
 
         wrapped_methods = [
-            ['access', self._access_real, self._access_fake],
-            ['stat.size', self._stat_size_real, self._stat_size_fake],
-            ['lstat.size', self._lstat_size_real, self._lstat_size_fake]
+            ["access", self._access_real, self._access_fake],
+            ["stat.size", self._stat_size_real, self._stat_size_fake],
+            ["lstat.size", self._lstat_size_real, self._lstat_size_fake],
         ]
 
         differences = []
@@ -364,8 +392,9 @@ class FakeFilesystemVsRealTest(TestCase):
             if diff:
                 differences.append(diff)
         for method_name in os_method_names_no_args:
-            diff = self.assertOsMethodBehaviorMatches(method_name, (),
-                                                      method_returns_path=True)
+            diff = self.assertOsMethodBehaviorMatches(
+                method_name, (), method_returns_path=True
+            )
             if diff:
                 differences.append(diff)
         for method_name in os_path_method_names:
@@ -377,18 +406,19 @@ class FakeFilesystemVsRealTest(TestCase):
             if diff:
                 differences.append(diff)
         if differences:
-            self.fail('Behaviors do not match for %s:\n    %s' %
-                      (path, '\n    '.join(differences)))
+            self.fail(
+                "Behaviors do not match for %s:\n    %s"
+                % (path, "\n    ".join(differences))
+            )
 
     def assertFileHandleBehaviorsMatch(self, path, mode, data):
         path = sep(path)
-        write_method_names = ['write', 'writelines']
-        read_method_names = ['read', 'readlines']
-        other_method_names = ['truncate', 'flush', 'close']
+        write_method_names = ["write", "writelines"]
+        read_method_names = ["read", "readlines"]
+        other_method_names = ["truncate", "flush", "close"]
         differences = []
         for method_name in write_method_names:
-            diff = self.diff_open_method_behavior(
-                method_name, path, mode, data)
+            diff = self.diff_open_method_behavior(method_name, path, mode, data)
             if diff:
                 differences.append(diff)
         for method_name in read_method_names + other_method_names:
@@ -396,8 +426,10 @@ class FakeFilesystemVsRealTest(TestCase):
             if diff:
                 differences.append(diff)
         if differences:
-            self.fail('Behaviors do not match for %s:\n    %s' %
-                      (path, '\n    '.join(differences)))
+            self.fail(
+                "Behaviors do not match for %s:\n    %s"
+                % (path, "\n    ".join(differences))
+            )
 
     def assertFileHandleOpenBehaviorsMatch(self, *args, **kwargs):
         """Compare open() function invocation between real and fake.
@@ -429,18 +461,20 @@ class FakeFilesystemVsRealTest(TestCase):
             fake_err = e
 
         # default equal in case one is None and other is not.
-        is_exception_equal = (real_err == fake_err)
+        is_exception_equal = real_err == fake_err
         if real_err and fake_err:
             # exception __eq__ doesn't evaluate equal ever, thus manual check.
-            is_exception_equal = (type(real_err) is type(fake_err) and
-                                  real_err.args == fake_err.args)
+            is_exception_equal = (
+                type(real_err) is type(fake_err) and real_err.args == fake_err.args
+            )
 
         if not is_exception_equal:
-            msg = (
-                "Behaviors don't match on open with args %s & kwargs %s.\n" %
-                (args, kwargs))
-            real_err_msg = 'Real open results in: %s\n' % repr(real_err)
-            fake_err_msg = 'Fake open results in: %s\n' % repr(fake_err)
+            msg = "Behaviors don't match on open with args %s & kwargs %s.\n" % (
+                args,
+                kwargs,
+            )
+            real_err_msg = "Real open results in: %s\n" % repr(real_err)
+            fake_err_msg = "Fake open results in: %s\n" % repr(fake_err)
             self.fail(msg + real_err_msg + fake_err_msg)
 
     # Helpers for checks which are not straight method calls.
@@ -490,211 +524,204 @@ class FakeFilesystemVsRealTest(TestCase):
 
     def test_isabs(self):
         # We do not have to create any files for isabs.
-        self.assertOsPathMethodBehaviorMatches('isabs', None)
-        self.assertOsPathMethodBehaviorMatches('isabs', '')
-        self.assertOsPathMethodBehaviorMatches('isabs', '/')
-        self.assertOsPathMethodBehaviorMatches('isabs', '/a')
-        self.assertOsPathMethodBehaviorMatches('isabs', 'a')
+        self.assertOsPathMethodBehaviorMatches("isabs", None)
+        self.assertOsPathMethodBehaviorMatches("isabs", "")
+        self.assertOsPathMethodBehaviorMatches("isabs", "/")
+        self.assertOsPathMethodBehaviorMatches("isabs", "/a")
+        self.assertOsPathMethodBehaviorMatches("isabs", "a")
 
     def test_none_path(self):
         self.assertAllOsBehaviorsMatch(None)
 
     def test_empty_path(self):
-        self.assertAllOsBehaviorsMatch('')
+        self.assertAllOsBehaviorsMatch("")
 
     def test_root_path(self):
-        self.assertAllOsBehaviorsMatch('/')
+        self.assertAllOsBehaviorsMatch("/")
 
     def test_non_existant_file(self):
-        self.assertAllOsBehaviorsMatch('foo')
+        self.assertAllOsBehaviorsMatch("foo")
 
     def test_empty_file(self):
-        self._create_test_file('f', 'aFile')
-        self.assertAllOsBehaviorsMatch('aFile')
+        self._create_test_file("f", "aFile")
+        self.assertAllOsBehaviorsMatch("aFile")
 
     def test_file_with_contents(self):
-        self._create_test_file('f', 'aFile', 'some contents')
-        self.assertAllOsBehaviorsMatch('aFile')
+        self._create_test_file("f", "aFile", "some contents")
+        self.assertAllOsBehaviorsMatch("aFile")
 
     def test_file_with_binary_contents(self):
-        self._create_test_file('b', 'aFile', b'some contents')
-        self.assertAllOsBehaviorsMatch('aFile')
+        self._create_test_file("b", "aFile", b"some contents")
+        self.assertAllOsBehaviorsMatch("aFile")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_sym_link_to_empty_file(self):
-        self._create_test_file('f', 'aFile')
-        self._create_test_file('l', 'link_to_empty', 'aFile')
-        self.assertAllOsBehaviorsMatch('link_to_empty')
+        self._create_test_file("f", "aFile")
+        self._create_test_file("l", "link_to_empty", "aFile")
+        self.assertAllOsBehaviorsMatch("link_to_empty")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_hard_link_to_empty_file(self):
-        self._create_test_file('f', 'aFile')
-        self._create_test_file('h', 'link_to_empty', 'aFile')
-        self.assertAllOsBehaviorsMatch('link_to_empty')
+        self._create_test_file("f", "aFile")
+        self._create_test_file("h", "link_to_empty", "aFile")
+        self.assertAllOsBehaviorsMatch("link_to_empty")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_sym_link_to_real_file(self):
-        self._create_test_file('f', 'aFile', 'some contents')
-        self._create_test_file('l', 'link_to_file', 'aFile')
-        self.assertAllOsBehaviorsMatch('link_to_file')
+        self._create_test_file("f", "aFile", "some contents")
+        self._create_test_file("l", "link_to_file", "aFile")
+        self.assertAllOsBehaviorsMatch("link_to_file")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_hard_link_to_real_file(self):
-        self._create_test_file('f', 'aFile', 'some contents')
-        self._create_test_file('h', 'link_to_file', 'aFile')
-        self.assertAllOsBehaviorsMatch('link_to_file')
+        self._create_test_file("f", "aFile", "some contents")
+        self._create_test_file("h", "link_to_file", "aFile")
+        self.assertAllOsBehaviorsMatch("link_to_file")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_broken_sym_link(self):
-        self._create_test_file('l', 'broken_link', 'broken')
-        self._create_test_file('l', 'loop', '/a/loop')
-        self.assertAllOsBehaviorsMatch('broken_link')
+        self._create_test_file("l", "broken_link", "broken")
+        self._create_test_file("l", "loop", "/a/loop")
+        self.assertAllOsBehaviorsMatch("broken_link")
 
     def test_file_in_a_folder(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('f', 'a/b/file', 'contents')
-        self.assertAllOsBehaviorsMatch('a/b/file')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("f", "a/b/file", "contents")
+        self.assertAllOsBehaviorsMatch("a/b/file")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_absolute_sym_link_to_folder(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('f', 'a/b/file', 'contents')
-        self._create_test_file('l', 'a/link', '/a/b')
-        self.assertAllOsBehaviorsMatch('a/link/file')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("f", "a/b/file", "contents")
+        self._create_test_file("l", "a/link", "/a/b")
+        self.assertAllOsBehaviorsMatch("a/link/file")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_link_to_folder_after_chdir(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('f', 'a/b/file', 'contents')
-        self._create_test_file('l', 'a/link', '/a/b')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("f", "a/b/file", "contents")
+        self._create_test_file("l", "a/link", "/a/b")
 
-        real_dir, fake_dir = self._paths('a/b')
+        real_dir, fake_dir = self._paths("a/b")
         os.chdir(real_dir)
         self.fake_os.chdir(fake_dir)
-        self.assertAllOsBehaviorsMatch('file')
+        self.assertAllOsBehaviorsMatch("file")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_relative_sym_link_to_folder(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('f', 'a/b/file', 'contents')
-        self._create_test_file('l', 'a/link', 'b')
-        self.assertAllOsBehaviorsMatch('a/link/file')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("f", "a/b/file", "contents")
+        self._create_test_file("l", "a/link", "b")
+        self.assertAllOsBehaviorsMatch("a/link/file")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_sym_link_to_parent(self):
         # Soft links on HFS+ / OS X behave differently.
-        if os.uname()[0] != 'Darwin':
-            self._create_test_file('d', 'a')
-            self._create_test_file('d', 'a/b')
-            self._create_test_file('l', 'a/b/c', '..')
-            self.assertAllOsBehaviorsMatch('a/b/c')
+        if os.uname()[0] != "Darwin":
+            self._create_test_file("d", "a")
+            self._create_test_file("d", "a/b")
+            self._create_test_file("l", "a/b/c", "..")
+            self.assertAllOsBehaviorsMatch("a/b/c")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_path_through_sym_link_to_parent(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('f', 'a/target', 'contents')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('l', 'a/b/c', '..')
-        self.assertAllOsBehaviorsMatch('a/b/c/target')
+        self._create_test_file("d", "a")
+        self._create_test_file("f", "a/target", "contents")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("l", "a/b/c", "..")
+        self.assertAllOsBehaviorsMatch("a/b/c/target")
 
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_sym_link_to_sibling_directory(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('d', 'a/sibling_of_b')
-        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
-        self._create_test_file('l', 'a/b/c', '../sibling_of_b')
-        self.assertAllOsBehaviorsMatch('a/b/c/target')
-
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("d", "a/sibling_of_b")
+        self._create_test_file("f", "a/sibling_of_b/target", "contents")
+        self._create_test_file("l", "a/b/c", "../sibling_of_b")
+        self.assertAllOsBehaviorsMatch("a/b/c/target")
+
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_sym_link_to_sibling_directory_non_existant_file(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('d', 'a/sibling_of_b')
-        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
-        self._create_test_file('l', 'a/b/c', '../sibling_of_b')
-        self.assertAllOsBehaviorsMatch('a/b/c/file_does_not_exist')
-
-    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("d", "a/sibling_of_b")
+        self._create_test_file("f", "a/sibling_of_b/target", "contents")
+        self._create_test_file("l", "a/b/c", "../sibling_of_b")
+        self.assertAllOsBehaviorsMatch("a/b/c/file_does_not_exist")
+
+    @unittest.skipIf(TestCase.is_windows, "no symlink in Windows")
     def test_broken_sym_link_to_sibling_directory(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('d', 'a/sibling_of_b')
-        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
-        self._create_test_file('l', 'a/b/c', '../broken_sibling_of_b')
-        self.assertAllOsBehaviorsMatch('a/b/c/target')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("d", "a/sibling_of_b")
+        self._create_test_file("f", "a/sibling_of_b/target", "contents")
+        self._create_test_file("l", "a/b/c", "../broken_sibling_of_b")
+        self.assertAllOsBehaviorsMatch("a/b/c/target")
 
     def test_relative_path(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('d', 'a/sibling_of_b')
-        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
-        self.assertAllOsBehaviorsMatch('a/b/../sibling_of_b/target')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("d", "a/sibling_of_b")
+        self._create_test_file("f", "a/sibling_of_b/target", "contents")
+        self.assertAllOsBehaviorsMatch("a/b/../sibling_of_b/target")
 
     def test_broken_relative_path(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('d', 'a/sibling_of_b')
-        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
-        self.assertAllOsBehaviorsMatch('a/b/../broken/target')
+        self._create_test_file("d", "a")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("d", "a/sibling_of_b")
+        self._create_test_file("f", "a/sibling_of_b/target", "contents")
+        self.assertAllOsBehaviorsMatch("a/b/../broken/target")
 
     def test_bad_relative_path(self):
-        self._create_test_file('d', 'a')
-        self._create_test_file('f', 'a/target', 'contents')
-        self._create_test_file('d', 'a/b')
-        self._create_test_file('d', 'a/sibling_of_b')
-        self._create_test_file('f', 'a/sibling_of_b/target', 'contents')
-        self.assertAllOsBehaviorsMatch('a/b/../broken/../target')
+        self._create_test_file("d", "a")
+        self._create_test_file("f", "a/target", "contents")
+        self._create_test_file("d", "a/b")
+        self._create_test_file("d", "a/sibling_of_b")
+        self._create_test_file("f", "a/sibling_of_b/target", "contents")
+        self.assertAllOsBehaviorsMatch("a/b/../broken/../target")
 
     def test_getmtime_nonexistant_path(self):
-        self.assertOsPathMethodBehaviorMatches('getmtime', 'no/such/path')
+        self.assertOsPathMethodBehaviorMatches("getmtime", "no/such/path")
 
     def test_builtin_open_modes(self):
-        self._create_test_file('f', 'read', 'some contents')
-        self._create_test_file('f', 'write', 'some contents')
-        self._create_test_file('f', 'append', 'some contents')
-        self.assertFileHandleBehaviorsMatch('read', 'r', 'other contents')
-        self.assertFileHandleBehaviorsMatch('write', 'w', 'other contents')
-        self.assertFileHandleBehaviorsMatch('append', 'a', 'other contents')
-        self._create_test_file('f', 'readplus', 'some contents')
-        self._create_test_file('f', 'writeplus', 'some contents')
-        self.assertFileHandleBehaviorsMatch(
-            'readplus', 'r+', 'other contents')
-        self.assertFileHandleBehaviorsMatch(
-            'writeplus', 'w+', 'other contents')
-        self._create_test_file('b', 'binaryread', b'some contents')
-        self._create_test_file('b', 'binarywrite', b'some contents')
-        self._create_test_file('b', 'binaryappend', b'some contents')
-        self.assertFileHandleBehaviorsMatch(
-            'binaryread', 'rb', b'other contents')
-        self.assertFileHandleBehaviorsMatch(
-            'binarywrite', 'wb', b'other contents')
-        self.assertFileHandleBehaviorsMatch(
-            'binaryappend', 'ab', b'other contents')
-        self.assertFileHandleBehaviorsMatch('read', 'rb', 'other contents')
-        self.assertFileHandleBehaviorsMatch('write', 'wb', 'other contents')
-        self.assertFileHandleBehaviorsMatch('append', 'ab', 'other contents')
+        self._create_test_file("f", "read", "some contents")
+        self._create_test_file("f", "write", "some contents")
+        self._create_test_file("f", "append", "some contents")
+        self.assertFileHandleBehaviorsMatch("read", "r", "other contents")
+        self.assertFileHandleBehaviorsMatch("write", "w", "other contents")
+        self.assertFileHandleBehaviorsMatch("append", "a", "other contents")
+        self._create_test_file("f", "readplus", "some contents")
+        self._create_test_file("f", "writeplus", "some contents")
+        self.assertFileHandleBehaviorsMatch("readplus", "r+", "other contents")
+        self.assertFileHandleBehaviorsMatch("writeplus", "w+", "other contents")
+        self._create_test_file("b", "binaryread", b"some contents")
+        self._create_test_file("b", "binarywrite", b"some contents")
+        self._create_test_file("b", "binaryappend", b"some contents")
+        self.assertFileHandleBehaviorsMatch("binaryread", "rb", b"other contents")
+        self.assertFileHandleBehaviorsMatch("binarywrite", "wb", b"other contents")
+        self.assertFileHandleBehaviorsMatch("binaryappend", "ab", b"other contents")
+        self.assertFileHandleBehaviorsMatch("read", "rb", "other contents")
+        self.assertFileHandleBehaviorsMatch("write", "wb", "other contents")
+        self.assertFileHandleBehaviorsMatch("append", "ab", "other contents")
 
         # binary cannot have encoding
-        self.assertFileHandleOpenBehaviorsMatch('read', 'rb', encoding='enc')
-        self.assertFileHandleOpenBehaviorsMatch(
-            'write', mode='wb', encoding='enc')
-        self.assertFileHandleOpenBehaviorsMatch('append', 'ab', encoding='enc')
+        self.assertFileHandleOpenBehaviorsMatch("read", "rb", encoding="enc")
+        self.assertFileHandleOpenBehaviorsMatch("write", mode="wb", encoding="enc")
+        self.assertFileHandleOpenBehaviorsMatch("append", "ab", encoding="enc")
 
         # text can have encoding
-        self.assertFileHandleOpenBehaviorsMatch('read', 'r', encoding='utf-8')
-        self.assertFileHandleOpenBehaviorsMatch('write', 'w', encoding='utf-8')
-        self.assertFileHandleOpenBehaviorsMatch(
-            'append', 'a', encoding='utf-8')
+        self.assertFileHandleOpenBehaviorsMatch("read", "r", encoding="utf-8")
+        self.assertFileHandleOpenBehaviorsMatch("write", "w", encoding="utf-8")
+        self.assertFileHandleOpenBehaviorsMatch("append", "a", encoding="utf-8")
 
 
 def main(_):
     unittest.main()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()