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)
         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)
     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()

[Dirk Pranke, 2013/10/23 17:42:52]

Note that this would be problematic if we had multiple CppChecker objects
simultaneously active and yet using different filesystem objects. Fortunately,
(a) we don't normally, and (b) there's no real state in the (non-mock) fs
objects, so it shouldn't be an issue. Still a good reason to make this be
instance fields and not class fields.

 
     # 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 = {}