Remove _unit_test_config hack, instead use FileSystem() in cpp.py & cpp_unittest.py

Tools/Scripts/webkitpy/style/checkers/cpp_unittest.py

 # -*- coding: utf-8; -*-
 #
 # Copyright (C) 2011 Google Inc. All rights reserved.
 # Copyright (C) 2009 Torch Mobile Inc.
 # Copyright (C) 2009 Apple Inc. All rights reserved.
 # Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
@@ skipping 17 matching lines @@
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 """Unit test for cpp_style.py."""
 
 # FIXME: Add a good test that tests UpdateIncludeState.
 
-import codecs
 import os
 import random
 import re
 import webkitpy.thirdparty.unittest2 as unittest
 import cpp as cpp_style
 from cpp import CppChecker
 from ..filter import FilterConfiguration
+from webkitpy.common.system.filesystem import FileSystem
 
 # This class works as an error collector and replaces cpp_style.Error
 # function for the unit tests.  We also verify each category we see
 # is in STYLE_CATEGORIES, to help keep that list up to date.
 class ErrorCollector:
     _all_style_categories = CppChecker.categories
     # This is a list including all categories seen in any unit test.
     _seen_style_categories = {}
 
     def __init__(self, assert_fn, filter=None, lines_to_check=None):
@@ skipping 36 matching lines @@
         this isn't called from within the normal unittest framework, we
         can't use the normal unittest assert macros.  Instead we just exit
         when we see an error.  Good thing this test is always run last!
         """
         for category in self._all_style_categories:
             if category not in self._seen_style_categories:
                 import sys
                 sys.exit('FATAL ERROR: There are no tests for category "%s"' % category)
 
 
-# This class is a lame mock of codecs. We do not verify filename, mode, or
-# encoding, but for the current use case it is not needed.
-class MockIo:
-    def __init__(self, mock_file):
-        self.mock_file = mock_file
-
-    def open(self, unused_filename, unused_mode, unused_encoding, _):  # NOLINT
-        # (lint doesn't like open as a method name)
-        return self.mock_file
-
-
 class CppFunctionsTest(unittest.TestCase):
 
     """Supports testing functions that do not need CppStyleTestBase."""
 
     def test_convert_to_lower_with_underscores(self):
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('ABC'), 'abc')
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('aB'), 'a_b')
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('isAName'), 'is_a_name')
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('AnotherTest'), 'another_test')
         self.assertEqual(cpp_style._convert_to_lower_with_underscores('PassRefPtr<MyClass>'), 'pass_ref_ptr<my_class>')
@@ skipping 116 matching lines @@
                       level for the tests.
 
     """
 
     # FIXME: Refactor the unit tests so the confidence level is passed
     #        explicitly, just like it is in the real code.
     min_confidence = 1;
 
     # Helper function to avoid needing to explicitly pass confidence
     # in all the unit test calls to cpp_style.process_file_data().
-    def process_file_data(self, filename, file_extension, lines, error, unit_test_config={}):
+    def process_file_data(self, filename, file_extension, lines, error, fs=None):
         """Call cpp_style.process_file_data() with the min_confidence."""
         return cpp_style.process_file_data(filename, file_extension, lines,
-                                           error, self.min_confidence, unit_test_config)
+                                           error, self.min_confidence, fs)
 
-    def perform_lint(self, code, filename, basic_error_rules, unit_test_config={}, lines_to_check=None):
+    def perform_lint(self, code, filename, basic_error_rules, fs=None, lines_to_check=None):
         error_collector = ErrorCollector(self.assertTrue, FilterConfiguration(basic_error_rules), lines_to_check)
         lines = code.split('\n')
         extension = filename.split('.')[1]
-        self.process_file_data(filename, extension, lines, error_collector, unit_test_config)
+        self.process_file_data(filename, extension, lines, error_collector, fs)
         return error_collector.results()
 
     # Perform lint on single line of input and return the error message.
     def perform_single_line_lint(self, code, filename):
         basic_error_rules = ('-build/header_guard',
                              '-legal/copyright',
                              '-readability/fn_size',
                              '-readability/parameter_name',
                              '-readability/pass_ptr',
                              '-whitespace/ending_newline')
@@ skipping 28 matching lines @@
                              '+readability/pass_ptr')
         return self.perform_lint(code, 'test.cpp', basic_error_rules)
 
     # Only keep leaky pattern errors.
     def perform_leaky_pattern_check(self, code):
         basic_error_rules = ('-',
                              '+runtime/leaky_pattern')
         return self.perform_lint(code, 'test.cpp', basic_error_rules)
 
     # Only include what you use errors.
-    def perform_include_what_you_use(self, code, filename='foo.h', io=codecs):
+    def perform_include_what_you_use(self, code, filename='foo.h', fs=None):
         basic_error_rules = ('-',
                              '+build/include_what_you_use')
-        unit_test_config = {cpp_style.INCLUDE_IO_INJECTION_KEY: io}
-        return self.perform_lint(code, filename, basic_error_rules, unit_test_config)
+        return self.perform_lint(code, filename, basic_error_rules, fs)
 
-    def perform_avoid_static_cast_of_objects(self, code, filename='foo.cpp', io=codecs):
+    def perform_avoid_static_cast_of_objects(self, code, filename='foo.cpp', fs=None):
         basic_error_rules = ('-',
                              '+runtime/casting')
-        unit_test_config = {cpp_style.INCLUDE_IO_INJECTION_KEY: io}
-        return self.perform_lint(code, filename, basic_error_rules, unit_test_config)
+        return self.perform_lint(code, filename, basic_error_rules, fs)
 
     # Perform lint and compare the error message with "expected_message".
     def assert_lint(self, code, expected_message, file_name='foo.cpp'):
         self.assertEqual(expected_message, self.perform_single_line_lint(code, file_name))
 
     def assert_lint_one_of_many_errors_re(self, code, expected_message_re, file_name='foo.cpp'):
         messages = self.perform_single_line_lint(code, file_name)
         for message in messages:
             if re.search(expected_message_re, message):
                 return
@@ skipping 438 matching lines @@
             'Do not use dynamic_cast<>.  If you need to cast within a class '
             'hierarchy, use static_cast<> to upcast.  Google doesn\'t support '
             'RTTI.  [runtime/rtti] [5]')
         # dynamic_cast is disallowed in most files.
         self.assert_language_rules_check('foo.cpp', statement, error_message)
         self.assert_language_rules_check('foo.h', statement, error_message)
 
     # Tests for static_cast readability.
     def test_static_cast_on_objects_with_toFoo(self):
         mock_header_contents = ['inline Foo* toFoo(Bar* bar)']
-        message = self.perform_avoid_static_cast_of_objects(
-            'Foo* x = static_cast<Foo*>(bar);',
-            filename='casting.cpp',
-            io=MockIo(mock_header_contents))
-        self.assertEqual(message, 'static_cast of class objects is not allowed. Use toFoo defined in Foo.h.'
-                                  '  [runtime/casting] [4]')
+        fs = FileSystem()
+        orig_read_text_file_fn = fs.read_text_file
+
+        def mock_read_text_file_fn(path):
+            return mock_header_contents
+
+        try:
+            fs.read_text_file = mock_read_text_file_fn
+            message = self.perform_avoid_static_cast_of_objects(
+                'Foo* x = static_cast<Foo*>(bar);',
+                filename='casting.cpp',
+                fs=fs)
+            self.assertEqual(message, 'static_cast of class objects is not allowed. Use toFoo defined in Foo.h.'
+                                      '  [runtime/casting] [4]')
+        finally:
+            fs.read_text_file = orig_read_text_file_fn
 
     def test_static_cast_on_objects_without_toFoo(self):
         mock_header_contents = ['inline FooBar* toFooBar(Bar* bar)']
-        message = self.perform_avoid_static_cast_of_objects(
-            'Foo* x = static_cast<Foo*>(bar);',
-            filename='casting.cpp',
-            io=MockIo(mock_header_contents))
-        self.assertEqual(message, 'static_cast of class objects is not allowed. Add toFoo in Foo.h and use it instead.'
-                                  '  [runtime/casting] [4]')
+        fs = FileSystem()
+        orig_read_text_file_fn = fs.read_text_file
+
+        def mock_read_text_file_fn(path):
+            return mock_header_contents
+
+        try:
+            fs.read_text_file = mock_read_text_file_fn
+            message = self.perform_avoid_static_cast_of_objects(
+                'Foo* x = static_cast<Foo*>(bar);',
+                filename='casting.cpp',
+                fs=fs)
+            self.assertEqual(message, 'static_cast of class objects is not allowed. Add toFoo in Foo.h and use it instead.'
+                                      '  [runtime/casting] [4]')
+        finally:
+            fs.read_text_file = orig_read_text_file_fn
 
     # We cannot test this functionality because of difference of
     # function definitions.  Anyway, we may never enable this.
     #
     # # Test for unnamed arguments in a method.
     # def test_check_for_unnamed_params(self):
     #   message = ('All parameters should be named in a function'
     #              '  [readability/function] [3]')
     #   self.assert_lint('virtual void A(int*) const;', message)
     #   self.assert_lint('virtual void B(void (*fn)(int*));', message)
@@ skipping 206 matching lines @@
             'Add #include <limits> for numeric_limits<>'
             '  [build/include_what_you_use] [4]')
         self.assert_include_what_you_use(
             '''#include <limits>
                int i = numeric_limits<int>::max()
             ''',
             '')
 
         # Test the UpdateIncludeState code path.
         mock_header_contents = ['#include "blah/foo.h"', '#include "blah/bar.h"']
-        message = self.perform_include_what_you_use(
-            '#include "config.h"\n'
-            '#include "blah/a.h"\n',
-            filename='blah/a.cpp',
-            io=MockIo(mock_header_contents))
-        self.assertEqual(message, '')
+        fs = FileSystem()
+        orig_read_text_file_fn = fs.read_text_file
 
-        mock_header_contents = ['#include <set>']
-        message = self.perform_include_what_you_use(
-            '''#include "config.h"
-               #include "blah/a.h"
+        def mock_read_text_file_fn(path):
+            return mock_header_contents
 
-               std::set<int> foo;''',
-            filename='blah/a.cpp',
-            io=MockIo(mock_header_contents))
-        self.assertEqual(message, '')
+        try:
+            fs.read_text_file = mock_read_text_file_fn
+            message = self.perform_include_what_you_use(
+                '#include "config.h"\n'
+                '#include "blah/a.h"\n',
+                filename='blah/a.cpp',
+                fs=fs)
+            self.assertEqual(message, '')
 
-        # If there's just a .cpp and the header can't be found then it's ok.
-        message = self.perform_include_what_you_use(
-            '''#include "config.h"
-               #include "blah/a.h"
+            mock_header_contents = ['#include <set>']
+            message = self.perform_include_what_you_use(
+                '''#include "config.h"
+                   #include "blah/a.h"
 
-               std::set<int> foo;''',
-            filename='blah/a.cpp')
-        self.assertEqual(message, '')
+                   std::set<int> foo;''',
+                filename='blah/a.cpp',
+                fs=fs)
+            self.assertEqual(message, '')
 
-        # Make sure we find the headers with relative paths.
-        mock_header_contents = ['']
-        message = self.perform_include_what_you_use(
-            '''#include "config.h"
-               #include "%s%sa.h"
+            # If there's just a .cpp and the header can't be found then it's ok.
+            message = self.perform_include_what_you_use(
+                '''#include "config.h"
+                   #include "blah/a.h"
 
-               std::set<int> foo;''' % (os.path.basename(os.getcwd()), os.path.sep),
-            filename='a.cpp',
-            io=MockIo(mock_header_contents))
-        self.assertEqual(message, 'Add #include <set> for set<>  '
-                                   '[build/include_what_you_use] [4]')
+                   std::set<int> foo;''',
+                filename='blah/a.cpp')
+            self.assertEqual(message, '')
+
+            # Make sure we find the headers with relative paths.
+            mock_header_contents = ['']
+            message = self.perform_include_what_you_use(
+                '''#include "config.h"
+                   #include "%s%sa.h"
+
+                   std::set<int> foo;''' % (os.path.basename(os.getcwd()), os.path.sep),
+                filename='a.cpp',
+                fs=fs)
+            self.assertEqual(message, 'Add #include <set> for set<>  '
+                                       '[build/include_what_you_use] [4]')
+        finally:
+            fs.read_text_file = orig_read_text_file_fn
 
     def test_files_belong_to_same_module(self):
         f = cpp_style.files_belong_to_same_module
         self.assertEqual((True, ''), f('a.cpp', 'a.h'))
         self.assertEqual((True, ''), f('base/google.cpp', 'base/google.h'))
         self.assertEqual((True, ''), f('base/google_test.cpp', 'base/google.h'))
         self.assertEqual((True, ''),
                           f('base/google_unittest.cpp', 'base/google.h'))
         self.assertEqual((True, ''),
                           f('base/internal/google_unittest.cpp',
@@ skipping 4104 matching lines @@
     def test_ne(self):
         """Test __ne__ inequality function."""
         checker1 = self._checker()
         checker2 = self._checker()
 
         # != calls __ne__.
         # By default, __ne__ always returns true on different objects.
         # Thus, just check the distinguishing case to verify that the
         # code defines __ne__.
         self.assertFalse(checker1 != checker2)