[Telemetry] Add pyfakefs to telemetry/third_party

tools/telemetry/third_party/pyfakefs/pyfakefs/fake_filesystem_vs_real_test.py

Index: tools/telemetry/third_party/pyfakefs/pyfakefs/fake_filesystem_vs_real_test.py
diff --git a/tools/telemetry/third_party/pyfakefs/pyfakefs/fake_filesystem_vs_real_test.py b/tools/telemetry/third_party/pyfakefs/pyfakefs/fake_filesystem_vs_real_test.py
new file mode 100755
index 0000000000000000000000000000000000000000..9da1bc8f977183e9753cb5cf4b6b7e93c630a07e
--- /dev/null
+++ b/tools/telemetry/third_party/pyfakefs/pyfakefs/fake_filesystem_vs_real_test.py
@@ -0,0 +1,612 @@
+#! /usr/bin/env python
+#
+# Copyright 2009 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#            http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Test that FakeFilesystem calls work identically to a real filesystem."""
+
+#pylint: disable-all
+
+import os #@UnusedImport
+import os.path
+import shutil
+import sys
+import tempfile
+import time
+import sys
+if sys.version_info < (2, 7):
+    import unittest2 as unittest
+else:
+    import unittest
+
+import fake_filesystem
+
+
+def Sep(path):
+    """Converts slashes in the path to the architecture's path seperator."""
+    if isinstance(path, str):
+        return path.replace('/', os.sep)
+    return path
+
+
+class TestCase(unittest.TestCase):
+    is_windows = sys.platform.startswith('win')
+    is_cygwin = sys.platform == 'cygwin'
+    _FAKE_FS_BASE = Sep('/fakefs')
+
+
+class FakeFilesystemVsRealTest(TestCase):
+
+    def _Paths(self, path):
+        """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))
+
+    def _CreateTestFile(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':
+            os.mkdir(real_path)
+            self.fake_os.mkdir(fake_path)
+        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.close()
+        # b for binary file
+        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.close()
+        # l for symlink, h for hard link
+        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':
+                os.symlink(real_target, real_path)
+                self.fake_os.symlink(fake_target, fake_path)
+            elif file_type == 'h':
+                os.link(real_target, real_path)
+                self.fake_os.link(fake_target, fake_path)
+
+    def setUp(self):
+        # 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()
+        # Fully expand the base_path - required on OS X.
+        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)
+        os.mkdir(self.real_base)
+        self.fake_base = self._FAKE_FS_BASE
+
+        # Make sure we can write to the physical testing temp directory.
+        self.assertTrue(os.access(self.real_base, os.W_OK))
+
+        self.fake_filesystem = fake_filesystem.FakeFilesystem()
+        self.fake_filesystem.CreateDirectory(self.fake_base)
+        self.fake_os = fake_filesystem.FakeOsModule(self.fake_filesystem)
+        self.fake_open = fake_filesystem.FakeFileOpen(self.fake_filesystem)
+        self._created_files = []
+
+        os.chdir(self.real_base)
+        self.fake_os.chdir(self.fake_base)
+
+    def tearDown(self):
+        # We have to remove all the files from the real FS. Doing the same for the
+        # fake FS is optional, but doing it is an extra sanity check.
+        os.chdir(tempfile.gettempdir())
+        try:
+            rev_files = self._created_files[:]
+            rev_files.reverse()
+            for info in rev_files:
+                real_path, fake_path = self._Paths(info[1])
+                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)))
+                        else:
+                            raise
+                    self.fake_os.rmdir(fake_path)
+                if info[0] == 'f' or info[0] == 'l':
+                    os.remove(real_path)
+                    self.fake_os.remove(fake_path)
+        finally:
+            shutil.rmtree(self.real_base)
+
+    def _GetErrno(self, raised_error):
+        try:
+            return (raised_error and raised_error.errno) or None
+        except AttributeError:
+            return None
+
+    def _CompareBehaviors(self, method_name, path, real, fake,
+                                                method_returns_path=False):
+        """Invoke an os method in both real and fake contexts and compare results.
+
+        Invoke a real filesystem method with a path to a real file and invoke a fake
+        filesystem method with a path to a fake file and compare the results.    We
+        expect some calls to throw Exceptions, so we catch those and compare them.
+
+        Args:
+            method_name: Name of method being tested, for use in error messages.
+            path: potential path to a file in the real and fake file systems, passing
+                an empty tuple indicates that no arguments to pass to method.
+            real: built-in system library or method from the built-in system library
+                which takes a path as an arg and returns some value.
+            fake: fake_filsystem object or method from a fake_filesystem class
+                which takes a path as an arg and returns some value.
+            method_returns_path: True if the method returns a path, and thus we must
+                compensate for expected difference between real and fake.
+
+        Returns:
+            A description of the difference in behavior, or None.
+        """
+        # pylint: disable=C6403
+
+        def _ErrorClass(e):
+            return (e and e.__class__.__name__) or 'None'
+
+        real_value = None
+        fake_value = None
+        real_err = None
+        fake_err = None
+        method_call = '%s' % method_name
+        method_call += '()' if path == () else '(%s)' % path
+        # Catching Exception below gives a lint warning, but it's what we need.
+        try:
+            args = [] if path == () else [path]
+            real_method = real
+            if not callable(real):
+                real_method = getattr(real, method_name)
+            real_value = str(real_method(*args))
+        except Exception as e:    # pylint: disable-msg=W0703
+            real_err = e
+        try:
+            fake_method = fake
+            if not callable(fake):
+                fake_method = getattr(fake, method_name)
+            args = [] if path == () else [path]
+            fake_value = str(fake_method(*args))
+        except Exception as e:    # pylint: disable-msg=W0703
+            fake_err = e
+        # We only compare on the error class because the acutal error contents
+        # is almost always different because of the file paths.
+        if _ErrorClass(real_err) != _ErrorClass(fake_err):
+            if real_err is None:
+                return '%s: real version returned %s, fake raised %s' % (
+                        method_call, real_value, _ErrorClass(fake_err))
+            if fake_err is None:
+                return '%s: real version raised %s, fake returned %s' % (
+                        method_call, _ErrorClass(real_err), fake_value)
+            return '%s: real version raised %s, fake raised %s' % (
+                    method_call, _ErrorClass(real_err), _ErrorClass(fake_err))
+        real_errno = self._GetErrno(real_err)
+        fake_errno = self._GetErrno(fake_err)
+        if real_errno != fake_errno:
+            return '%s(%s): both raised %s, real errno %s, fake errno %s' % (
+                    method_name, path, _ErrorClass(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 != fake_value:
+            return '%s: real return %s, fake returned %s' % (
+                    method_call, real_value, fake_value)
+        return None
+
+    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
+        behavior of the system provided module against the fake_filesytem module.
+        We expect results and/or Exceptions raised to be identical.
+
+        Args:
+            method_name: Name of method being tested.
+            path: potential path to a file in the real and fake file systems.
+            method_returns_path: True if the method returns a path, and thus we must
+                compensate for expected difference between real and fake.
+
+        Returns:
+            A description of the difference in behavior, or None.
+        """
+        path = Sep(path)
+        return self._CompareBehaviors(method_name, path, os, self.fake_os,
+                                                                    method_returns_path)
+
+    def DiffOpenMethodBehavior(self, method_name, path, mode, data,
+                                                         method_returns_data=True):
+        """Invoke an open method in both real and fkae contexts and compare.
+
+        Args:
+            method_name: Name of method being tested.
+            path: potential path to a file in the real and fake file systems.
+            mode: how to open the file.
+            data: any data to pass to the method.
+            method_returns_data: True if a method returns some sort of data.
+
+        For a given method name (from builtin open) and a path, compare the
+        behavior of the system provided module against the fake_filesytem module.
+        We expect results and/or Exceptions raised to be identical.
+
+        Returns:
+            A description of the difference in behavior, or None.
+        """
+        with open(path, mode) as real_fh:
+            with self.fake_open(path, mode) as fake_fh:
+                return self._CompareBehaviors(method_name, data, real_fh, fake_fh,
+                                                                            method_returns_data)
+
+    def DiffOsPathMethodBehavior(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 the
+        behavior of the system provided module against the fake_filesytem module.
+        We expect results and/or Exceptions raised to be identical.
+
+        Args:
+            method_name: Name of method being tested.
+            path: potential path to a file in the real and fake file systems.
+            method_returns_path: True if the method returns a path, and thus we must
+                compensate for expected difference between real and fake.
+
+        Returns:
+            A description of the difference in behavior, or None.
+        """
+        return self._CompareBehaviors(method_name, path, os.path, self.fake_os.path,
+                                                                    method_returns_path)
+
+    def assertOsPathMethodBehaviorMatches(self, method_name, path,
+                                                                                method_returns_path=False):
+        """Assert that an os.path behaves the same in both real and fake contexts.
+
+        Wraps DiffOsPathMethodBehavior, raising AssertionError if any differences
+        are reported.
+
+        Args:
+            method_name: Name of method being tested.
+            path: potential path to a file in the real and fake file systems.
+            method_returns_path: True if the method returns a path, and thus we must
+                compensate for expected difference between real and fake.
+
+        Raises:
+            AssertionError if there is any difference in behavior.
+        """
+        path = Sep(path)
+        diff = self.DiffOsPathMethodBehavior(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']
+        if sys.version_info < (3, 0):
+            os_method_names_no_args.append('getcwdu')
+        os_path_method_names = ['isabs',
+                                                        'isdir',
+                                                        'isfile',
+                                                        'exists'
+                                                     ]
+        if not self.is_windows:
+            os_path_method_names.append('islink')
+            os_path_method_names.append('lexists')
+        wrapped_methods = [['access', self._AccessReal, self._AccessFake],
+                                             ['stat.size', self._StatSizeReal, self._StatSizeFake],
+                                             ['lstat.size', self._LstatSizeReal, self._LstatSizeFake]
+                                            ]
+
+        differences = []
+        for method_name in os_method_names:
+            diff = self.assertOsMethodBehaviorMatches(method_name, path)
+            if diff:
+                differences.append(diff)
+        for method_name in os_method_names_no_args:
+            diff = self.assertOsMethodBehaviorMatches(method_name, (),
+                                                                                                method_returns_path=True)
+            if diff:
+                differences.append(diff)
+        for method_name in os_path_method_names:
+            diff = self.DiffOsPathMethodBehavior(method_name, path)
+            if diff:
+                differences.append(diff)
+        for m in wrapped_methods:
+            diff = self._CompareBehaviors(m[0], path, m[1], m[2])
+            if diff:
+                differences.append(diff)
+        if 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']
+        differences = []
+        for method_name in write_method_names:
+            diff = self.DiffOpenMethodBehavior(method_name, path, mode, data)
+            if diff:
+                differences.append(diff)
+        for method_name in read_method_names + other_method_names:
+            diff = self.DiffOpenMethodBehavior(method_name, path, mode, ())
+            if diff:
+                differences.append(diff)
+        if differences:
+            self.fail('Behaviors do not match for %s:\n    %s' %
+                                (path, '\n    '.join(differences)))
+
+    # Helpers for checks which are not straight method calls.
+
+    def _AccessReal(self, path):
+        return os.access(path, os.R_OK)
+
+    def _AccessFake(self, path):
+        return self.fake_os.access(path, os.R_OK)
+
+    def _StatSizeReal(self, path):
+        real_path, unused_fake_path = self._Paths(path)
+        # fake_filesystem.py does not implement stat().st_size for directories
+        if os.path.isdir(real_path):
+            return None
+        return os.stat(real_path).st_size
+
+    def _StatSizeFake(self, path):
+        unused_real_path, fake_path = self._Paths(path)
+        # fake_filesystem.py does not implement stat().st_size for directories
+        if self.fake_os.path.isdir(fake_path):
+            return None
+        return self.fake_os.stat(fake_path).st_size
+
+    def _LstatSizeReal(self, path):
+        real_path, unused_fake_path = self._Paths(path)
+        if os.path.isdir(real_path):
+            return None
+        size = os.lstat(real_path).st_size
+        # Account for the difference in the lengths of the absolute paths.
+        if os.path.islink(real_path):
+            if os.readlink(real_path).startswith(os.sep):
+                size -= len(self.real_base)
+        return size
+
+    def _LstatSizeFake(self, path):
+        unused_real_path, fake_path = self._Paths(path)
+        #size = 0
+        if self.fake_os.path.isdir(fake_path):
+            return None
+        size = self.fake_os.lstat(fake_path).st_size
+        # Account for the difference in the lengths of the absolute paths.
+        if self.fake_os.path.islink(fake_path):
+            if self.fake_os.readlink(fake_path).startswith(os.sep):
+                size -= len(self.fake_base)
+        return size
+
+    def testIsabs(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')
+
+    def testNonePath(self):
+        self.assertAllOsBehaviorsMatch(None)
+
+    def testEmptyPath(self):
+        self.assertAllOsBehaviorsMatch('')
+
+    def testRootPath(self):
+        self.assertAllOsBehaviorsMatch('/')
+
+    def testNonExistantFile(self):
+        self.assertAllOsBehaviorsMatch('foo')
+
+    def testEmptyFile(self):
+        self._CreateTestFile('f', 'aFile')
+        self.assertAllOsBehaviorsMatch('aFile')
+
+    def testFileWithContents(self):
+        self._CreateTestFile('f', 'aFile', 'some contents')
+        self.assertAllOsBehaviorsMatch('aFile')
+
+    def testFileWithBinaryContents(self):
+        self._CreateTestFile('b', 'aFile', b'some contents')
+        self.assertAllOsBehaviorsMatch('aFile')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testSymLinkToEmptyFile(self):
+        self._CreateTestFile('f', 'aFile')
+        self._CreateTestFile('l', 'link_to_empty', 'aFile')
+        self.assertAllOsBehaviorsMatch('link_to_empty')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def TBD_testHardLinkToEmptyFile(self):
+        self._CreateTestFile('f', 'aFile')
+        self._CreateTestFile('h', 'link_to_empty', 'aFile')
+        self.assertAllOsBehaviorsMatch('link_to_empty')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testSymLinkToRealFile(self):
+        self._CreateTestFile('f', 'aFile', 'some contents')
+        self._CreateTestFile('l', 'link_to_file', 'aFile')
+        self.assertAllOsBehaviorsMatch('link_to_file')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def TBD_testHardLinkToRealFile(self):
+        self._CreateTestFile('f', 'aFile', 'some contents')
+        self._CreateTestFile('h', 'link_to_file', 'aFile')
+        self.assertAllOsBehaviorsMatch('link_to_file')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testBrokenSymLink(self):
+        self._CreateTestFile('l', 'broken_link', 'broken')
+        self._CreateTestFile('l', 'loop', '/a/loop')
+        self.assertAllOsBehaviorsMatch('broken_link')
+
+    def testFileInAFolder(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('f', 'a/b/file', 'contents')
+        self.assertAllOsBehaviorsMatch('a/b/file')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testAbsoluteSymLinkToFolder(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('f', 'a/b/file', 'contents')
+        self._CreateTestFile('l', 'a/link', '/a/b')
+        self.assertAllOsBehaviorsMatch('a/link/file')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testLinkToFolderAfterChdir(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('f', 'a/b/file', 'contents')
+        self._CreateTestFile('l', 'a/link', '/a/b')
+
+        real_dir, fake_dir = self._Paths('a/b')
+        os.chdir(real_dir)
+        self.fake_os.chdir(fake_dir)
+        self.assertAllOsBehaviorsMatch('file')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testRelativeSymLinkToFolder(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('f', 'a/b/file', 'contents')
+        self._CreateTestFile('l', 'a/link', 'b')
+        self.assertAllOsBehaviorsMatch('a/link/file')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testSymLinkToParent(self):
+        # Soft links on HFS+ / OS X behave differently.
+        if os.uname()[0] != 'Darwin':
+            self._CreateTestFile('d', 'a')
+            self._CreateTestFile('d', 'a/b')
+            self._CreateTestFile('l', 'a/b/c', '..')
+            self.assertAllOsBehaviorsMatch('a/b/c')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testPathThroughSymLinkToParent(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('f', 'a/target', 'contents')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('l', 'a/b/c', '..')
+        self.assertAllOsBehaviorsMatch('a/b/c/target')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testSymLinkToSiblingDirectory(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('d', 'a/sibling_of_b')
+        self._CreateTestFile('f', 'a/sibling_of_b/target', 'contents')
+        self._CreateTestFile('l', 'a/b/c', '../sibling_of_b')
+        self.assertAllOsBehaviorsMatch('a/b/c/target')
+
+    @unittest.skipIf(TestCase.is_windows, 'no symlink in Windows')
+    def testSymLinkToSiblingDirectoryNonExistantFile(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('d', 'a/sibling_of_b')
+        self._CreateTestFile('f', 'a/sibling_of_b/target', 'contents')
+        self._CreateTestFile('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 testBrokenSymLinkToSiblingDirectory(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('d', 'a/sibling_of_b')
+        self._CreateTestFile('f', 'a/sibling_of_b/target', 'contents')
+        self._CreateTestFile('l', 'a/b/c', '../broken_sibling_of_b')
+        self.assertAllOsBehaviorsMatch('a/b/c/target')
+
+    def testRelativePath(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('d', 'a/sibling_of_b')
+        self._CreateTestFile('f', 'a/sibling_of_b/target', 'contents')
+        self.assertAllOsBehaviorsMatch('a/b/../sibling_of_b/target')
+
+    def testBrokenRelativePath(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('d', 'a/sibling_of_b')
+        self._CreateTestFile('f', 'a/sibling_of_b/target', 'contents')
+        self.assertAllOsBehaviorsMatch('a/b/../broken/target')
+
+    def testBadRelativePath(self):
+        self._CreateTestFile('d', 'a')
+        self._CreateTestFile('f', 'a/target', 'contents')
+        self._CreateTestFile('d', 'a/b')
+        self._CreateTestFile('d', 'a/sibling_of_b')
+        self._CreateTestFile('f', 'a/sibling_of_b/target', 'contents')
+        self.assertAllOsBehaviorsMatch('a/b/../broken/../target')
+
+    def testGetmtimeNonexistantPath(self):
+        self.assertOsPathMethodBehaviorMatches('getmtime', 'no/such/path')
+
+    def testBuiltinOpenModes(self):
+        self._CreateTestFile('f', 'read', 'some contents')
+        self._CreateTestFile('f', 'write', 'some contents')
+        self._CreateTestFile('f', 'append', 'some contents')
+        self.assertFileHandleBehaviorsMatch('read', 'r', 'other contents')
+        self.assertFileHandleBehaviorsMatch('write', 'w', 'other contents')
+        self.assertFileHandleBehaviorsMatch('append', 'a', 'other contents')
+        self._CreateTestFile('f', 'readplus', 'some contents')
+        self._CreateTestFile('f', 'writeplus', 'some contents')
+        self.assertFileHandleBehaviorsMatch('readplus', 'r+', 'other contents')
+        self.assertFileHandleBehaviorsMatch('writeplus', 'w+', 'other contents')
+        self._CreateTestFile('b', 'binaryread', b'some contents')
+        self._CreateTestFile('b', 'binarywrite', b'some contents')
+        self._CreateTestFile('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')
+
+
+def main(unused_argv):
+    unittest.main()
+
+
+if __name__ == '__main__':
+    unittest.main()