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

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

 # -*- coding: utf-8 -*-
 #
 # Copyright (C) 2009, 2010, 2012 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 18 matching lines @@
 # 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.
 
 # This is the modified version of Google's cpplint. The original code is
 # http://google-styleguide.googlecode.com/svn/trunk/cpplint/cpplint.py
 
 """Support for check-webkit-style."""
 
-import codecs
 import math  # for log
 import os
 import os.path
 import re
 import sre_compile
 import string
 import sys
 import unicodedata
 
 from webkitpy.common.memoized import memoized
 from webkitpy.common.system.filesystem import FileSystem
 
-# The key to use to provide a class to fake loading a header file.
-INCLUDE_IO_INJECTION_KEY = 'include_header_io'
-
 # Headers that we consider STL headers.
 _STL_HEADERS = frozenset([
     'algobase.h', 'algorithm', 'alloc.h', 'bitset', 'deque', 'exception',
     'function.h', 'functional', 'hash_map', 'hash_map.h', 'hash_set',
     'hash_set.h', 'iterator', 'list', 'list.h', 'map', 'memory', 'pair.h',
     'pthread_alloc', 'queue', 'set', 'set.h', 'sstream', 'stack',
     'stl_alloc.h', 'stl_relops.h', 'type_traits.h',
     'utility', 'vector', 'vector.h',
     ])
 
@@ skipping 50 matching lines @@
 
 
 # These constants define types of headers for use with
 # _IncludeState.check_next_include_order().
 _CONFIG_HEADER = 0
 _PRIMARY_HEADER = 1
 _OTHER_HEADER = 2
 _MOC_HEADER = 3
 
 
-# A dictionary of items customize behavior for unit test. For example,
-# INCLUDE_IO_INJECTION_KEY allows providing a custom io class which allows
-# for faking a header file.
-_unit_test_config = {}
-
-
 # The regexp compilation caching is inlined in all regexp functions for
 # performance reasons; factoring it out into a separate function turns out
 # to be noticeably expensive.
 _regexp_compile_cache = {}
 
 
 def match(pattern, s):
     """Matches the string with the pattern, caching the compiled regexp."""
     if not pattern in _regexp_compile_cache:
         _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
@@ skipping 3319 matching lines @@
                         matches.append([line, function_state.body_start_position.row, function_state.end_position.row + 1])
                         function_state = None
             except UnicodeDecodeError:
                 # There would be no non-ascii characters in the codebase ever. The only exception
                 # would be comments/copyright text which might have non-ascii characters. Hence,
                 # it is prefectly safe to catch the UnicodeDecodeError and just pass the line.
                 pass
 
         return matches
 
-    def check_in_mock_header(filename, matches=None, io=codecs):
+    def check_in_mock_header(filename, matches=None):
         if not filename == 'Foo.h':
             return False
 
-        io = _unit_test_config.get(INCLUDE_IO_INJECTION_KEY, codecs)
         header_file = None
         try:
-            header_file = io.open(filename, 'r', 'utf8', 'replace')
+            header_file = CppChecker.fs.read_text_file(filename, 'replace')
         except IOError:
             return False
         line_number = 0
         for line in header_file:
             line_number += 1
             matched = re.search(r'\btoFoo\b', line)
             if matched:
                 matches.append(['toFoo', line_number, line_number + 3])
         return True
 
@@ skipping 236 matching lines @@
     filename_h = filename_h.replace('/public/', '/')
     filename_h = filename_h.replace('/internal/', '/')
 
     files_belong_to_same_module = filename_cpp.endswith(filename_h)
     common_path = ''
     if files_belong_to_same_module:
         common_path = filename_cpp[:-len(filename_h)]
     return files_belong_to_same_module, common_path
 
 
-def update_include_state(filename, include_state, io=codecs):
+def update_include_state(filename, include_state):
     """Fill up the include_state with new includes found from the file.
 
     Args:
       filename: the name of the header to read.
       include_state: an _IncludeState instance in which the headers are inserted.
       io: The io factory to use to read the file. Provided for testability.
 
     Returns:
       True if a header was succesfully added. False otherwise.
     """
-    io = _unit_test_config.get(INCLUDE_IO_INJECTION_KEY, codecs)
     header_file = None
     try:
-        header_file = io.open(filename, 'r', 'utf8', 'replace')
+        header_file = CppChecker.fs.read_text_file(filename, 'replace')
     except IOError:
         return False
     line_number = 0
     for line in header_file:
         line_number += 1
         clean_line = cleanse_comments(line)
         matched = _RE_PATTERN_INCLUDE.search(clean_line)
         if matched:
             include = matched.group(2)
             # The value formatting is cute, but not really used right now.
@@ skipping 247 matching lines @@
         'whitespace/indent',
         'whitespace/line_length',
         'whitespace/newline',
         'whitespace/operators',
         'whitespace/parens',
         'whitespace/semicolon',
         'whitespace/tab',
         'whitespace/todo',
         ])
 
+    fs = None
+
     def __init__(self, file_path, file_extension, handle_style_error,
-                 min_confidence):
+                 min_confidence, fs=None):
         """Create a CppChecker instance.
 
         Args:
           file_extension: A string that is the file extension, without
                           the leading dot.
 
         """
         self.file_extension = file_extension
         self.file_path = file_path
         self.handle_style_error = handle_style_error
         self.min_confidence = min_confidence
+        CppChecker.fs = fs or FileSystem()
 
     # Useful for unit testing.
     def __eq__(self, other):
         """Return whether this CppChecker instance is equal to another."""
         if self.file_extension != other.file_extension:
             return False
         if self.file_path != other.file_path:
             return False
         if self.handle_style_error != other.handle_style_error:
             return False
         if self.min_confidence != other.min_confidence:
             return False
 
         return True
 
     # Useful for unit testing.
     def __ne__(self, other):
         # Python does not automatically deduce __ne__() from __eq__().
         return not self.__eq__(other)
 
     def check(self, lines):
         _process_lines(self.file_path, self.file_extension, lines,
                        self.handle_style_error, self.min_confidence)
 
 
 # FIXME: Remove this function (requires refactoring unit tests).
-def process_file_data(filename, file_extension, lines, error, min_confidence, unit_test_config):
-    global _unit_test_config
-    _unit_test_config = unit_test_config
-    checker = CppChecker(filename, file_extension, error, min_confidence)
+def process_file_data(filename, file_extension, lines, error, min_confidence, fs=None):
+    checker = CppChecker(filename, file_extension, error, min_confidence, fs)
     checker.check(lines)
-    _unit_test_config = {}