Merge webkit.org at r54127 : Initial merge by git

Change-Id: Ib661abb595522f50ea406f72d3a0ce17f7193c82

11 files changed, 8709 insertions, 0 deletions

diff --git a/WebKitTools/Scripts/webkitpy/style/__init__.py b/WebKitTools/Scripts/webkitpy/style/__init__.py
new file mode 100644
index 0000000..ef65bee
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/__init__.py
@@ -0,0 +1 @@
+# Required for Python to search this directory for module files
diff --git a/WebKitTools/Scripts/webkitpy/style/checker.py b/WebKitTools/Scripts/webkitpy/style/checker.py
new file mode 100644
index 0000000..faf954f
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/checker.py
@@ -0,0 +1,809 @@
+# Copyright (C) 2009 Google Inc. All rights reserved.
+# Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# 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.
+
+"""Front end of some style-checker modules."""
+
+import codecs
+import getopt
+import os.path
+import sys
+
+from .. style_references import parse_patch
+from error_handlers import DefaultStyleErrorHandler
+from error_handlers import PatchStyleErrorHandler
+from processors.cpp import CppProcessor
+from processors.text import TextProcessor
+
+
+# These defaults are used by check-webkit-style.
+WEBKIT_DEFAULT_VERBOSITY = 1
+WEBKIT_DEFAULT_OUTPUT_FORMAT = 'emacs'
+
+
+# FIXME: For style categories we will never want to have, remove them.
+#        For categories for which we want to have similar functionality,
+#        modify the implementation and enable them.
+#
+# Throughout this module, we use "filter rule" rather than "filter"
+# for an individual boolean filter flag like "+foo". This allows us to
+# reserve "filter" for what one gets by collectively applying all of
+# the filter rules.
+#
+# The _WEBKIT_FILTER_RULES are prepended to any user-specified filter
+# rules. Since by default all errors are on, only include rules that
+# begin with a - sign.
+WEBKIT_DEFAULT_FILTER_RULES = [
+    '-build/endif_comment',
+    '-build/include_what_you_use',  # <string> for std::string
+    '-build/storage_class',  # const static
+    '-legal/copyright',
+    '-readability/multiline_comment',
+    '-readability/braces',  # int foo() {};
+    '-readability/fn_size',
+    '-readability/casting',
+    '-readability/function',
+    '-runtime/arrays',  # variable length array
+    '-runtime/casting',
+    '-runtime/sizeof',
+    '-runtime/explicit',  # explicit
+    '-runtime/virtual',  # virtual dtor
+    '-runtime/printf',
+    '-runtime/threadsafe_fn',
+    '-runtime/rtti',
+    '-whitespace/blank_line',
+    '-whitespace/end_of_line',
+    '-whitespace/labels',
+    ]
+
+
+# Some files should be skipped when checking style. For example,
+# WebKit maintains some files in Mozilla style on purpose to ease
+# future merges.
+#
+# Include a warning for skipped files that are less obvious.
+SKIPPED_FILES_WITH_WARNING = [
+    # The Qt API and tests do not follow WebKit style.
+    # They follow Qt style. :)
+    "gtk2drawing.c", # WebCore/platform/gtk/gtk2drawing.c
+    "gtk2drawing.h", # WebCore/platform/gtk/gtk2drawing.h
+    "JavaScriptCore/qt/api/",
+    "WebKit/gtk/tests/",
+    "WebKit/qt/Api/",
+    "WebKit/qt/tests/",
+    ]
+
+
+# Don't include a warning for skipped files that are more common
+# and more obvious.
+SKIPPED_FILES_WITHOUT_WARNING = [
+    "LayoutTests/"
+    ]
+
+
+def style_categories():
+    """Return the set of all categories used by check-webkit-style."""
+    # If other processors had categories, we would take their union here.
+    return CppProcessor.categories
+
+
+def webkit_argument_defaults():
+    """Return the DefaultArguments instance for use by check-webkit-style."""
+    return ArgumentDefaults(WEBKIT_DEFAULT_OUTPUT_FORMAT,
+                            WEBKIT_DEFAULT_VERBOSITY,
+                            WEBKIT_DEFAULT_FILTER_RULES)
+
+
+def _create_usage(defaults):
+    """Return the usage string to display for command help.
+
+    Args:
+      defaults: An ArgumentDefaults instance.
+
+    """
+    usage = """
+Syntax: %(program_name)s [--verbose=#] [--git-commit=<SingleCommit>] [--output=vs7]
+        [--filter=-x,+y,...] [file] ...
+
+  The style guidelines this tries to follow are here:
+    http://webkit.org/coding/coding-style.html
+
+  Every style error is given a confidence score from 1-5, with 5 meaning
+  we are certain of the problem, and 1 meaning it could be a legitimate
+  construct.  This can miss some errors and does not substitute for
+  code review.
+
+  To prevent specific lines from being linted, add a '// NOLINT' comment to the
+  end of the line.
+
+  Linted extensions are .cpp, .c and .h.  Other file types are ignored.
+
+  The file parameter is optional and accepts multiple files.  Leaving
+  out the file parameter applies the check to all files considered changed
+  by your source control management system.
+
+  Flags:
+
+    verbose=#
+      A number 1-5 that restricts output to errors with a confidence
+      score at or above this value. In particular, the value 1 displays
+      all errors. The default is %(default_verbosity)s.
+
+    git-commit=<SingleCommit>
+      Checks the style of everything from the given commit to the local tree.
+
+    output=vs7
+      The output format, which may be one of
+        emacs : to ease emacs parsing
+        vs7   : compatible with Visual Studio
+      Defaults to "%(default_output_format)s". Other formats are unsupported.
+
+    filter=-x,+y,...
+      A comma-separated list of boolean filter rules used to filter
+      which categories of style guidelines to check.  The script checks
+      a category if the category passes the filter rules, as follows.
+
+      Any webkit category starts out passing.  All filter rules are then
+      evaluated left to right, with later rules taking precedence.  For
+      example, the rule "+foo" passes any category that starts with "foo",
+      and "-foo" fails any such category.  The filter input "-whitespace,
+      +whitespace/braces" fails the category "whitespace/tab" and passes
+      "whitespace/braces".
+
+      Examples: --filter=-whitespace,+whitespace/braces
+                --filter=-whitespace,-runtime/printf,+runtime/printf_format
+                --filter=-,+build/include_what_you_use
+
+      Category names appear in error messages in brackets, for example
+      [whitespace/indent].  To see a list of all categories available to
+      %(program_name)s, along with which are enabled by default, pass
+      the empty filter as follows:
+         --filter=
+""" % {'program_name': os.path.basename(sys.argv[0]),
+       'default_verbosity': defaults.verbosity,
+       'default_output_format': defaults.output_format}
+
+    return usage
+
+
+class CategoryFilter(object):
+
+    """Filters whether to check style categories."""
+
+    def __init__(self, filter_rules=None):
+        """Create a category filter.
+
+        This method performs argument validation but does not strip
+        leading or trailing white space.
+
+        Args:
+          filter_rules: A list of strings that are filter rules, which
+                        are strings beginning with the plus or minus
+                        symbol (+/-). The list should include any
+                        default filter rules at the beginning.
+                        Defaults to the empty list.
+
+        Raises:
+          ValueError: Invalid filter rule if a rule does not start with
+                      plus ("+") or minus ("-").
+
+        """
+        if filter_rules is None:
+            filter_rules = []
+
+        for rule in filter_rules:
+            if not (rule.startswith('+') or rule.startswith('-')):
+                raise ValueError('Invalid filter rule "%s": every rule '
+                                 'rule in the --filter flag must start '
+                                 'with + or -.' % rule)
+
+        self._filter_rules = filter_rules
+        self._should_check_category = {} # Cached dictionary of category to True/False
+
+    def __str__(self):
+        return ",".join(self._filter_rules)
+
+    # Useful for unit testing.
+    def __eq__(self, other):
+        """Return whether this CategoryFilter instance is equal to another."""
+        return self._filter_rules == other._filter_rules
+
+    # Useful for unit testing.
+    def __ne__(self, other):
+        # Python does not automatically deduce from __eq__().
+        return not (self == other)
+
+    def should_check(self, category):
+        """Return whether the category should be checked.
+
+        The rules for determining whether a category should be checked
+        are as follows. By default all categories should be checked.
+        Then apply the filter rules in order from first to last, with
+        later flags taking precedence.
+
+        A filter rule applies to a category if the string after the
+        leading plus/minus (+/-) matches the beginning of the category
+        name. A plus (+) means the category should be checked, while a
+        minus (-) means the category should not be checked.
+
+        """
+        if category in self._should_check_category:
+            return self._should_check_category[category]
+
+        should_check = True # All categories checked by default.
+        for rule in self._filter_rules:
+            if not category.startswith(rule[1:]):
+                continue
+            should_check = rule.startswith('+')
+        self._should_check_category[category] = should_check # Update cache.
+        return should_check
+
+
+# This class should not have knowledge of the flag key names.
+class ProcessorOptions(object):
+
+    """A container to store options to use when checking style.
+
+    Attributes:
+      output_format: A string that is the output format. The supported
+                     output formats are "emacs" which emacs can parse
+                     and "vs7" which Microsoft Visual Studio 7 can parse.
+
+      verbosity: An integer between 1-5 inclusive that restricts output
+                 to errors with a confidence score at or above this value.
+                 The default is 1, which displays all errors.
+
+      filter: A CategoryFilter instance. The default is the empty filter,
+              which means that all categories should be checked.
+
+      git_commit: A string representing the git commit to check.
+                  The default is None.
+
+      extra_flag_values: A string-string dictionary of all flag key-value
+                         pairs that are not otherwise represented by this
+                         class. The default is the empty dictionary.
+
+    """
+
+    def __init__(self, output_format="emacs", verbosity=1, filter=None,
+                 git_commit=None, extra_flag_values=None):
+        if filter is None:
+            filter = CategoryFilter()
+        if extra_flag_values is None:
+            extra_flag_values = {}
+
+        if output_format not in ("emacs", "vs7"):
+            raise ValueError('Invalid "output_format" parameter: '
+                             'value must be "emacs" or "vs7". '
+                             'Value given: "%s".' % output_format)
+
+        if (verbosity < 1) or (verbosity > 5):
+            raise ValueError('Invalid "verbosity" parameter: '
+                             "value must be an integer between 1-5 inclusive. "
+                             'Value given: "%s".' % verbosity)
+
+        self.output_format = output_format
+        self.verbosity = verbosity
+        self.filter = filter
+        self.git_commit = git_commit
+        self.extra_flag_values = extra_flag_values
+
+    # Useful for unit testing.
+    def __eq__(self, other):
+        """Return whether this ProcessorOptions instance is equal to another."""
+        if self.output_format != other.output_format:
+            return False
+        if self.verbosity != other.verbosity:
+            return False
+        if self.filter != other.filter:
+            return False
+        if self.git_commit != other.git_commit:
+            return False
+        if self.extra_flag_values != other.extra_flag_values:
+            return False
+
+        return True
+
+    # Useful for unit testing.
+    def __ne__(self, other):
+        # Python does not automatically deduce from __eq__().
+        return not (self == other)
+
+    def is_reportable(self, category, confidence_in_error):
+        """Return whether an error is reportable.
+
+        An error is reportable if the confidence in the error
+        is at least the current verbosity level, and if the current
+        filter says that the category should be checked.
+
+        Args:
+          category: A string that is a style category.
+          confidence_in_error: An integer between 1 and 5, inclusive, that
+                               represents the application's confidence in
+                               the error. A higher number signifies greater
+                               confidence.
+
+        """
+        if confidence_in_error < self.verbosity:
+            return False
+
+        if self.filter is None:
+            return True # All categories should be checked by default.
+
+        return self.filter.should_check(category)
+
+
+# This class should not have knowledge of the flag key names.
+class ArgumentDefaults(object):
+
+    """A container to store default argument values.
+
+    Attributes:
+      output_format: A string that is the default output format.
+      verbosity: An integer that is the default verbosity level.
+      filter_rules: A list of strings that are boolean filter rules
+                    to prepend to any user-specified rules.
+
+    """
+
+    def __init__(self, default_output_format, default_verbosity,
+                 default_filter_rules):
+        self.output_format = default_output_format
+        self.verbosity = default_verbosity
+        self.filter_rules = default_filter_rules
+
+
+class ArgumentPrinter(object):
+
+    """Supports the printing of check-webkit-style command arguments."""
+
+    def _flag_pair_to_string(self, flag_key, flag_value):
+        return '--%(key)s=%(val)s' % {'key': flag_key, 'val': flag_value }
+
+    def to_flag_string(self, options):
+        """Return a flag string yielding the given ProcessorOptions instance.
+
+        This method orders the flag values alphabetically by the flag key.
+
+        Args:
+          options: A ProcessorOptions instance.
+
+        """
+        flags = options.extra_flag_values.copy()
+
+        flags['output'] = options.output_format
+        flags['verbose'] = options.verbosity
+        if options.filter:
+            # Only include the filter flag if rules are present.
+            filter_string = str(options.filter)
+            if filter_string:
+                flags['filter'] = filter_string
+        if options.git_commit:
+            flags['git-commit'] = options.git_commit
+
+        flag_string = ''
+        # Alphabetizing lets us unit test this method.
+        for key in sorted(flags.keys()):
+            flag_string += self._flag_pair_to_string(key, flags[key]) + ' '
+
+        return flag_string.strip()
+
+
+class ArgumentParser(object):
+
+    """Supports the parsing of check-webkit-style command arguments.
+
+    Attributes:
+      defaults: An ArgumentDefaults instance.
+      create_usage: A function that accepts an ArgumentDefaults instance
+                    and returns a string of usage instructions.
+                    This defaults to the function used to generate the
+                    usage string for check-webkit-style.
+      doc_print: A function that accepts a string parameter and that is
+                 called to display help messages. This defaults to
+                 sys.stderr.write().
+
+    """
+
+    def __init__(self, argument_defaults, create_usage=None, doc_print=None):
+        if create_usage is None:
+            create_usage = _create_usage
+        if doc_print is None:
+            doc_print = sys.stderr.write
+
+        self.defaults = argument_defaults
+        self.create_usage = create_usage
+        self.doc_print = doc_print
+
+    def _exit_with_usage(self, error_message=''):
+        """Exit and print a usage string with an optional error message.
+
+        Args:
+          error_message: A string that is an error message to print.
+
+        """
+        usage = self.create_usage(self.defaults)
+        self.doc_print(usage)
+        if error_message:
+            sys.exit('\nFATAL ERROR: ' + error_message)
+        else:
+            sys.exit(1)
+
+    def _exit_with_categories(self):
+        """Exit and print the style categories and default filter rules."""
+        self.doc_print('\nAll categories:\n')
+        categories = style_categories()
+        for category in sorted(categories):
+            self.doc_print('    ' + category + '\n')
+
+        self.doc_print('\nDefault filter rules**:\n')
+        for filter_rule in sorted(self.defaults.filter_rules):
+            self.doc_print('    ' + filter_rule + '\n')
+        self.doc_print('\n**The command always evaluates the above rules, '
+                       'and before any --filter flag.\n\n')
+
+        sys.exit(0)
+
+    def _parse_filter_flag(self, flag_value):
+        """Parse the value of the --filter flag.
+
+        These filters are applied when deciding whether to emit a given
+        error message.
+
+        Args:
+          flag_value: A string of comma-separated filter rules, for
+                      example "-whitespace,+whitespace/indent".
+
+        """
+        filters = []
+        for uncleaned_filter in flag_value.split(','):
+            filter = uncleaned_filter.strip()
+            if not filter:
+                continue
+            filters.append(filter)
+        return filters
+
+    def parse(self, args, extra_flags=None):
+        """Parse the command line arguments to check-webkit-style.
+
+        Args:
+          args: A list of command-line arguments as returned by sys.argv[1:].
+          extra_flags: A list of flags whose values we want to extract, but
+                       are not supported by the ProcessorOptions class.
+                       An example flag "new_flag=". This defaults to the
+                       empty list.
+
+        Returns:
+          A tuple of (filenames, options)
+
+          filenames: The list of filenames to check.
+          options: A ProcessorOptions instance.
+
+        """
+        if extra_flags is None:
+            extra_flags = []
+
+        output_format = self.defaults.output_format
+        verbosity = self.defaults.verbosity
+        filter_rules = self.defaults.filter_rules
+
+        # The flags already supported by the ProcessorOptions class.
+        flags = ['help', 'output=', 'verbose=', 'filter=', 'git-commit=']
+
+        for extra_flag in extra_flags:
+            if extra_flag in flags:
+                raise ValueError('Flag \'%(extra_flag)s is duplicated '
+                                 'or already supported.' %
+                                 {'extra_flag': extra_flag})
+            flags.append(extra_flag)
+
+        try:
+            (opts, filenames) = getopt.getopt(args, '', flags)
+        except getopt.GetoptError:
+            # FIXME: Settle on an error handling approach: come up
+            #        with a consistent guideline as to when and whether
+            #        a ValueError should be raised versus calling
+            #        sys.exit when needing to interrupt execution.
+            self._exit_with_usage('Invalid arguments.')
+
+        extra_flag_values = {}
+        git_commit = None
+
+        for (opt, val) in opts:
+            if opt == '--help':
+                self._exit_with_usage()
+            elif opt == '--output':
+                output_format = val
+            elif opt == '--verbose':
+                verbosity = val
+            elif opt == '--git-commit':
+                git_commit = val
+            elif opt == '--filter':
+                if not val:
+                    self._exit_with_categories()
+                # Prepend the defaults.
+                filter_rules = filter_rules + self._parse_filter_flag(val)
+            else:
+                extra_flag_values[opt] = val
+
+        # Check validity of resulting values.
+        if filenames and (git_commit != None):
+            self._exit_with_usage('It is not possible to check files and a '
+                                  'specific commit at the same time.')
+
+        if output_format not in ('emacs', 'vs7'):
+            raise ValueError('Invalid --output value "%s": The only '
+                             'allowed output formats are emacs and vs7.' %
+                             output_format)
+
+        verbosity = int(verbosity)
+        if (verbosity < 1) or (verbosity > 5):
+            raise ValueError('Invalid --verbose value %s: value must '
+                             'be between 1-5.' % verbosity)
+
+        filter = CategoryFilter(filter_rules)
+
+        options = ProcessorOptions(output_format, verbosity, filter,
+                                   git_commit, extra_flag_values)
+
+        return (filenames, options)
+
+
+# Enum-like idiom
+class FileType:
+
+    NONE = 1
+    # Alphabetize remaining types
+    CPP = 2
+    TEXT = 3
+
+
+class ProcessorDispatcher(object):
+
+    """Supports determining whether and how to check style, based on path."""
+
+    cpp_file_extensions = (
+        'c',
+        'cpp',
+        'h',
+        )
+
+    text_file_extensions = (
+        'css',
+        'html',
+        'idl',
+        'js',
+        'mm',
+        'php',
+        'pm',
+        'py',
+        'txt',
+        )
+
+    def _file_extension(self, file_path):
+        """Return the file extension without the leading dot."""
+        return os.path.splitext(file_path)[1].lstrip(".")
+
+    def should_skip_with_warning(self, file_path):
+        """Return whether the given file should be skipped with a warning."""
+        for skipped_file in SKIPPED_FILES_WITH_WARNING:
+            if file_path.find(skipped_file) >= 0:
+                return True
+        return False
+
+    def should_skip_without_warning(self, file_path):
+        """Return whether the given file should be skipped without a warning."""
+        for skipped_file in SKIPPED_FILES_WITHOUT_WARNING:
+            if file_path.find(skipped_file) >= 0:
+                return True
+        return False
+
+    def _file_type(self, file_path):
+        """Return the file type corresponding to the given file."""
+        file_extension = self._file_extension(file_path)
+
+        if (file_extension in self.cpp_file_extensions) or (file_path == '-'):
+            # FIXME: Do something about the comment below and the issue it
+            #        raises since cpp_style already relies on the extension.
+            #
+            # Treat stdin as C++. Since the extension is unknown when
+            # reading from stdin, cpp_style tests should not rely on
+            # the extension.
+            return FileType.CPP
+        elif ("ChangeLog" in file_path
+              or "WebKitTools/Scripts/" in file_path
+              or file_extension in self.text_file_extensions):
+            return FileType.TEXT
+        else:
+            return FileType.NONE
+
+    def _create_processor(self, file_type, file_path, handle_style_error, verbosity):
+        """Instantiate and return a style processor based on file type."""
+        if file_type == FileType.NONE:
+            processor = None
+        elif file_type == FileType.CPP:
+            file_extension = self._file_extension(file_path)
+            processor = CppProcessor(file_path, file_extension, handle_style_error, verbosity)
+        elif file_type == FileType.TEXT:
+            processor = TextProcessor(file_path, handle_style_error)
+        else:
+            raise ValueError('Invalid file type "%(file_type)s": the only valid file types '
+                             "are %(NONE)s, %(CPP)s, and %(TEXT)s."
+                             % {"file_type": file_type,
+                                "NONE": FileType.NONE,
+                                "CPP": FileType.CPP,
+                                "TEXT": FileType.TEXT})
+
+        return processor
+
+    def dispatch_processor(self, file_path, handle_style_error, verbosity):
+        """Instantiate and return a style processor based on file path."""
+        file_type = self._file_type(file_path)
+
+        processor = self._create_processor(file_type,
+                                           file_path,
+                                           handle_style_error,
+                                           verbosity)
+        return processor
+
+
+class StyleChecker(object):
+
+    """Supports checking style in files and patches.
+
+       Attributes:
+         error_count: An integer that is the total number of reported
+                      errors for the lifetime of this StyleChecker
+                      instance.
+         options: A ProcessorOptions instance that controls the behavior
+                  of style checking.
+
+    """
+
+    def __init__(self, options, stderr_write=None):
+        """Create a StyleChecker instance.
+
+        Args:
+          options: See options attribute.
+          stderr_write: A function that takes a string as a parameter
+                        and that is called when a style error occurs.
+                        Defaults to sys.stderr.write. This should be
+                        used only for unit tests.
+
+        """
+        if stderr_write is None:
+            stderr_write = sys.stderr.write
+
+        self._stderr_write = stderr_write
+        self.error_count = 0
+        self.options = options
+
+    def _increment_error_count(self):
+        """Increment the total count of reported errors."""
+        self.error_count += 1
+
+    def _process_file(self, processor, file_path, handle_style_error):
+        """Process the file using the given processor."""
+        try:
+            # Support the UNIX convention of using "-" for stdin.  Note that
+            # we are not opening the file with universal newline support
+            # (which codecs doesn't support anyway), so the resulting lines do
+            # contain trailing '\r' characters if we are reading a file that
+            # has CRLF endings.
+            # If after the split a trailing '\r' is present, it is removed
+            # below. If it is not expected to be present (i.e. os.linesep !=
+            # '\r\n' as in Windows), a warning is issued below if this file
+            # is processed.
+            if file_path == '-':
+                lines = codecs.StreamReaderWriter(sys.stdin,
+                                                  codecs.getreader('utf8'),
+                                                  codecs.getwriter('utf8'),
+                                                  'replace').read().split('\n')
+            else:
+                lines = codecs.open(file_path, 'r', 'utf8', 'replace').read().split('\n')
+
+            carriage_return_found = False
+            # Remove trailing '\r'.
+            for line_number in range(len(lines)):
+                if lines[line_number].endswith('\r'):
+                    lines[line_number] = lines[line_number].rstrip('\r')
+                    carriage_return_found = True
+
+        except IOError:
+            self._stderr_write("Skipping input '%s': Can't open for reading\n" % file_path)
+            return
+
+        processor.process(lines)
+
+        if carriage_return_found and os.linesep != '\r\n':
+            # FIXME: Make sure this error also shows up when checking
+            #        patches, if appropriate.
+            #
+            # Use 0 for line_number since outputting only one error for
+            # potentially several lines.
+            handle_style_error(file_path, 0, 'whitespace/newline', 1,
+                               'One or more unexpected \\r (^M) found;'
+                               'better to use only a \\n')
+
+    def check_file(self, file_path, handle_style_error=None, process_file=None):
+        """Check style in the given file.
+
+        Args:
+          file_path: A string that is the path of the file to process.
+          handle_style_error: The function to call when a style error
+                              occurs. This parameter is meant for internal
+                              use within this class. Defaults to a
+                              DefaultStyleErrorHandler instance.
+          process_file: The function to call to process the file. This
+                        parameter should be used only for unit tests.
+                        Defaults to the file processing method of this class.
+
+        """
+        if handle_style_error is None:
+            handle_style_error = DefaultStyleErrorHandler(file_path,
+                                     self.options,
+                                     self._increment_error_count,
+                                     self._stderr_write)
+        if process_file is None:
+            process_file = self._process_file
+
+        dispatcher = ProcessorDispatcher()
+
+        if dispatcher.should_skip_without_warning(file_path):
+            return
+        if dispatcher.should_skip_with_warning(file_path):
+            self._stderr_write('Ignoring "%s": this file is exempt from the '
+                               "style guide.\n" % file_path)
+            return
+
+        verbosity = self.options.verbosity
+        processor = dispatcher.dispatch_processor(file_path,
+                                                  handle_style_error,
+                                                  verbosity)
+        if processor is None:
+            return
+
+        process_file(processor, file_path, handle_style_error)
+
+    def check_patch(self, patch_string):
+        """Check style in the given patch.
+
+        Args:
+          patch_string: A string that is a patch string.
+
+        """
+        patch_files = parse_patch(patch_string)
+        for file_path, diff in patch_files.iteritems():
+            style_error_handler = PatchStyleErrorHandler(diff,
+                                      file_path,
+                                      self.options,
+                                      self._increment_error_count,
+                                      self._stderr_write)
+
+            self.check_file(file_path, style_error_handler)
+
diff --git a/WebKitTools/Scripts/webkitpy/style/checker_unittest.py b/WebKitTools/Scripts/webkitpy/style/checker_unittest.py
new file mode 100755
index 0000000..4d6b2e7
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/checker_unittest.py
@@ -0,0 +1,677 @@
+#!/usr/bin/python
+# -*- coding: utf-8; -*-
+#
+# Copyright (C) 2009 Google Inc. All rights reserved.
+# Copyright (C) 2009 Torch Mobile Inc.
+# Copyright (C) 2009 Apple Inc. All rights reserved.
+# Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#    * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#    * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# 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 tests for style.py."""
+
+import unittest
+
+import checker as style
+from checker import CategoryFilter
+from checker import ProcessorDispatcher
+from checker import ProcessorOptions
+from checker import StyleChecker
+from processors.cpp import CppProcessor
+from processors.text import TextProcessor
+
+class CategoryFilterTest(unittest.TestCase):
+
+    """Tests CategoryFilter class."""
+
+    def test_init(self):
+        """Test __init__ constructor."""
+        self.assertRaises(ValueError, CategoryFilter, ["no_prefix"])
+        CategoryFilter() # No ValueError: works
+        CategoryFilter(["+"]) # No ValueError: works
+        CategoryFilter(["-"]) # No ValueError: works
+
+    def test_str(self):
+        """Test __str__ "to string" operator."""
+        filter = CategoryFilter(["+a", "-b"])
+        self.assertEquals(str(filter), "+a,-b")
+
+    def test_eq(self):
+        """Test __eq__ equality function."""
+        filter1 = CategoryFilter(["+a", "+b"])
+        filter2 = CategoryFilter(["+a", "+b"])
+        filter3 = CategoryFilter(["+b", "+a"])
+
+        # == calls __eq__.
+        self.assertTrue(filter1 == filter2)
+        self.assertFalse(filter1 == filter3) # Cannot test with assertNotEqual.
+
+    def test_ne(self):
+        """Test __ne__ inequality function."""
+        # != 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(CategoryFilter() != CategoryFilter())
+
+    def test_should_check(self):
+        """Test should_check() method."""
+        filter = CategoryFilter()
+        self.assertTrue(filter.should_check("everything"))
+        # Check a second time to exercise cache.
+        self.assertTrue(filter.should_check("everything"))
+
+        filter = CategoryFilter(["-"])
+        self.assertFalse(filter.should_check("anything"))
+        # Check a second time to exercise cache.
+        self.assertFalse(filter.should_check("anything"))
+
+        filter = CategoryFilter(["-", "+ab"])
+        self.assertTrue(filter.should_check("abc"))
+        self.assertFalse(filter.should_check("a"))
+
+        filter = CategoryFilter(["+", "-ab"])
+        self.assertFalse(filter.should_check("abc"))
+        self.assertTrue(filter.should_check("a"))
+
+
+class ProcessorOptionsTest(unittest.TestCase):
+
+    """Tests ProcessorOptions class."""
+
+    def test_init(self):
+        """Test __init__ constructor."""
+        # Check default parameters.
+        options = ProcessorOptions()
+        self.assertEquals(options.extra_flag_values, {})
+        self.assertEquals(options.filter, CategoryFilter())
+        self.assertEquals(options.git_commit, None)
+        self.assertEquals(options.output_format, "emacs")
+        self.assertEquals(options.verbosity, 1)
+
+        # Check argument validation.
+        self.assertRaises(ValueError, ProcessorOptions, output_format="bad")
+        ProcessorOptions(output_format="emacs") # No ValueError: works
+        ProcessorOptions(output_format="vs7") # works
+        self.assertRaises(ValueError, ProcessorOptions, verbosity=0)
+        self.assertRaises(ValueError, ProcessorOptions, verbosity=6)
+        ProcessorOptions(verbosity=1) # works
+        ProcessorOptions(verbosity=5) # works
+
+        # Check attributes.
+        options = ProcessorOptions(extra_flag_values={"extra_value" : 2},
+                                   filter=CategoryFilter(["+"]),
+                                   git_commit="commit",
+                                   output_format="vs7",
+                                   verbosity=3)
+        self.assertEquals(options.extra_flag_values, {"extra_value" : 2})
+        self.assertEquals(options.filter, CategoryFilter(["+"]))
+        self.assertEquals(options.git_commit, "commit")
+        self.assertEquals(options.output_format, "vs7")
+        self.assertEquals(options.verbosity, 3)
+
+    def test_eq(self):
+        """Test __eq__ equality function."""
+        # == calls __eq__.
+        self.assertTrue(ProcessorOptions() == ProcessorOptions())
+
+        # Verify that a difference in any argument cause equality to fail.
+        options = ProcessorOptions(extra_flag_values={"extra_value" : 1},
+                                   filter=CategoryFilter(["+"]),
+                                   git_commit="commit",
+                                   output_format="vs7",
+                                   verbosity=1)
+        self.assertFalse(options == ProcessorOptions(extra_flag_values={"extra_value" : 2}))
+        self.assertFalse(options == ProcessorOptions(filter=CategoryFilter(["-"])))
+        self.assertFalse(options == ProcessorOptions(git_commit="commit2"))
+        self.assertFalse(options == ProcessorOptions(output_format="emacs"))
+        self.assertFalse(options == ProcessorOptions(verbosity=2))
+
+    def test_ne(self):
+        """Test __ne__ inequality function."""
+        # != 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(ProcessorOptions() != ProcessorOptions())
+
+    def test_is_reportable(self):
+        """Test is_reportable()."""
+        filter = CategoryFilter(["-xyz"])
+        options = ProcessorOptions(filter=filter, verbosity=3)
+
+        # Test verbosity
+        self.assertTrue(options.is_reportable("abc", 3))
+        self.assertFalse(options.is_reportable("abc", 2))
+
+        # Test filter
+        self.assertTrue(options.is_reportable("xy", 3))
+        self.assertFalse(options.is_reportable("xyz", 3))
+
+
+class WebKitArgumentDefaultsTest(unittest.TestCase):
+
+    """Tests validity of default arguments used by check-webkit-style."""
+
+    def defaults(self):
+        return style.webkit_argument_defaults()
+
+    def test_filter_rules(self):
+        defaults = self.defaults()
+        already_seen = []
+        all_categories = style.style_categories()
+        for rule in defaults.filter_rules:
+            # Check no leading or trailing white space.
+            self.assertEquals(rule, rule.strip())
+            # All categories are on by default, so defaults should
+            # begin with -.
+            self.assertTrue(rule.startswith('-'))
+            self.assertTrue(rule[1:] in all_categories)
+            # Check no rule occurs twice.
+            self.assertFalse(rule in already_seen)
+            already_seen.append(rule)
+
+    def test_defaults(self):
+        """Check that default arguments are valid."""
+        defaults = self.defaults()
+
+        # FIXME: We should not need to call parse() to determine
+        #        whether the default arguments are valid.
+        parser = style.ArgumentParser(defaults)
+        # No need to test the return value here since we test parse()
+        # on valid arguments elsewhere.
+        parser.parse([]) # arguments valid: no error or SystemExit
+
+
+class ArgumentPrinterTest(unittest.TestCase):
+
+    """Tests the ArgumentPrinter class."""
+
+    _printer = style.ArgumentPrinter()
+
+    def _create_options(self, output_format='emacs', verbosity=3,
+                        filter_rules=[], git_commit=None,
+                        extra_flag_values={}):
+        filter = CategoryFilter(filter_rules)
+        return style.ProcessorOptions(output_format, verbosity, filter,
+                                      git_commit, extra_flag_values)
+
+    def test_to_flag_string(self):
+        options = self._create_options('vs7', 5, ['+foo', '-bar'], 'git',
+                                       {'a': 0, 'z': 1})
+        self.assertEquals('--a=0 --filter=+foo,-bar --git-commit=git '
+                          '--output=vs7 --verbose=5 --z=1',
+                          self._printer.to_flag_string(options))
+
+        # This is to check that --filter and --git-commit do not
+        # show up when not user-specified.
+        options = self._create_options()
+        self.assertEquals('--output=emacs --verbose=3',
+                          self._printer.to_flag_string(options))
+
+
+class ArgumentParserTest(unittest.TestCase):
+
+    """Test the ArgumentParser class."""
+
+    def _parse(self):
+        """Return a default parse() function for testing."""
+        return self._create_parser().parse
+
+    def _create_defaults(self, default_output_format='vs7',
+                         default_verbosity=3,
+                         default_filter_rules=['-', '+whitespace']):
+        """Return a default ArgumentDefaults instance for testing."""
+        return style.ArgumentDefaults(default_output_format,
+                                      default_verbosity,
+                                      default_filter_rules)
+
+    def _create_parser(self, defaults=None):
+        """Return an ArgumentParser instance for testing."""
+        def create_usage(_defaults):
+            """Return a usage string for testing."""
+            return "usage"
+
+        def doc_print(message):
+            # We do not want the usage string or style categories
+            # to print during unit tests, so print nothing.
+            return
+
+        if defaults is None:
+            defaults = self._create_defaults()
+
+        return style.ArgumentParser(defaults, create_usage, doc_print)
+
+    def test_parse_documentation(self):
+        parse = self._parse()
+
+        # FIXME: Test both the printing of the usage string and the
+        #        filter categories help.
+
+        # Request the usage string.
+        self.assertRaises(SystemExit, parse, ['--help'])
+        # Request default filter rules and available style categories.
+        self.assertRaises(SystemExit, parse, ['--filter='])
+
+    def test_parse_bad_values(self):
+        parse = self._parse()
+
+        # Pass an unsupported argument.
+        self.assertRaises(SystemExit, parse, ['--bad'])
+
+        self.assertRaises(ValueError, parse, ['--verbose=bad'])
+        self.assertRaises(ValueError, parse, ['--verbose=0'])
+        self.assertRaises(ValueError, parse, ['--verbose=6'])
+        parse(['--verbose=1']) # works
+        parse(['--verbose=5']) # works
+
+        self.assertRaises(ValueError, parse, ['--output=bad'])
+        parse(['--output=vs7']) # works
+
+        # Pass a filter rule not beginning with + or -.
+        self.assertRaises(ValueError, parse, ['--filter=foo'])
+        parse(['--filter=+foo']) # works
+        # Pass files and git-commit at the same time.
+        self.assertRaises(SystemExit, parse, ['--git-commit=', 'file.txt'])
+        # Pass an extra flag already supported.
+        self.assertRaises(ValueError, parse, [], ['filter='])
+        parse([], ['extra=']) # works
+        # Pass an extra flag with typo.
+        self.assertRaises(SystemExit, parse, ['--extratypo='], ['extra='])
+        parse(['--extra='], ['extra=']) # works
+        self.assertRaises(ValueError, parse, [], ['extra=', 'extra='])
+
+
+    def test_parse_default_arguments(self):
+        parse = self._parse()
+
+        (files, options) = parse([])
+
+        self.assertEquals(files, [])
+
+        self.assertEquals(options.output_format, 'vs7')
+        self.assertEquals(options.verbosity, 3)
+        self.assertEquals(options.filter,
+                          CategoryFilter(["-", "+whitespace"]))
+        self.assertEquals(options.git_commit, None)
+
+    def test_parse_explicit_arguments(self):
+        parse = self._parse()
+
+        # Pass non-default explicit values.
+        (files, options) = parse(['--output=emacs'])
+        self.assertEquals(options.output_format, 'emacs')
+        (files, options) = parse(['--verbose=4'])
+        self.assertEquals(options.verbosity, 4)
+        (files, options) = parse(['--git-commit=commit'])
+        self.assertEquals(options.git_commit, 'commit')
+        (files, options) = parse(['--filter=+foo,-bar'])
+        self.assertEquals(options.filter,
+                          CategoryFilter(["-", "+whitespace", "+foo", "-bar"]))
+        # Spurious white space in filter rules.
+        (files, options) = parse(['--filter=+foo ,-bar'])
+        self.assertEquals(options.filter,
+                          CategoryFilter(["-", "+whitespace", "+foo", "-bar"]))
+
+        # Pass extra flag values.
+        (files, options) = parse(['--extra'], ['extra'])
+        self.assertEquals(options.extra_flag_values, {'--extra': ''})
+        (files, options) = parse(['--extra='], ['extra='])
+        self.assertEquals(options.extra_flag_values, {'--extra': ''})
+        (files, options) = parse(['--extra=x'], ['extra='])
+        self.assertEquals(options.extra_flag_values, {'--extra': 'x'})
+
+    def test_parse_files(self):
+        parse = self._parse()
+
+        (files, options) = parse(['foo.cpp'])
+        self.assertEquals(files, ['foo.cpp'])
+
+        # Pass multiple files.
+        (files, options) = parse(['--output=emacs', 'foo.cpp', 'bar.cpp'])
+        self.assertEquals(files, ['foo.cpp', 'bar.cpp'])
+
+
+class ProcessorDispatcherSkipTest(unittest.TestCase):
+
+    """Tests the "should skip" methods of the ProcessorDispatcher class."""
+
+    def test_should_skip_with_warning(self):
+        """Test should_skip_with_warning()."""
+        dispatcher = ProcessorDispatcher()
+
+        # Check a non-skipped file.
+        self.assertFalse(dispatcher.should_skip_with_warning("foo.txt"))
+
+        # Check skipped files.
+        paths_to_skip = [
+           "gtk2drawing.c",
+           "gtk2drawing.h",
+           "JavaScriptCore/qt/api/qscriptengine_p.h",
+           "WebCore/platform/gtk/gtk2drawing.c",
+           "WebCore/platform/gtk/gtk2drawing.h",
+           "WebKit/gtk/tests/testatk.c",
+           "WebKit/qt/Api/qwebpage.h",
+           "WebKit/qt/tests/qwebsecurityorigin/tst_qwebsecurityorigin.cpp",
+            ]
+
+        for path in paths_to_skip:
+            self.assertTrue(dispatcher.should_skip_with_warning(path),
+                            "Checking: " + path)
+
+    def test_should_skip_without_warning(self):
+        """Test should_skip_without_warning()."""
+        dispatcher = ProcessorDispatcher()
+
+        # Check a non-skipped file.
+        self.assertFalse(dispatcher.should_skip_without_warning("foo.txt"))
+
+        # Check skipped files.
+        paths_to_skip = [
+           # LayoutTests folder
+           "LayoutTests/foo.txt",
+            ]
+
+        for path in paths_to_skip:
+            self.assertTrue(dispatcher.should_skip_without_warning(path),
+                            "Checking: " + path)
+
+
+class ProcessorDispatcherDispatchTest(unittest.TestCase):
+
+    """Tests dispatch_processor() method of ProcessorDispatcher class."""
+
+    def mock_handle_style_error(self):
+        pass
+
+    def dispatch_processor(self, file_path):
+        """Call dispatch_processor() with the given file path."""
+        dispatcher = ProcessorDispatcher()
+        processor = dispatcher.dispatch_processor(file_path,
+                                                  self.mock_handle_style_error,
+                                                  verbosity=3)
+        return processor
+
+    def assert_processor_none(self, file_path):
+        """Assert that the dispatched processor is None."""
+        processor = self.dispatch_processor(file_path)
+        self.assertTrue(processor is None, 'Checking: "%s"' % file_path)
+
+    def assert_processor(self, file_path, expected_class):
+        """Assert the type of the dispatched processor."""
+        processor = self.dispatch_processor(file_path)
+        got_class = processor.__class__
+        self.assertEquals(got_class, expected_class,
+                          'For path "%(file_path)s" got %(got_class)s when '
+                          "expecting %(expected_class)s."
+                          % {"file_path": file_path,
+                             "got_class": got_class,
+                             "expected_class": expected_class})
+
+    def assert_processor_cpp(self, file_path):
+        """Assert that the dispatched processor is a CppProcessor."""
+        self.assert_processor(file_path, CppProcessor)
+
+    def assert_processor_text(self, file_path):
+        """Assert that the dispatched processor is a TextProcessor."""
+        self.assert_processor(file_path, TextProcessor)
+
+    def test_cpp_paths(self):
+        """Test paths that should be checked as C++."""
+        paths = [
+            "-",
+            "foo.c",
+            "foo.cpp",
+            "foo.h",
+            ]
+
+        for path in paths:
+            self.assert_processor_cpp(path)
+
+        # Check processor attributes on a typical input.
+        file_base = "foo"
+        file_extension = "c"
+        file_path = file_base + "." + file_extension
+        self.assert_processor_cpp(file_path)
+        processor = self.dispatch_processor(file_path)
+        self.assertEquals(processor.file_extension, file_extension)
+        self.assertEquals(processor.file_path, file_path)
+        self.assertEquals(processor.handle_style_error, self.mock_handle_style_error)
+        self.assertEquals(processor.verbosity, 3)
+        # Check "-" for good measure.
+        file_base = "-"
+        file_extension = ""
+        file_path = file_base
+        self.assert_processor_cpp(file_path)
+        processor = self.dispatch_processor(file_path)
+        self.assertEquals(processor.file_extension, file_extension)
+        self.assertEquals(processor.file_path, file_path)
+
+    def test_text_paths(self):
+        """Test paths that should be checked as text."""
+        paths = [
+           "ChangeLog",
+           "foo.css",
+           "foo.html",
+           "foo.idl",
+           "foo.js",
+           "foo.mm",
+           "foo.php",
+           "foo.pm",
+           "foo.py",
+           "foo.txt",
+           "FooChangeLog.bak",
+           "WebCore/ChangeLog",
+           "WebCore/inspector/front-end/inspector.js",
+           "WebKitTools/Scripts/check-webkit=style",
+           "WebKitTools/Scripts/modules/text_style.py",
+            ]
+
+        for path in paths:
+            self.assert_processor_text(path)
+
+        # Check processor attributes on a typical input.
+        file_base = "foo"
+        file_extension = "css"
+        file_path = file_base + "." + file_extension
+        self.assert_processor_text(file_path)
+        processor = self.dispatch_processor(file_path)
+        self.assertEquals(processor.file_path, file_path)
+        self.assertEquals(processor.handle_style_error, self.mock_handle_style_error)
+
+    def test_none_paths(self):
+        """Test paths that have no file type.."""
+        paths = [
+           "Makefile",
+           "foo.png",
+           "foo.exe",
+            ]
+
+        for path in paths:
+            self.assert_processor_none(path)
+
+
+class StyleCheckerTest(unittest.TestCase):
+
+    """Test the StyleChecker class.
+
+    Attributes:
+      error_messages: A string containing all of the warning messages
+                      written to the mock_stderr_write method of
+                      this class.
+
+    """
+
+    def _mock_stderr_write(self, message):
+        pass
+
+    def _style_checker(self, options):
+        return StyleChecker(options, self._mock_stderr_write)
+
+    def test_init(self):
+        """Test __init__ constructor."""
+        options = ProcessorOptions()
+        style_checker = self._style_checker(options)
+
+        self.assertEquals(style_checker.error_count, 0)
+        self.assertEquals(style_checker.options, options)
+
+
+class StyleCheckerCheckFileTest(unittest.TestCase):
+
+    """Test the check_file() method of the StyleChecker class.
+
+    The check_file() method calls its process_file parameter when
+    given a file that should not be skipped.
+
+    The "got_*" attributes of this class are the parameters passed
+    to process_file by calls to check_file() made by this test
+    class. These attributes allow us to check the parameter values
+    passed internally to the process_file function.
+
+    Attributes:
+      got_file_path: The file_path parameter passed by check_file()
+                     to its process_file parameter.
+      got_handle_style_error: The handle_style_error parameter passed
+                              by check_file() to its process_file
+                              parameter.
+      got_processor: The processor parameter passed by check_file() to
+                     its process_file parameter.
+      warning_messages: A string containing all of the warning messages
+                        written to the mock_stderr_write method of
+                        this class.
+
+    """
+    def setUp(self):
+        self.got_file_path = None
+        self.got_handle_style_error = None
+        self.got_processor = None
+        self.warning_messages = ""
+
+    def mock_stderr_write(self, warning_message):
+        self.warning_messages += warning_message
+
+    def mock_handle_style_error(self):
+        pass
+
+    def mock_process_file(self, processor, file_path, handle_style_error):
+        """A mock _process_file().
+
+        See the documentation for this class for more information
+        on this function.
+
+        """
+        self.got_file_path = file_path
+        self.got_handle_style_error = handle_style_error
+        self.got_processor = processor
+
+    def assert_attributes(self,
+                          expected_file_path,
+                          expected_handle_style_error,
+                          expected_processor,
+                          expected_warning_messages):
+        """Assert that the attributes of this class equal the given values."""
+        self.assertEquals(self.got_file_path, expected_file_path)
+        self.assertEquals(self.got_handle_style_error, expected_handle_style_error)
+        self.assertEquals(self.got_processor, expected_processor)
+        self.assertEquals(self.warning_messages, expected_warning_messages)
+
+    def call_check_file(self, file_path):
+        """Call the check_file() method of a test StyleChecker instance."""
+        # Confirm that the attributes are reset.
+        self.assert_attributes(None, None, None, "")
+
+        # Create a test StyleChecker instance.
+        #
+        # The verbosity attribute is the only ProcessorOptions
+        # attribute that needs to be checked in this test.
+        # This is because it is the only option is directly
+        # passed to the constructor of a style processor.
+        options = ProcessorOptions(verbosity=3)
+
+        style_checker = StyleChecker(options, self.mock_stderr_write)
+
+        style_checker.check_file(file_path,
+                                 self.mock_handle_style_error,
+                                 self.mock_process_file)
+
+    def test_check_file_on_skip_without_warning(self):
+        """Test check_file() for a skipped-without-warning file."""
+
+        file_path = "LayoutTests/foo.txt"
+
+        dispatcher = ProcessorDispatcher()
+        # Confirm that the input file is truly a skipped-without-warning file.
+        self.assertTrue(dispatcher.should_skip_without_warning(file_path))
+
+        # Check the outcome.
+        self.call_check_file(file_path)
+        self.assert_attributes(None, None, None, "")
+
+    def test_check_file_on_skip_with_warning(self):
+        """Test check_file() for a skipped-with-warning file."""
+
+        file_path = "gtk2drawing.c"
+
+        dispatcher = ProcessorDispatcher()
+        # Check that the input file is truly a skipped-with-warning file.
+        self.assertTrue(dispatcher.should_skip_with_warning(file_path))
+
+        # Check the outcome.
+        self.call_check_file(file_path)
+        self.assert_attributes(None, None, None,
+                               'Ignoring "gtk2drawing.c": this file is exempt from the style guide.\n')
+
+    def test_check_file_on_non_skipped(self):
+
+        # We use a C++ file since by using a CppProcessor, we can check
+        # that all of the possible information is getting passed to
+        # process_file (in particular, the verbosity).
+        file_base = "foo"
+        file_extension = "cpp"
+        file_path = file_base + "." + file_extension
+
+        dispatcher = ProcessorDispatcher()
+        # Check that the input file is truly a C++ file.
+        self.assertEquals(dispatcher._file_type(file_path), style.FileType.CPP)
+
+        # Check the outcome.
+        self.call_check_file(file_path)
+
+        expected_processor = CppProcessor(file_path, file_extension, self.mock_handle_style_error, 3)
+
+        self.assert_attributes(file_path,
+                               self.mock_handle_style_error,
+                               expected_processor,
+                               "")
+
+
+if __name__ == '__main__':
+    import sys
+
+    unittest.main()
+
diff --git a/WebKitTools/Scripts/webkitpy/style/error_handlers.py b/WebKitTools/Scripts/webkitpy/style/error_handlers.py
new file mode 100644
index 0000000..54b1d76
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/error_handlers.py
@@ -0,0 +1,154 @@
+# 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:
+# 1.  Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+# 2.  Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT 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.
+
+"""Defines style error handler classes.
+
+A style error handler is a function to call when a style error is
+found. Style error handlers can also have state. A class that represents
+a style error handler should implement the following methods.
+
+Methods:
+
+  __call__(self, line_number, category, confidence, message):
+
+    Handle the occurrence of a style error.
+
+    Check whether the error is reportable. If so, report the details.
+
+    Args:
+      line_number: The integer line number of the line containing the error.
+      category: The name of the category of the error, for example
+                "whitespace/newline".
+      confidence: An integer between 1-5 that represents the level of
+                  confidence in the error. The value 5 means that we are
+                  certain of the problem, and the value 1 means that it
+                  could be a legitimate construct.
+      message: The error message to report.
+
+"""
+
+
+import sys
+
+
+class DefaultStyleErrorHandler(object):
+
+    """The default style error handler."""
+
+    def __init__(self, file_path, options, increment_error_count,
+                 stderr_write=None):
+        """Create a default style error handler.
+
+        Args:
+          file_path: The path to the file containing the error. This
+                     is used for reporting to the user.
+          options: A ProcessorOptions instance.
+          increment_error_count: A function that takes no arguments and
+                                 increments the total count of reportable
+                                 errors.
+          stderr_write: A function that takes a string as a parameter
+                        and that is called when a style error occurs.
+                        Defaults to sys.stderr.write. This should be
+                        used only for unit tests.
+
+        """
+        if stderr_write is None:
+            stderr_write = sys.stderr.write
+
+        self._file_path = file_path
+        self._increment_error_count = increment_error_count
+        self._options = options
+        self._stderr_write = stderr_write
+
+    def __call__(self, line_number, category, confidence, message):
+        """Handle the occurrence of a style error.
+
+        See the docstring of this module for more information.
+
+        """
+        if not self._options.is_reportable(category, confidence):
+            return
+
+        self._increment_error_count()
+
+        if self._options.output_format == 'vs7':
+            format_string = "%s(%s):  %s  [%s] [%d]\n"
+        else:
+            format_string = "%s:%s:  %s  [%s] [%d]\n"
+
+        self._stderr_write(format_string % (self._file_path,
+                                            line_number,
+                                            message,
+                                            category,
+                                            confidence))
+
+
+class PatchStyleErrorHandler(object):
+
+    """The style error function for patch files."""
+
+    def __init__(self, diff, file_path, options, increment_error_count,
+                 stderr_write):
+        """Create a patch style error handler for the given path.
+
+        Args:
+          diff: A DiffFile instance.
+          Other arguments: see the DefaultStyleErrorHandler.__init__()
+                           documentation for the other arguments.
+
+        """
+        self._diff = diff
+        self._default_error_handler = DefaultStyleErrorHandler(file_path,
+                                          options,
+                                          increment_error_count,
+                                          stderr_write)
+
+        # The line numbers of the modified lines. This is set lazily.
+        self._line_numbers = set()
+
+    def _get_line_numbers(self):
+        """Return the line numbers of the modified lines."""
+        if not self._line_numbers:
+            for line in self._diff.lines:
+                # When deleted line is not set, it means that
+                # the line is newly added.
+                if not line[0]:
+                    self._line_numbers.add(line[1])
+
+        return self._line_numbers
+
+    def __call__(self, line_number, category, confidence, message):
+        """Handle the occurrence of a style error.
+
+        This function does not report errors occurring in lines not
+        modified or added.
+
+        Args: see the DefaultStyleErrorHandler.__call__() documentation.
+
+        """
+        if line_number not in self._get_line_numbers():
+            # Then the error is not reportable.
+            return
+
+        self._default_error_handler(line_number, category, confidence,
+                                    message)
+
diff --git a/WebKitTools/Scripts/webkitpy/style/error_handlers_unittest.py b/WebKitTools/Scripts/webkitpy/style/error_handlers_unittest.py
new file mode 100644
index 0000000..6a91ff2
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/error_handlers_unittest.py
@@ -0,0 +1,163 @@
+# 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:
+# 1.  Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+# 2.  Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT 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 tests for error_handlers.py."""
+
+
+import unittest
+
+from .. style_references import parse_patch
+from checker import ProcessorOptions
+from error_handlers import DefaultStyleErrorHandler
+from error_handlers import PatchStyleErrorHandler
+
+
+class StyleErrorHandlerTestBase(unittest.TestCase):
+
+    def setUp(self):
+        self._error_messages = ""
+        self._error_count = 0
+
+    def _mock_increment_error_count(self):
+        self._error_count += 1
+
+    def _mock_stderr_write(self, message):
+        self._error_messages += message
+
+
+class DefaultStyleErrorHandlerTest(StyleErrorHandlerTestBase):
+
+    """Tests DefaultStyleErrorHandler class."""
+
+    _category = "whitespace/tab"
+
+    def _options(self, output_format):
+        return ProcessorOptions(verbosity=3, output_format=output_format)
+
+    def _error_handler(self, options):
+        file_path = "foo.h"
+        return DefaultStyleErrorHandler(file_path,
+                                        options,
+                                        self._mock_increment_error_count,
+                                        self._mock_stderr_write)
+
+    def _prepare_call(self, output_format="emacs"):
+        """Return options after initializing."""
+        options = self._options(output_format)
+
+        # Test that count is initialized to zero.
+        self.assertEquals(0, self._error_count)
+        self.assertEquals("", self._error_messages)
+
+        return options
+
+    def _call_error_handler(self, options, confidence):
+        """Handle an error with given confidence."""
+        handle_error = self._error_handler(options)
+
+        line_number = 100
+        message = "message"
+
+        handle_error(line_number, self._category, confidence, message)
+
+    def test_call_non_reportable(self):
+        """Test __call__() method with a non-reportable error."""
+        confidence = 1
+        options = self._prepare_call()
+
+        # Confirm the error is not reportable.
+        self.assertFalse(options.is_reportable(self._category, confidence))
+
+        self._call_error_handler(options, confidence)
+
+        self.assertEquals(0, self._error_count)
+        self.assertEquals("", self._error_messages)
+
+    def test_call_reportable_emacs(self):
+        """Test __call__() method with a reportable error and emacs format."""
+        confidence = 5
+        options = self._prepare_call("emacs")
+
+        self._call_error_handler(options, confidence)
+
+        self.assertEquals(1, self._error_count)
+        self.assertEquals(self._error_messages,
+                          "foo.h:100:  message  [whitespace/tab] [5]\n")
+
+    def test_call_reportable_vs7(self):
+        """Test __call__() method with a reportable error and vs7 format."""
+        confidence = 5
+        options = self._prepare_call("vs7")
+
+        self._call_error_handler(options, confidence)
+
+        self.assertEquals(1, self._error_count)
+        self.assertEquals(self._error_messages,
+                          "foo.h(100):  message  [whitespace/tab] [5]\n")
+
+
+class PatchStyleErrorHandlerTest(StyleErrorHandlerTestBase):
+
+    """Tests PatchStyleErrorHandler class."""
+
+    file_path = "__init__.py"
+
+    patch_string = """diff --git a/__init__.py b/__init__.py
+index ef65bee..e3db70e 100644
+--- a/__init__.py
++++ b/__init__.py
+@@ -1 +1,2 @@
+ # Required for Python to search this directory for module files
++# New line
+
+"""
+
+    def test_call(self):
+        patch_files = parse_patch(self.patch_string)
+        diff = patch_files[self.file_path]
+
+        options = ProcessorOptions(verbosity=3)
+
+        handle_error = PatchStyleErrorHandler(diff,
+                                              self.file_path,
+                                              options,
+                                              self._mock_increment_error_count,
+                                              self._mock_stderr_write)
+
+        category = "whitespace/tab"
+        confidence = 5
+        message = "message"
+
+        # Confirm error is reportable.
+        self.assertTrue(options.is_reportable(category, confidence))
+
+        # Confirm error count initialized to zero.
+        self.assertEquals(0, self._error_count)
+
+        # Test error in unmodified line (error count does not increment).
+        handle_error(1, category, confidence, message)
+        self.assertEquals(0, self._error_count)
+
+        # Test error in modified line (error count increments).
+        handle_error(2, category, confidence, message)
+        self.assertEquals(1, self._error_count)
+
diff --git a/WebKitTools/Scripts/webkitpy/style/processors/__init__.py b/WebKitTools/Scripts/webkitpy/style/processors/__init__.py
new file mode 100644
index 0000000..ef65bee
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/processors/__init__.py
@@ -0,0 +1 @@
+# Required for Python to search this directory for module files
diff --git a/WebKitTools/Scripts/webkitpy/style/processors/cpp.py b/WebKitTools/Scripts/webkitpy/style/processors/cpp.py
new file mode 100644
index 0000000..e1f41a4
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/processors/cpp.py
@@ -0,0 +1,3007 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2009 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:
+#
+#    * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#    * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# 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.
+
+# 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
+
+
+# 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',
+    ])
+
+
+# Non-STL C++ system headers.
+_CPP_HEADERS = frozenset([
+    'algo.h', 'builtinbuf.h', 'bvector.h', 'cassert', 'cctype',
+    'cerrno', 'cfloat', 'ciso646', 'climits', 'clocale', 'cmath',
+    'complex', 'complex.h', 'csetjmp', 'csignal', 'cstdarg', 'cstddef',
+    'cstdio', 'cstdlib', 'cstring', 'ctime', 'cwchar', 'cwctype',
+    'defalloc.h', 'deque.h', 'editbuf.h', 'exception', 'fstream',
+    'fstream.h', 'hashtable.h', 'heap.h', 'indstream.h', 'iomanip',
+    'iomanip.h', 'ios', 'iosfwd', 'iostream', 'iostream.h', 'istream.h',
+    'iterator.h', 'limits', 'map.h', 'multimap.h', 'multiset.h',
+    'numeric', 'ostream.h', 'parsestream.h', 'pfstream.h', 'PlotFile.h',
+    'procbuf.h', 'pthread_alloc.h', 'rope', 'rope.h', 'ropeimpl.h',
+    'SFile.h', 'slist', 'slist.h', 'stack.h', 'stdexcept',
+    'stdiostream.h', 'streambuf.h', 'stream.h', 'strfile.h', 'string',
+    'strstream', 'strstream.h', 'tempbuf.h', 'tree.h', 'typeinfo', 'valarray',
+    ])
+
+
+# Assertion macros.  These are defined in base/logging.h and
+# testing/base/gunit.h.  Note that the _M versions need to come first
+# for substring matching to work.
+_CHECK_MACROS = [
+    'DCHECK', 'CHECK',
+    'EXPECT_TRUE_M', 'EXPECT_TRUE',
+    'ASSERT_TRUE_M', 'ASSERT_TRUE',
+    'EXPECT_FALSE_M', 'EXPECT_FALSE',
+    'ASSERT_FALSE_M', 'ASSERT_FALSE',
+    ]
+
+# Replacement macros for CHECK/DCHECK/EXPECT_TRUE/EXPECT_FALSE
+_CHECK_REPLACEMENT = dict([(m, {}) for m in _CHECK_MACROS])
+
+for op, replacement in [('==', 'EQ'), ('!=', 'NE'),
+                        ('>=', 'GE'), ('>', 'GT'),
+                        ('<=', 'LE'), ('<', 'LT')]:
+    _CHECK_REPLACEMENT['DCHECK'][op] = 'DCHECK_%s' % replacement
+    _CHECK_REPLACEMENT['CHECK'][op] = 'CHECK_%s' % replacement
+    _CHECK_REPLACEMENT['EXPECT_TRUE'][op] = 'EXPECT_%s' % replacement
+    _CHECK_REPLACEMENT['ASSERT_TRUE'][op] = 'ASSERT_%s' % replacement
+    _CHECK_REPLACEMENT['EXPECT_TRUE_M'][op] = 'EXPECT_%s_M' % replacement
+    _CHECK_REPLACEMENT['ASSERT_TRUE_M'][op] = 'ASSERT_%s_M' % replacement
+
+for op, inv_replacement in [('==', 'NE'), ('!=', 'EQ'),
+                            ('>=', 'LT'), ('>', 'LE'),
+                            ('<=', 'GT'), ('<', 'GE')]:
+    _CHECK_REPLACEMENT['EXPECT_FALSE'][op] = 'EXPECT_%s' % inv_replacement
+    _CHECK_REPLACEMENT['ASSERT_FALSE'][op] = 'ASSERT_%s' % inv_replacement
+    _CHECK_REPLACEMENT['EXPECT_FALSE_M'][op] = 'EXPECT_%s_M' % inv_replacement
+    _CHECK_REPLACEMENT['ASSERT_FALSE_M'][op] = 'ASSERT_%s_M' % inv_replacement
+
+
+# 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
+
+
+# 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)
+    return _regexp_compile_cache[pattern].match(s)
+
+
+def search(pattern, s):
+    """Searches the string for the pattern, caching the compiled regexp."""
+    if not pattern in _regexp_compile_cache:
+        _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+    return _regexp_compile_cache[pattern].search(s)
+
+
+def sub(pattern, replacement, s):
+    """Substitutes occurrences of a pattern, caching the compiled regexp."""
+    if not pattern in _regexp_compile_cache:
+        _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+    return _regexp_compile_cache[pattern].sub(replacement, s)
+
+
+def subn(pattern, replacement, s):
+    """Substitutes occurrences of a pattern, caching the compiled regexp."""
+    if not pattern in _regexp_compile_cache:
+        _regexp_compile_cache[pattern] = sre_compile.compile(pattern)
+    return _regexp_compile_cache[pattern].subn(replacement, s)
+
+
+def up_to_unmatched_closing_paren(s):
+    """Splits a string into two parts up to first unmatched ')'.
+
+    Args:
+      s: a string which is a substring of line after '('
+      (e.g., "a == (b + c))").
+
+    Returns:
+      A pair of strings (prefix before first unmatched ')',
+      reminder of s after first unmatched ')'), e.g.,
+      up_to_unmatched_closing_paren("a == (b + c)) { ")
+      returns "a == (b + c)", " {".
+      Returns None, None if there is no unmatched ')'
+
+    """
+    i = 1
+    for pos, c in enumerate(s):
+      if c == '(':
+        i += 1
+      elif c == ')':
+        i -= 1
+        if i == 0:
+          return s[:pos], s[pos + 1:]
+    return None, None
+
+class _IncludeState(dict):
+    """Tracks line numbers for includes, and the order in which includes appear.
+
+    As a dict, an _IncludeState object serves as a mapping between include
+    filename and line number on which that file was included.
+
+    Call check_next_include_order() once for each header in the file, passing
+    in the type constants defined above. Calls in an illegal order will
+    raise an _IncludeError with an appropriate error message.
+
+    """
+    # self._section will move monotonically through this set. If it ever
+    # needs to move backwards, check_next_include_order will raise an error.
+    _INITIAL_SECTION = 0
+    _CONFIG_SECTION = 1
+    _PRIMARY_SECTION = 2
+    _OTHER_SECTION = 3
+
+    _TYPE_NAMES = {
+        _CONFIG_HEADER: 'WebCore config.h',
+        _PRIMARY_HEADER: 'header this file implements',
+        _OTHER_HEADER: 'other header',
+        _MOC_HEADER: 'moc file',
+        }
+    _SECTION_NAMES = {
+        _INITIAL_SECTION: "... nothing.",
+        _CONFIG_SECTION: "WebCore config.h.",
+        _PRIMARY_SECTION: 'a header this file implements.',
+        _OTHER_SECTION: 'other header.',
+        }
+
+    def __init__(self):
+        dict.__init__(self)
+        self._section = self._INITIAL_SECTION
+        self._visited_primary_section = False
+        self.header_types = dict();
+
+    def visited_primary_section(self):
+        return self._visited_primary_section
+
+    def check_next_include_order(self, header_type, file_is_header):
+        """Returns a non-empty error message if the next header is out of order.
+
+        This function also updates the internal state to be ready to check
+        the next include.
+
+        Args:
+          header_type: One of the _XXX_HEADER constants defined above.
+          file_is_header: Whether the file that owns this _IncludeState is itself a header
+
+        Returns:
+          The empty string if the header is in the right order, or an
+          error message describing what's wrong.
+
+        """
+        if header_type == _CONFIG_HEADER and file_is_header:
+            return 'Header file should not contain WebCore config.h.'
+        if header_type == _PRIMARY_HEADER and file_is_header:
+            return 'Header file should not contain itself.'
+        if header_type == _MOC_HEADER:
+            return ''
+
+        error_message = ''
+        if self._section != self._OTHER_SECTION:
+            before_error_message = ('Found %s before %s' %
+                                    (self._TYPE_NAMES[header_type],
+                                     self._SECTION_NAMES[self._section + 1]))
+        after_error_message = ('Found %s after %s' %
+                                (self._TYPE_NAMES[header_type],
+                                 self._SECTION_NAMES[self._section]))
+
+        if header_type == _CONFIG_HEADER:
+            if self._section >= self._CONFIG_SECTION:
+                error_message = after_error_message
+            self._section = self._CONFIG_SECTION
+        elif header_type == _PRIMARY_HEADER:
+            if self._section >= self._PRIMARY_SECTION:
+                error_message = after_error_message
+            elif self._section < self._CONFIG_SECTION:
+                error_message = before_error_message
+            self._section = self._PRIMARY_SECTION
+            self._visited_primary_section = True
+        else:
+            assert header_type == _OTHER_HEADER
+            if not file_is_header and self._section < self._PRIMARY_SECTION:
+                error_message = before_error_message
+            self._section = self._OTHER_SECTION
+
+        return error_message
+
+
+class _FunctionState(object):
+    """Tracks current function name and the number of lines in its body.
+
+    Attributes:
+      verbosity: The verbosity level to use while checking style.
+
+    """
+
+    _NORMAL_TRIGGER = 250  # for --v=0, 500 for --v=1, etc.
+    _TEST_TRIGGER = 400    # about 50% more than _NORMAL_TRIGGER.
+
+    def __init__(self, verbosity):
+        self.verbosity = verbosity
+        self.in_a_function = False
+        self.lines_in_function = 0
+        self.current_function = ''
+
+    def begin(self, function_name):
+        """Start analyzing function body.
+
+        Args:
+            function_name: The name of the function being tracked.
+        """
+        self.in_a_function = True
+        self.lines_in_function = 0
+        self.current_function = function_name
+
+    def count(self):
+        """Count line in current function body."""
+        if self.in_a_function:
+            self.lines_in_function += 1
+
+    def check(self, error, line_number):
+        """Report if too many lines in function body.
+
+        Args:
+          error: The function to call with any errors found.
+          line_number: The number of the line to check.
+        """
+        if match(r'T(EST|est)', self.current_function):
+            base_trigger = self._TEST_TRIGGER
+        else:
+            base_trigger = self._NORMAL_TRIGGER
+        trigger = base_trigger * 2 ** self.verbosity
+
+        if self.lines_in_function > trigger:
+            error_level = int(math.log(self.lines_in_function / base_trigger, 2))
+            # 50 => 0, 100 => 1, 200 => 2, 400 => 3, 800 => 4, 1600 => 5, ...
+            if error_level > 5:
+                error_level = 5
+            error(line_number, 'readability/fn_size', error_level,
+                  'Small and focused functions are preferred:'
+                  ' %s has %d non-comment lines'
+                  ' (error triggered by exceeding %d lines).'  % (
+                      self.current_function, self.lines_in_function, trigger))
+
+    def end(self):
+        """Stop analizing function body."""
+        self.in_a_function = False
+
+
+class _IncludeError(Exception):
+    """Indicates a problem with the include order in a file."""
+    pass
+
+
+def is_c_or_objective_c(file_extension):
+   """Return whether the file extension corresponds to C or Objective-C.
+
+   Args:
+     file_extension: The file extension without the leading dot.
+
+   """
+   return file_extension in ['c', 'm']
+
+
+class FileInfo:
+    """Provides utility functions for filenames.
+
+    FileInfo provides easy access to the components of a file's path
+    relative to the project root.
+    """
+
+    def __init__(self, filename):
+        self._filename = filename
+
+    def full_name(self):
+        """Make Windows paths like Unix."""
+        return os.path.abspath(self._filename).replace('\\', '/')
+
+    def repository_name(self):
+        """Full name after removing the local path to the repository.
+
+        If we have a real absolute path name here we can try to do something smart:
+        detecting the root of the checkout and truncating /path/to/checkout from
+        the name so that we get header guards that don't include things like
+        "C:\Documents and Settings\..." or "/home/username/..." in them and thus
+        people on different computers who have checked the source out to different
+        locations won't see bogus errors.
+        """
+        fullname = self.full_name()
+
+        if os.path.exists(fullname):
+            project_dir = os.path.dirname(fullname)
+
+            if os.path.exists(os.path.join(project_dir, ".svn")):
+                # If there's a .svn file in the current directory, we
+                # recursively look up the directory tree for the top
+                # of the SVN checkout
+                root_dir = project_dir
+                one_up_dir = os.path.dirname(root_dir)
+                while os.path.exists(os.path.join(one_up_dir, ".svn")):
+                    root_dir = os.path.dirname(root_dir)
+                    one_up_dir = os.path.dirname(one_up_dir)
+
+                prefix = os.path.commonprefix([root_dir, project_dir])
+                return fullname[len(prefix) + 1:]
+
+            # Not SVN? Try to find a git top level directory by
+            # searching up from the current path.
+            root_dir = os.path.dirname(fullname)
+            while (root_dir != os.path.dirname(root_dir)
+                   and not os.path.exists(os.path.join(root_dir, ".git"))):
+                root_dir = os.path.dirname(root_dir)
+                if os.path.exists(os.path.join(root_dir, ".git")):
+                    prefix = os.path.commonprefix([root_dir, project_dir])
+                    return fullname[len(prefix) + 1:]
+
+        # Don't know what to do; header guard warnings may be wrong...
+        return fullname
+
+    def split(self):
+        """Splits the file into the directory, basename, and extension.
+
+        For 'chrome/browser/browser.cpp', Split() would
+        return ('chrome/browser', 'browser', '.cpp')
+
+        Returns:
+          A tuple of (directory, basename, extension).
+        """
+
+        googlename = self.repository_name()
+        project, rest = os.path.split(googlename)
+        return (project,) + os.path.splitext(rest)
+
+    def base_name(self):
+        """File base name - text after the final slash, before the final period."""
+        return self.split()[1]
+
+    def extension(self):
+        """File extension - text following the final period."""
+        return self.split()[2]
+
+    def no_extension(self):
+        """File has no source file extension."""
+        return '/'.join(self.split()[0:2])
+
+    def is_source(self):
+        """File has a source file extension."""
+        return self.extension()[1:] in ('c', 'cc', 'cpp', 'cxx')
+
+
+# Matches standard C++ escape esequences per 2.13.2.3 of the C++ standard.
+_RE_PATTERN_CLEANSE_LINE_ESCAPES = re.compile(
+    r'\\([abfnrtv?"\\\']|\d+|x[0-9a-fA-F]+)')
+# Matches strings.  Escape codes should already be removed by ESCAPES.
+_RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES = re.compile(r'"[^"]*"')
+# Matches characters.  Escape codes should already be removed by ESCAPES.
+_RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES = re.compile(r"'.'")
+# Matches multi-line C++ comments.
+# This RE is a little bit more complicated than one might expect, because we
+# have to take care of space removals tools so we can handle comments inside
+# statements better.
+# The current rule is: We only clear spaces from both sides when we're at the
+# end of the line. Otherwise, we try to remove spaces from the right side,
+# if this doesn't work we try on left side but only if there's a non-character
+# on the right.
+_RE_PATTERN_CLEANSE_LINE_C_COMMENTS = re.compile(
+    r"""(\s*/\*.*\*/\s*$|
+            /\*.*\*/\s+|
+         \s+/\*.*\*/(?=\W)|
+            /\*.*\*/)""", re.VERBOSE)
+
+
+def is_cpp_string(line):
+    """Does line terminate so, that the next symbol is in string constant.
+
+    This function does not consider single-line nor multi-line comments.
+
+    Args:
+      line: is a partial line of code starting from the 0..n.
+
+    Returns:
+      True, if next character appended to 'line' is inside a
+      string constant.
+    """
+
+    line = line.replace(r'\\', 'XX')  # after this, \\" does not match to \"
+    return ((line.count('"') - line.count(r'\"') - line.count("'\"'")) & 1) == 1
+
+
+def find_next_multi_line_comment_start(lines, line_index):
+    """Find the beginning marker for a multiline comment."""
+    while line_index < len(lines):
+        if lines[line_index].strip().startswith('/*'):
+            # Only return this marker if the comment goes beyond this line
+            if lines[line_index].strip().find('*/', 2) < 0:
+                return line_index
+        line_index += 1
+    return len(lines)
+
+
+def find_next_multi_line_comment_end(lines, line_index):
+    """We are inside a comment, find the end marker."""
+    while line_index < len(lines):
+        if lines[line_index].strip().endswith('*/'):
+            return line_index
+        line_index += 1
+    return len(lines)
+
+
+def remove_multi_line_comments_from_range(lines, begin, end):
+    """Clears a range of lines for multi-line comments."""
+    # Having // dummy comments makes the lines non-empty, so we will not get
+    # unnecessary blank line warnings later in the code.
+    for i in range(begin, end):
+        lines[i] = '// dummy'
+
+
+def remove_multi_line_comments(lines, error):
+    """Removes multiline (c-style) comments from lines."""
+    line_index = 0
+    while line_index < len(lines):
+        line_index_begin = find_next_multi_line_comment_start(lines, line_index)
+        if line_index_begin >= len(lines):
+            return
+        line_index_end = find_next_multi_line_comment_end(lines, line_index_begin)
+        if line_index_end >= len(lines):
+            error(line_index_begin + 1, 'readability/multiline_comment', 5,
+                  'Could not find end of multi-line comment')
+            return
+        remove_multi_line_comments_from_range(lines, line_index_begin, line_index_end + 1)
+        line_index = line_index_end + 1
+
+
+def cleanse_comments(line):
+    """Removes //-comments and single-line C-style /* */ comments.
+
+    Args:
+      line: A line of C++ source.
+
+    Returns:
+      The line with single-line comments removed.
+    """
+    comment_position = line.find('//')
+    if comment_position != -1 and not is_cpp_string(line[:comment_position]):
+        line = line[:comment_position]
+    # get rid of /* ... */
+    return _RE_PATTERN_CLEANSE_LINE_C_COMMENTS.sub('', line)
+
+
+class CleansedLines(object):
+    """Holds 3 copies of all lines with different preprocessing applied to them.
+
+    1) elided member contains lines without strings and comments,
+    2) lines member contains lines without comments, and
+    3) raw member contains all the lines without processing.
+    All these three members are of <type 'list'>, and of the same length.
+    """
+
+    def __init__(self, lines):
+        self.elided = []
+        self.lines = []
+        self.raw_lines = lines
+        self._num_lines = len(lines)
+        for line_number in range(len(lines)):
+            self.lines.append(cleanse_comments(lines[line_number]))
+            elided = self.collapse_strings(lines[line_number])
+            self.elided.append(cleanse_comments(elided))
+
+    def num_lines(self):
+        """Returns the number of lines represented."""
+        return self._num_lines
+
+    @staticmethod
+    def collapse_strings(elided):
+        """Collapses strings and chars on a line to simple "" or '' blocks.
+
+        We nix strings first so we're not fooled by text like '"http://"'
+
+        Args:
+          elided: The line being processed.
+
+        Returns:
+          The line with collapsed strings.
+        """
+        if not _RE_PATTERN_INCLUDE.match(elided):
+            # Remove escaped characters first to make quote/single quote collapsing
+            # basic.  Things that look like escaped characters shouldn't occur
+            # outside of strings and chars.
+            elided = _RE_PATTERN_CLEANSE_LINE_ESCAPES.sub('', elided)
+            elided = _RE_PATTERN_CLEANSE_LINE_SINGLE_QUOTES.sub("''", elided)
+            elided = _RE_PATTERN_CLEANSE_LINE_DOUBLE_QUOTES.sub('""', elided)
+        return elided
+
+
+def close_expression(clean_lines, line_number, pos):
+    """If input points to ( or { or [, finds the position that closes it.
+
+    If lines[line_number][pos] points to a '(' or '{' or '[', finds the the
+    line_number/pos that correspond to the closing of the expression.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      pos: A position on the line.
+
+    Returns:
+      A tuple (line, line_number, pos) pointer *past* the closing brace, or
+      (line, len(lines), -1) if we never find a close.  Note we ignore
+      strings and comments when matching; and the line we return is the
+      'cleansed' line at line_number.
+    """
+
+    line = clean_lines.elided[line_number]
+    start_character = line[pos]
+    if start_character not in '({[':
+        return (line, clean_lines.num_lines(), -1)
+    if start_character == '(':
+        end_character = ')'
+    if start_character == '[':
+        end_character = ']'
+    if start_character == '{':
+        end_character = '}'
+
+    num_open = line.count(start_character) - line.count(end_character)
+    while line_number < clean_lines.num_lines() and num_open > 0:
+        line_number += 1
+        line = clean_lines.elided[line_number]
+        num_open += line.count(start_character) - line.count(end_character)
+    # OK, now find the end_character that actually got us back to even
+    endpos = len(line)
+    while num_open >= 0:
+        endpos = line.rfind(')', 0, endpos)
+        num_open -= 1                 # chopped off another )
+    return (line, line_number, endpos + 1)
+
+
+def check_for_copyright(lines, error):
+    """Logs an error if no Copyright message appears at the top of the file."""
+
+    # We'll say it should occur by line 10. Don't forget there's a
+    # dummy line at the front.
+    for line in xrange(1, min(len(lines), 11)):
+        if re.search(r'Copyright', lines[line], re.I):
+            break
+    else:                       # means no copyright line was found
+        error(0, 'legal/copyright', 5,
+              'No copyright message found.  '
+              'You should have a line: "Copyright [year] <Copyright Owner>"')
+
+
+def get_header_guard_cpp_variable(filename):
+    """Returns the CPP variable that should be used as a header guard.
+
+    Args:
+      filename: The name of a C++ header file.
+
+    Returns:
+      The CPP variable that should be used as a header guard in the
+      named file.
+
+    """
+
+    return sub(r'[-.\s]', '_', os.path.basename(filename))
+
+
+def check_for_header_guard(filename, lines, error):
+    """Checks that the file contains a header guard.
+
+    Logs an error if no #ifndef header guard is present.  For other
+    headers, checks that the full pathname is used.
+
+    Args:
+      filename: The name of the C++ header file.
+      lines: An array of strings, each representing a line of the file.
+      error: The function to call with any errors found.
+    """
+
+    cppvar = get_header_guard_cpp_variable(filename)
+
+    ifndef = None
+    ifndef_line_number = 0
+    define = None
+    for line_number, line in enumerate(lines):
+        line_split = line.split()
+        if len(line_split) >= 2:
+            # find the first occurrence of #ifndef and #define, save arg
+            if not ifndef and line_split[0] == '#ifndef':
+                # set ifndef to the header guard presented on the #ifndef line.
+                ifndef = line_split[1]
+                ifndef_line_number = line_number
+            if not define and line_split[0] == '#define':
+                define = line_split[1]
+            if define and ifndef:
+                break
+
+    if not ifndef or not define or ifndef != define:
+        error(0, 'build/header_guard', 5,
+              'No #ifndef header guard found, suggested CPP variable is: %s' %
+              cppvar)
+        return
+
+    # The guard should be File_h.
+    if ifndef != cppvar:
+        error(ifndef_line_number, 'build/header_guard', 5,
+              '#ifndef header guard has wrong style, please use: %s' % cppvar)
+
+
+def check_for_unicode_replacement_characters(lines, error):
+    """Logs an error for each line containing Unicode replacement characters.
+
+    These indicate that either the file contained invalid UTF-8 (likely)
+    or Unicode replacement characters (which it shouldn't).  Note that
+    it's possible for this to throw off line numbering if the invalid
+    UTF-8 occurred adjacent to a newline.
+
+    Args:
+      lines: An array of strings, each representing a line of the file.
+      error: The function to call with any errors found.
+    """
+    for line_number, line in enumerate(lines):
+        if u'\ufffd' in line:
+            error(line_number, 'readability/utf8', 5,
+                  'Line contains invalid UTF-8 (or Unicode replacement character).')
+
+
+def check_for_new_line_at_eof(lines, error):
+    """Logs an error if there is no newline char at the end of the file.
+
+    Args:
+      lines: An array of strings, each representing a line of the file.
+      error: The function to call with any errors found.
+    """
+
+    # The array lines() was created by adding two newlines to the
+    # original file (go figure), then splitting on \n.
+    # To verify that the file ends in \n, we just have to make sure the
+    # last-but-two element of lines() exists and is empty.
+    if len(lines) < 3 or lines[-2]:
+        error(len(lines) - 2, 'whitespace/ending_newline', 5,
+              'Could not find a newline character at the end of the file.')
+
+
+def check_for_multiline_comments_and_strings(clean_lines, line_number, error):
+    """Logs an error if we see /* ... */ or "..." that extend past one line.
+
+    /* ... */ comments are legit inside macros, for one line.
+    Otherwise, we prefer // comments, so it's ok to warn about the
+    other.  Likewise, it's ok for strings to extend across multiple
+    lines, as long as a line continuation character (backslash)
+    terminates each line. Although not currently prohibited by the C++
+    style guide, it's ugly and unnecessary. We don't do well with either
+    in this lint program, so we warn about both.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    line = clean_lines.elided[line_number]
+
+    # Remove all \\ (escaped backslashes) from the line. They are OK, and the
+    # second (escaped) slash may trigger later \" detection erroneously.
+    line = line.replace('\\\\', '')
+
+    if line.count('/*') > line.count('*/'):
+        error(line_number, 'readability/multiline_comment', 5,
+              'Complex multi-line /*...*/-style comment found. '
+              'Lint may give bogus warnings.  '
+              'Consider replacing these with //-style comments, '
+              'with #if 0...#endif, '
+              'or with more clearly structured multi-line comments.')
+
+    if (line.count('"') - line.count('\\"')) % 2:
+        error(line_number, 'readability/multiline_string', 5,
+              'Multi-line string ("...") found.  This lint script doesn\'t '
+              'do well with such strings, and may give bogus warnings.  They\'re '
+              'ugly and unnecessary, and you should use concatenation instead".')
+
+
+_THREADING_LIST = (
+    ('asctime(', 'asctime_r('),
+    ('ctime(', 'ctime_r('),
+    ('getgrgid(', 'getgrgid_r('),
+    ('getgrnam(', 'getgrnam_r('),
+    ('getlogin(', 'getlogin_r('),
+    ('getpwnam(', 'getpwnam_r('),
+    ('getpwuid(', 'getpwuid_r('),
+    ('gmtime(', 'gmtime_r('),
+    ('localtime(', 'localtime_r('),
+    ('rand(', 'rand_r('),
+    ('readdir(', 'readdir_r('),
+    ('strtok(', 'strtok_r('),
+    ('ttyname(', 'ttyname_r('),
+    )
+
+
+def check_posix_threading(clean_lines, line_number, error):
+    """Checks for calls to thread-unsafe functions.
+
+    Much code has been originally written without consideration of
+    multi-threading. Also, engineers are relying on their old experience;
+    they have learned posix before threading extensions were added. These
+    tests guide the engineers to use thread-safe functions (when using
+    posix directly).
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    line = clean_lines.elided[line_number]
+    for single_thread_function, multithread_safe_function in _THREADING_LIST:
+        index = line.find(single_thread_function)
+        # Comparisons made explicit for clarity -- pylint: disable-msg=C6403
+        if index >= 0 and (index == 0 or (not line[index - 1].isalnum()
+                                          and line[index - 1] not in ('_', '.', '>'))):
+            error(line_number, 'runtime/threadsafe_fn', 2,
+                  'Consider using ' + multithread_safe_function +
+                  '...) instead of ' + single_thread_function +
+                  '...) for improved thread safety.')
+
+
+# Matches invalid increment: *count++, which moves pointer instead of
+# incrementing a value.
+_RE_PATTERN_INVALID_INCREMENT = re.compile(
+    r'^\s*\*\w+(\+\+|--);')
+
+
+def check_invalid_increment(clean_lines, line_number, error):
+    """Checks for invalid increment *count++.
+
+    For example following function:
+    void increment_counter(int* count) {
+        *count++;
+    }
+    is invalid, because it effectively does count++, moving pointer, and should
+    be replaced with ++*count, (*count)++ or *count += 1.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+    line = clean_lines.elided[line_number]
+    if _RE_PATTERN_INVALID_INCREMENT.match(line):
+        error(line_number, 'runtime/invalid_increment', 5,
+              'Changing pointer instead of value (or unused value of operator*).')
+
+
+class _ClassInfo(object):
+    """Stores information about a class."""
+
+    def __init__(self, name, line_number):
+        self.name = name
+        self.line_number = line_number
+        self.seen_open_brace = False
+        self.is_derived = False
+        self.virtual_method_line_number = None
+        self.has_virtual_destructor = False
+        self.brace_depth = 0
+
+
+class _ClassState(object):
+    """Holds the current state of the parse relating to class declarations.
+
+    It maintains a stack of _ClassInfos representing the parser's guess
+    as to the current nesting of class declarations. The innermost class
+    is at the top (back) of the stack. Typically, the stack will either
+    be empty or have exactly one entry.
+    """
+
+    def __init__(self):
+        self.classinfo_stack = []
+
+    def check_finished(self, error):
+        """Checks that all classes have been completely parsed.
+
+        Call this when all lines in a file have been processed.
+        Args:
+          error: The function to call with any errors found.
+        """
+        if self.classinfo_stack:
+            # Note: This test can result in false positives if #ifdef constructs
+            # get in the way of brace matching. See the testBuildClass test in
+            # cpp_style_unittest.py for an example of this.
+            error(self.classinfo_stack[0].line_number, 'build/class', 5,
+                  'Failed to find complete declaration of class %s' %
+                  self.classinfo_stack[0].name)
+
+
+class _FileState(object):
+    def __init__(self):
+        self._did_inside_namespace_indent_warning = False
+
+    def set_did_inside_namespace_indent_warning(self):
+        self._did_inside_namespace_indent_warning = True
+
+    def did_inside_namespace_indent_warning(self):
+        return self._did_inside_namespace_indent_warning
+
+def check_for_non_standard_constructs(clean_lines, line_number,
+                                      class_state, error):
+    """Logs an error if we see certain non-ANSI constructs ignored by gcc-2.
+
+    Complain about several constructs which gcc-2 accepts, but which are
+    not standard C++.  Warning about these in lint is one way to ease the
+    transition to new compilers.
+    - put storage class first (e.g. "static const" instead of "const static").
+    - "%lld" instead of %qd" in printf-type functions.
+    - "%1$d" is non-standard in printf-type functions.
+    - "\%" is an undefined character escape sequence.
+    - text after #endif is not allowed.
+    - invalid inner-style forward declaration.
+    - >? and <? operators, and their >?= and <?= cousins.
+    - classes with virtual methods need virtual destructors (compiler warning
+        available, but not turned on yet.)
+
+    Additionally, check for constructor/destructor style violations as it
+    is very convenient to do so while checking for gcc-2 compliance.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      class_state: A _ClassState instance which maintains information about
+                   the current stack of nested class declarations being parsed.
+      error: A callable to which errors are reported, which takes parameters:
+             line number, error level, and message
+    """
+
+    # Remove comments from the line, but leave in strings for now.
+    line = clean_lines.lines[line_number]
+
+    if search(r'printf\s*\(.*".*%[-+ ]?\d*q', line):
+        error(line_number, 'runtime/printf_format', 3,
+              '%q in format strings is deprecated.  Use %ll instead.')
+
+    if search(r'printf\s*\(.*".*%\d+\$', line):
+        error(line_number, 'runtime/printf_format', 2,
+              '%N$ formats are unconventional.  Try rewriting to avoid them.')
+
+    # Remove escaped backslashes before looking for undefined escapes.
+    line = line.replace('\\\\', '')
+
+    if search(r'("|\').*\\(%|\[|\(|{)', line):
+        error(line_number, 'build/printf_format', 3,
+              '%, [, (, and { are undefined character escapes.  Unescape them.')
+
+    # For the rest, work with both comments and strings removed.
+    line = clean_lines.elided[line_number]
+
+    if search(r'\b(const|volatile|void|char|short|int|long'
+              r'|float|double|signed|unsigned'
+              r'|schar|u?int8|u?int16|u?int32|u?int64)'
+              r'\s+(auto|register|static|extern|typedef)\b',
+              line):
+        error(line_number, 'build/storage_class', 5,
+              'Storage class (static, extern, typedef, etc) should be first.')
+
+    if match(r'\s*#\s*endif\s*[^/\s]+', line):
+        error(line_number, 'build/endif_comment', 5,
+              'Uncommented text after #endif is non-standard.  Use a comment.')
+
+    if match(r'\s*class\s+(\w+\s*::\s*)+\w+\s*;', line):
+        error(line_number, 'build/forward_decl', 5,
+              'Inner-style forward declarations are invalid.  Remove this line.')
+
+    if search(r'(\w+|[+-]?\d+(\.\d*)?)\s*(<|>)\?=?\s*(\w+|[+-]?\d+)(\.\d*)?', line):
+        error(line_number, 'build/deprecated', 3,
+              '>? and <? (max and min) operators are non-standard and deprecated.')
+
+    # Track class entry and exit, and attempt to find cases within the
+    # class declaration that don't meet the C++ style
+    # guidelines. Tracking is very dependent on the code matching Google
+    # style guidelines, but it seems to perform well enough in testing
+    # to be a worthwhile addition to the checks.
+    classinfo_stack = class_state.classinfo_stack
+    # Look for a class declaration
+    class_decl_match = match(
+        r'\s*(template\s*<[\w\s<>,:]*>\s*)?(class|struct)\s+(\w+(::\w+)*)', line)
+    if class_decl_match:
+        classinfo_stack.append(_ClassInfo(class_decl_match.group(3), line_number))
+
+    # Everything else in this function uses the top of the stack if it's
+    # not empty.
+    if not classinfo_stack:
+        return
+
+    classinfo = classinfo_stack[-1]
+
+    # If the opening brace hasn't been seen look for it and also
+    # parent class declarations.
+    if not classinfo.seen_open_brace:
+        # If the line has a ';' in it, assume it's a forward declaration or
+        # a single-line class declaration, which we won't process.
+        if line.find(';') != -1:
+            classinfo_stack.pop()
+            return
+        classinfo.seen_open_brace = (line.find('{') != -1)
+        # Look for a bare ':'
+        if search('(^|[^:]):($|[^:])', line):
+            classinfo.is_derived = True
+        if not classinfo.seen_open_brace:
+            return  # Everything else in this function is for after open brace
+
+    # The class may have been declared with namespace or classname qualifiers.
+    # The constructor and destructor will not have those qualifiers.
+    base_classname = classinfo.name.split('::')[-1]
+
+    # Look for single-argument constructors that aren't marked explicit.
+    # Technically a valid construct, but against style.
+    args = match(r'(?<!explicit)\s+%s\s*\(([^,()]+)\)'
+                 % re.escape(base_classname),
+                 line)
+    if (args
+        and args.group(1) != 'void'
+        and not match(r'(const\s+)?%s\s*&' % re.escape(base_classname),
+                      args.group(1).strip())):
+        error(line_number, 'runtime/explicit', 5,
+              'Single-argument constructors should be marked explicit.')
+
+    # Look for methods declared virtual.
+    if search(r'\bvirtual\b', line):
+        classinfo.virtual_method_line_number = line_number
+        # Only look for a destructor declaration on the same line. It would
+        # be extremely unlikely for the destructor declaration to occupy
+        # more than one line.
+        if search(r'~%s\s*\(' % base_classname, line):
+            classinfo.has_virtual_destructor = True
+
+    # Look for class end.
+    brace_depth = classinfo.brace_depth
+    brace_depth = brace_depth + line.count('{') - line.count('}')
+    if brace_depth <= 0:
+        classinfo = classinfo_stack.pop()
+        # Try to detect missing virtual destructor declarations.
+        # For now, only warn if a non-derived class with virtual methods lacks
+        # a virtual destructor. This is to make it less likely that people will
+        # declare derived virtual destructors without declaring the base
+        # destructor virtual.
+        if ((classinfo.virtual_method_line_number is not None)
+            and (not classinfo.has_virtual_destructor)
+            and (not classinfo.is_derived)):  # Only warn for base classes
+            error(classinfo.line_number, 'runtime/virtual', 4,
+                  'The class %s probably needs a virtual destructor due to '
+                  'having virtual method(s), one declared at line %d.'
+                  % (classinfo.name, classinfo.virtual_method_line_number))
+    else:
+        classinfo.brace_depth = brace_depth
+
+
+def check_spacing_for_function_call(line, line_number, error):
+    """Checks for the correctness of various spacing around function calls.
+
+    Args:
+      line: The text of the line to check.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    # Since function calls often occur inside if/for/foreach/while/switch
+    # expressions - which have their own, more liberal conventions - we
+    # first see if we should be looking inside such an expression for a
+    # function call, to which we can apply more strict standards.
+    function_call = line    # if there's no control flow construct, look at whole line
+    for pattern in (r'\bif\s*\((.*)\)\s*{',
+                    r'\bfor\s*\((.*)\)\s*{',
+                    r'\bforeach\s*\((.*)\)\s*{',
+                    r'\bwhile\s*\((.*)\)\s*[{;]',
+                    r'\bswitch\s*\((.*)\)\s*{'):
+        matched = search(pattern, line)
+        if matched:
+            function_call = matched.group(1)    # look inside the parens for function calls
+            break
+
+    # Except in if/for/foreach/while/switch, there should never be space
+    # immediately inside parens (eg "f( 3, 4 )").  We make an exception
+    # for nested parens ( (a+b) + c ).  Likewise, there should never be
+    # a space before a ( when it's a function argument.  I assume it's a
+    # function argument when the char before the whitespace is legal in
+    # a function name (alnum + _) and we're not starting a macro. Also ignore
+    # pointers and references to arrays and functions coz they're too tricky:
+    # we use a very simple way to recognize these:
+    # " (something)(maybe-something)" or
+    # " (something)(maybe-something," or
+    # " (something)[something]"
+    # Note that we assume the contents of [] to be short enough that
+    # they'll never need to wrap.
+    if (  # Ignore control structures.
+        not search(r'\b(if|for|foreach|while|switch|return|new|delete)\b', function_call)
+        # Ignore pointers/references to functions.
+        and not search(r' \([^)]+\)\([^)]*(\)|,$)', function_call)
+        # Ignore pointers/references to arrays.
+        and not search(r' \([^)]+\)\[[^\]]+\]', function_call)):
+        if search(r'\w\s*\([ \t](?!\s*\\$)', function_call):      # a ( used for a fn call
+            error(line_number, 'whitespace/parens', 4,
+                  'Extra space after ( in function call')
+        elif search(r'\([ \t]+(?!(\s*\\)|\()', function_call):
+            error(line_number, 'whitespace/parens', 2,
+                  'Extra space after (')
+        if (search(r'\w\s+\(', function_call)
+            and not search(r'#\s*define|typedef', function_call)):
+            error(line_number, 'whitespace/parens', 4,
+                  'Extra space before ( in function call')
+        # If the ) is followed only by a newline or a { + newline, assume it's
+        # part of a control statement (if/while/etc), and don't complain
+        if search(r'[^)\s]\s+\)(?!\s*$|{\s*$)', function_call):
+            error(line_number, 'whitespace/parens', 2,
+                  'Extra space before )')
+
+
+def is_blank_line(line):
+    """Returns true if the given line is blank.
+
+    We consider a line to be blank if the line is empty or consists of
+    only white spaces.
+
+    Args:
+      line: A line of a string.
+
+    Returns:
+      True, if the given line is blank.
+    """
+    return not line or line.isspace()
+
+
+def check_for_function_lengths(clean_lines, line_number, function_state, error):
+    """Reports for long function bodies.
+
+    For an overview why this is done, see:
+    http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Write_Short_Functions
+
+    Uses a simplistic algorithm assuming other style guidelines
+    (especially spacing) are followed.
+    Only checks unindented functions, so class members are unchecked.
+    Trivial bodies are unchecked, so constructors with huge initializer lists
+    may be missed.
+    Blank/comment lines are not counted so as to avoid encouraging the removal
+    of vertical space and commments just to get through a lint check.
+    NOLINT *on the last line of a function* disables this check.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      function_state: Current function name and lines in body so far.
+      error: The function to call with any errors found.
+    """
+    lines = clean_lines.lines
+    line = lines[line_number]
+    raw = clean_lines.raw_lines
+    raw_line = raw[line_number]
+    joined_line = ''
+
+    starting_func = False
+    regexp = r'(\w(\w|::|\*|\&|\s)*)\('  # decls * & space::name( ...
+    match_result = match(regexp, line)
+    if match_result:
+        # If the name is all caps and underscores, figure it's a macro and
+        # ignore it, unless it's TEST or TEST_F.
+        function_name = match_result.group(1).split()[-1]
+        if function_name == 'TEST' or function_name == 'TEST_F' or (not match(r'[A-Z_]+$', function_name)):
+            starting_func = True
+
+    if starting_func:
+        body_found = False
+        for start_line_number in xrange(line_number, clean_lines.num_lines()):
+            start_line = lines[start_line_number]
+            joined_line += ' ' + start_line.lstrip()
+            if search(r'(;|})', start_line):  # Declarations and trivial functions
+                body_found = True
+                break                              # ... ignore
+            if search(r'{', start_line):
+                body_found = True
+                function = search(r'((\w|:)*)\(', line).group(1)
+                if match(r'TEST', function):    # Handle TEST... macros
+                    parameter_regexp = search(r'(\(.*\))', joined_line)
+                    if parameter_regexp:             # Ignore bad syntax
+                        function += parameter_regexp.group(1)
+                else:
+                    function += '()'
+                function_state.begin(function)
+                break
+        if not body_found:
+            # No body for the function (or evidence of a non-function) was found.
+            error(line_number, 'readability/fn_size', 5,
+                  'Lint failed to find start of function body.')
+    elif match(r'^\}\s*$', line):  # function end
+        if not search(r'\bNOLINT\b', raw_line):
+            function_state.check(error, line_number)
+        function_state.end()
+    elif not match(r'^\s*$', line):
+        function_state.count()  # Count non-blank/non-comment lines.
+
+
+def check_spacing(file_extension, clean_lines, line_number, error):
+    """Checks for the correctness of various spacing issues in the code.
+
+    Things we check for: spaces around operators, spaces after
+    if/for/while/switch, no spaces around parens in function calls, two
+    spaces between code and comment, don't start a block with a blank
+    line, don't end a function with a blank line, don't have too many
+    blank lines in a row.
+
+    Args:
+      file_extension: The current file extension, without the leading dot.
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    raw = clean_lines.raw_lines
+    line = raw[line_number]
+
+    # Before nixing comments, check if the line is blank for no good
+    # reason.  This includes the first line after a block is opened, and
+    # blank lines at the end of a function (ie, right before a line like '}').
+    if is_blank_line(line):
+        elided = clean_lines.elided
+        previous_line = elided[line_number - 1]
+        previous_brace = previous_line.rfind('{')
+        # FIXME: Don't complain if line before blank line, and line after,
+        #        both start with alnums and are indented the same amount.
+        #        This ignores whitespace at the start of a namespace block
+        #        because those are not usually indented.
+        if (previous_brace != -1 and previous_line[previous_brace:].find('}') == -1
+            and previous_line[:previous_brace].find('namespace') == -1):
+            # OK, we have a blank line at the start of a code block.  Before we
+            # complain, we check if it is an exception to the rule: The previous
+            # non-empty line has the parameters of a function header that are indented
+            # 4 spaces (because they did not fit in a 80 column line when placed on
+            # the same line as the function name).  We also check for the case where
+            # the previous line is indented 6 spaces, which may happen when the
+            # initializers of a constructor do not fit into a 80 column line.
+            exception = False
+            if match(r' {6}\w', previous_line):  # Initializer list?
+                # We are looking for the opening column of initializer list, which
+                # should be indented 4 spaces to cause 6 space indentation afterwards.
+                search_position = line_number - 2
+                while (search_position >= 0
+                       and match(r' {6}\w', elided[search_position])):
+                    search_position -= 1
+                exception = (search_position >= 0
+                             and elided[search_position][:5] == '    :')
+            else:
+                # Search for the function arguments or an initializer list.  We use a
+                # simple heuristic here: If the line is indented 4 spaces; and we have a
+                # closing paren, without the opening paren, followed by an opening brace
+                # or colon (for initializer lists) we assume that it is the last line of
+                # a function header.  If we have a colon indented 4 spaces, it is an
+                # initializer list.
+                exception = (match(r' {4}\w[^\(]*\)\s*(const\s*)?(\{\s*$|:)',
+                                   previous_line)
+                             or match(r' {4}:', previous_line))
+
+            if not exception:
+                error(line_number, 'whitespace/blank_line', 2,
+                      'Blank line at the start of a code block.  Is this needed?')
+        # This doesn't ignore whitespace at the end of a namespace block
+        # because that is too hard without pairing open/close braces;
+        # however, a special exception is made for namespace closing
+        # brackets which have a comment containing "namespace".
+        #
+        # Also, ignore blank lines at the end of a block in a long if-else
+        # chain, like this:
+        #   if (condition1) {
+        #     // Something followed by a blank line
+        #
+        #   } else if (condition2) {
+        #     // Something else
+        #   }
+        if line_number + 1 < clean_lines.num_lines():
+            next_line = raw[line_number + 1]
+            if (next_line
+                and match(r'\s*}', next_line)
+                and next_line.find('namespace') == -1
+                and next_line.find('} else ') == -1):
+                error(line_number, 'whitespace/blank_line', 3,
+                      'Blank line at the end of a code block.  Is this needed?')
+
+    # Next, we complain if there's a comment too near the text
+    comment_position = line.find('//')
+    if comment_position != -1:
+        # Check if the // may be in quotes.  If so, ignore it
+        # Comparisons made explicit for clarity -- pylint: disable-msg=C6403
+        if (line.count('"', 0, comment_position) - line.count('\\"', 0, comment_position)) % 2 == 0:   # not in quotes
+            # Allow one space before end of line comment.
+            if (not match(r'^\s*$', line[:comment_position])
+                and (comment_position >= 1
+                and ((line[comment_position - 1] not in string.whitespace)
+                     or (comment_position >= 2
+                         and line[comment_position - 2] in string.whitespace)))):
+                error(line_number, 'whitespace/comments', 5,
+                      'One space before end of line comments')
+            # There should always be a space between the // and the comment
+            commentend = comment_position + 2
+            if commentend < len(line) and not line[commentend] == ' ':
+                # but some lines are exceptions -- e.g. if they're big
+                # comment delimiters like:
+                # //----------------------------------------------------------
+                # or they begin with multiple slashes followed by a space:
+                # //////// Header comment
+                matched = (search(r'[=/-]{4,}\s*$', line[commentend:])
+                           or search(r'^/+ ', line[commentend:]))
+                if not matched:
+                    error(line_number, 'whitespace/comments', 4,
+                          'Should have a space between // and comment')
+
+    line = clean_lines.elided[line_number]  # get rid of comments and strings
+
+    # Don't try to do spacing checks for operator methods
+    line = sub(r'operator(==|!=|<|<<|<=|>=|>>|>)\(', 'operator\(', line)
+    # Don't try to do spacing checks for #include or #import statements at
+    # minimum because it messes up checks for spacing around /
+    if match(r'\s*#\s*(?:include|import)', line):
+        return
+    if search(r'[\w.]=[\w.]', line):
+        error(line_number, 'whitespace/operators', 4,
+              'Missing spaces around =')
+
+    # FIXME: It's not ok to have spaces around binary operators like .
+
+    # You should always have whitespace around binary operators.
+    # Alas, we can't test < or > because they're legitimately used sans spaces
+    # (a->b, vector<int> a).  The only time we can tell is a < with no >, and
+    # only if it's not template params list spilling into the next line.
+    matched = search(r'[^<>=!\s](==|!=|\+=|-=|\*=|/=|/|\|=|&=|<<=|>>=|<=|>=|\|\||\||&&|>>|<<)[^<>=!\s]', line)
+    if not matched:
+        # Note that while it seems that the '<[^<]*' term in the following
+        # regexp could be simplified to '<.*', which would indeed match
+        # the same class of strings, the [^<] means that searching for the
+        # regexp takes linear rather than quadratic time.
+        if not search(r'<[^<]*,\s*$', line):  # template params spill
+            matched = search(r'[^<>=!\s](<)[^<>=!\s]([^>]|->)*$', line)
+    if matched:
+        error(line_number, 'whitespace/operators', 3,
+              'Missing spaces around %s' % matched.group(1))
+
+    # There shouldn't be space around unary operators
+    matched = search(r'(!\s|~\s|[\s]--[\s;]|[\s]\+\+[\s;])', line)
+    if matched:
+        error(line_number, 'whitespace/operators', 4,
+              'Extra space for operator %s' % matched.group(1))
+
+    # A pet peeve of mine: no spaces after an if, while, switch, or for
+    matched = search(r' (if\(|for\(|foreach\(|while\(|switch\()', line)
+    if matched:
+        error(line_number, 'whitespace/parens', 5,
+              'Missing space before ( in %s' % matched.group(1))
+
+    # For if/for/foreach/while/switch, the left and right parens should be
+    # consistent about how many spaces are inside the parens, and
+    # there should either be zero or one spaces inside the parens.
+    # We don't want: "if ( foo)" or "if ( foo   )".
+    # Exception: "for ( ; foo; bar)" and "for (foo; bar; )" are allowed.
+    matched = search(r'\b(?P<statement>if|for|foreach|while|switch)\s*\((?P<reminder>.*)$', line)
+    if matched:
+        statement = matched.group('statement')
+        condition, rest = up_to_unmatched_closing_paren(matched.group('reminder'))
+        if condition is not None:
+            condition_match = search(r'(?P<leading>[ ]*)(?P<separator>.).*[^ ]+(?P<trailing>[ ]*)', condition)
+            if condition_match:
+                n_leading = len(condition_match.group('leading'))
+                n_trailing = len(condition_match.group('trailing'))
+                if n_leading != n_trailing:
+                    for_exception = statement == 'for' and (
+                        (condition.startswith(' ;') and n_trailing == 0) or
+                        (condition.endswith('; ')   and n_leading == 0))
+                    if not for_exception:
+                        error(line_number, 'whitespace/parens', 5,
+                              'Mismatching spaces inside () in %s' % statement)
+                if n_leading > 1:
+                    error(line_number, 'whitespace/parens', 5,
+                          'Should have zero or one spaces inside ( and ) in %s' %
+                          statement)
+
+            # Do not check for more than one command in macros
+            in_macro = match(r'\s*#define', line)
+            if not in_macro and not match(r'((\s*{\s*}?)|(\s*;?))\s*\\?$', rest):
+                error(line_number, 'whitespace/parens', 4,
+                      'More than one command on the same line in %s' % statement)
+
+    # You should always have a space after a comma (either as fn arg or operator)
+    if search(r',[^\s]', line):
+        error(line_number, 'whitespace/comma', 3,
+              'Missing space after ,')
+
+    if file_extension == 'cpp':
+        # C++ should have the & or * beside the type not the variable name.
+        matched = match(r'\s*\w+(?<!\breturn)\s+(?P<pointer_operator>\*|\&)\w+', line)
+        if matched:
+            error(line_number, 'whitespace/declaration', 3,
+                  'Declaration has space between type name and %s in %s' % (matched.group('pointer_operator'), matched.group(0).strip()))
+
+    elif file_extension == 'c':
+        # C Pointer declaration should have the * beside the variable not the type name.
+        matched = search(r'^\s*\w+\*\s+\w+', line)
+        if matched:
+            error(line_number, 'whitespace/declaration', 3,
+                  'Declaration has space between * and variable name in %s' % matched.group(0).strip())
+
+    # Next we will look for issues with function calls.
+    check_spacing_for_function_call(line, line_number, error)
+
+    # Except after an opening paren, you should have spaces before your braces.
+    # And since you should never have braces at the beginning of a line, this is
+    # an easy test.
+    if search(r'[^ ({]{', line):
+        error(line_number, 'whitespace/braces', 5,
+              'Missing space before {')
+
+    # Make sure '} else {' has spaces.
+    if search(r'}else', line):
+        error(line_number, 'whitespace/braces', 5,
+              'Missing space before else')
+
+    # You shouldn't have spaces before your brackets, except maybe after
+    # 'delete []' or 'new char * []'.
+    if search(r'\w\s+\[', line) and not search(r'delete\s+\[', line):
+        error(line_number, 'whitespace/braces', 5,
+              'Extra space before [')
+
+    # You shouldn't have a space before a semicolon at the end of the line.
+    # There's a special case for "for" since the style guide allows space before
+    # the semicolon there.
+    if search(r':\s*;\s*$', line):
+        error(line_number, 'whitespace/semicolon', 5,
+              'Semicolon defining empty statement. Use { } instead.')
+    elif search(r'^\s*;\s*$', line):
+        error(line_number, 'whitespace/semicolon', 5,
+              'Line contains only semicolon. If this should be an empty statement, '
+              'use { } instead.')
+    elif (search(r'\s+;\s*$', line) and not search(r'\bfor\b', line)):
+        error(line_number, 'whitespace/semicolon', 5,
+              'Extra space before last semicolon. If this should be an empty '
+              'statement, use { } instead.')
+    elif (search(r'\b(for|while)\s*\(.*\)\s*;\s*$', line)
+          and line.count('(') == line.count(')')
+          # Allow do {} while();
+          and not search(r'}\s*while', line)):
+        error(line_number, 'whitespace/semicolon', 5,
+              'Semicolon defining empty statement for this loop. Use { } instead.')
+
+
+def get_previous_non_blank_line(clean_lines, line_number):
+    """Return the most recent non-blank line and its line number.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file contents.
+      line_number: The number of the line to check.
+
+    Returns:
+      A tuple with two elements.  The first element is the contents of the last
+      non-blank line before the current line, or the empty string if this is the
+      first non-blank line.  The second is the line number of that line, or -1
+      if this is the first non-blank line.
+    """
+
+    previous_line_number = line_number - 1
+    while previous_line_number >= 0:
+        previous_line = clean_lines.elided[previous_line_number]
+        if not is_blank_line(previous_line):     # if not a blank line...
+            return (previous_line, previous_line_number)
+        previous_line_number -= 1
+    return ('', -1)
+
+
+def check_namespace_indentation(clean_lines, line_number, file_extension, file_state, error):
+    """Looks for indentation errors inside of namespaces.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      file_extension: The extension (dot not included) of the file.
+      file_state: A _FileState instance which maintains information about
+                  the state of things in the file.
+      error: The function to call with any errors found.
+    """
+
+    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+
+    namespace_match = match(r'(?P<namespace_indentation>\s*)namespace\s+\S+\s*{\s*$', line)
+    if not namespace_match:
+        return
+
+    current_indentation_level = len(namespace_match.group('namespace_indentation'))
+    if current_indentation_level > 0:
+        # Don't warn about an indented namespace if we already warned about indented code.
+        if not file_state.did_inside_namespace_indent_warning():
+            error(line_number, 'whitespace/indent', 4,
+                  'namespace should never be indented.')
+        return
+    looking_for_semicolon = False;
+    line_offset = 0
+    in_preprocessor_directive = False;
+    for current_line in clean_lines.elided[line_number + 1:]:
+        line_offset += 1
+        if not current_line.strip():
+            continue
+        if not current_indentation_level:
+            if not (in_preprocessor_directive or looking_for_semicolon):
+                if not match(r'\S', current_line) and not file_state.did_inside_namespace_indent_warning():
+                    file_state.set_did_inside_namespace_indent_warning()
+                    error(line_number + line_offset, 'whitespace/indent', 4,
+                          'Code inside a namespace should not be indented.')
+            if in_preprocessor_directive or (current_line.strip()[0] == '#'): # This takes care of preprocessor directive syntax.
+                in_preprocessor_directive = current_line[-1] == '\\'
+            else:
+                looking_for_semicolon = ((current_line.find(';') == -1) and (current_line.strip()[-1] != '}')) or (current_line[-1] == '\\')
+        else:
+            looking_for_semicolon = False; # If we have a brace we may not need a semicolon.
+        current_indentation_level += current_line.count('{') - current_line.count('}')
+        if current_indentation_level < 0:
+            break;
+
+def check_using_std(file_extension, clean_lines, line_number, error):
+    """Looks for 'using std::foo;' statements which should be replaced with 'using namespace std;'.
+
+    Args:
+      file_extension: The extension of the current file, without the leading dot.
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    # This check doesn't apply to C or Objective-C implementation files.
+    if is_c_or_objective_c(file_extension):
+        return
+
+    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+
+    using_std_match = match(r'\s*using\s+std::(?P<method_name>\S+)\s*;\s*$', line)
+    if not using_std_match:
+        return
+
+    method_name = using_std_match.group('method_name')
+    error(line_number, 'build/using_std', 4,
+          "Use 'using namespace std;' instead of 'using std::%s;'." % method_name)
+
+
+def check_max_min_macros(file_extension, clean_lines, line_number, error):
+    """Looks use of MAX() and MIN() macros that should be replaced with std::max() and std::min().
+
+    Args:
+      file_extension: The extension of the current file, without the leading dot.
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    # This check doesn't apply to C or Objective-C implementation files.
+    if is_c_or_objective_c(file_extension):
+        return
+
+    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+
+    max_min_macros_search = search(r'\b(?P<max_min_macro>(MAX|MIN))\s*\(', line)
+    if not max_min_macros_search:
+        return
+
+    max_min_macro = max_min_macros_search.group('max_min_macro')
+    max_min_macro_lower = max_min_macro.lower()
+    error(line_number, 'runtime/max_min_macros', 4,
+          'Use std::%s() or std::%s<type>() instead of the %s() macro.'
+          % (max_min_macro_lower, max_min_macro_lower, max_min_macro))
+
+
+def check_switch_indentation(clean_lines, line_number, error):
+    """Looks for indentation errors inside of switch statements.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+
+    switch_match = match(r'(?P<switch_indentation>\s*)switch\s*\(.+\)\s*{\s*$', line)
+    if not switch_match:
+        return
+
+    switch_indentation = switch_match.group('switch_indentation')
+    inner_indentation = switch_indentation + ' ' * 4
+    line_offset = 0
+    encountered_nested_switch = False
+
+    for current_line in clean_lines.elided[line_number + 1:]:
+        line_offset += 1
+
+        # Skip not only empty lines but also those with preprocessor directives.
+        if current_line.strip() == '' or current_line.startswith('#'):
+            continue
+
+        if match(r'\s*switch\s*\(.+\)\s*{\s*$', current_line):
+            # Complexity alarm - another switch statement nested inside the one
+            # that we're currently testing. We'll need to track the extent of
+            # that inner switch if the upcoming label tests are still supposed
+            # to work correctly. Let's not do that; instead, we'll finish
+            # checking this line, and then leave it like that. Assuming the
+            # indentation is done consistently (even if incorrectly), this will
+            # still catch all indentation issues in practice.
+            encountered_nested_switch = True
+
+        current_indentation_match = match(r'(?P<indentation>\s*)(?P<remaining_line>.*)$', current_line);
+        current_indentation = current_indentation_match.group('indentation')
+        remaining_line = current_indentation_match.group('remaining_line')
+
+        # End the check at the end of the switch statement.
+        if remaining_line.startswith('}') and current_indentation == switch_indentation:
+            break
+        # Case and default branches should not be indented. The regexp also
+        # catches single-line cases like "default: break;" but does not trigger
+        # on stuff like "Document::Foo();".
+        elif match(r'(default|case\s+.*)\s*:([^:].*)?$', remaining_line):
+            if current_indentation != switch_indentation:
+                error(line_number + line_offset, 'whitespace/indent', 4,
+                      'A case label should not be indented, but line up with its switch statement.')
+                # Don't throw an error for multiple badly indented labels,
+                # one should be enough to figure out the problem.
+                break
+        # We ignore goto labels at the very beginning of a line.
+        elif match(r'\w+\s*:\s*$', remaining_line):
+            continue
+        # It's not a goto label, so check if it's indented at least as far as
+        # the switch statement plus one more level of indentation.
+        elif not current_indentation.startswith(inner_indentation):
+            error(line_number + line_offset, 'whitespace/indent', 4,
+                  'Non-label code inside switch statements should be indented.')
+            # Don't throw an error for multiple badly indented statements,
+            # one should be enough to figure out the problem.
+            break
+
+        if encountered_nested_switch:
+            break
+
+
+def check_braces(clean_lines, line_number, error):
+    """Looks for misplaced braces (e.g. at the end of line).
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+
+    if match(r'\s*{\s*$', line):
+        # We allow an open brace to start a line in the case where someone
+        # is using braces for function definition or in a block to
+        # explicitly create a new scope, which is commonly used to control
+        # the lifetime of stack-allocated variables.  We don't detect this
+        # perfectly: we just don't complain if the last non-whitespace
+        # character on the previous non-blank line is ';', ':', '{', '}',
+        # ')', or ') const' and doesn't begin with 'if|for|while|switch|else'.
+        # We also allow '#' for #endif and '=' for array initialization.
+        previous_line = get_previous_non_blank_line(clean_lines, line_number)[0]
+        if ((not search(r'[;:}{)=]\s*$|\)\s*const\s*$', previous_line)
+             or search(r'\b(if|for|foreach|while|switch|else)\b', previous_line))
+            and previous_line.find('#') < 0):
+            error(line_number, 'whitespace/braces', 4,
+                  'This { should be at the end of the previous line')
+    elif (search(r'\)\s*(const\s*)?{\s*$', line)
+          and line.count('(') == line.count(')')
+          and not search(r'\b(if|for|foreach|while|switch)\b', line)
+          and not match(r'\s+[A-Z_][A-Z_0-9]+\b', line)):
+        error(line_number, 'whitespace/braces', 4,
+              'Place brace on its own line for function definitions.')
+
+    if (match(r'\s*}\s*(else\s*({\s*)?)?$', line) and line_number > 1):
+        # We check if a closed brace has started a line to see if a
+        # one line control statement was previous.
+        previous_line = clean_lines.elided[line_number - 2]
+        if (previous_line.find('{') > 0
+            and search(r'\b(if|for|foreach|while|else)\b', previous_line)):
+            error(line_number, 'whitespace/braces', 4,
+                  'One line control clauses should not use braces.')
+
+    # An else clause should be on the same line as the preceding closing brace.
+    if match(r'\s*else\s*', line):
+        previous_line = get_previous_non_blank_line(clean_lines, line_number)[0]
+        if match(r'\s*}\s*$', previous_line):
+            error(line_number, 'whitespace/newline', 4,
+                  'An else should appear on the same line as the preceding }')
+
+    # Likewise, an else should never have the else clause on the same line
+    if search(r'\belse [^\s{]', line) and not search(r'\belse if\b', line):
+        error(line_number, 'whitespace/newline', 4,
+              'Else clause should never be on same line as else (use 2 lines)')
+
+    # In the same way, a do/while should never be on one line
+    if match(r'\s*do [^\s{]', line):
+        error(line_number, 'whitespace/newline', 4,
+              'do/while clauses should not be on a single line')
+
+    # Braces shouldn't be followed by a ; unless they're defining a struct
+    # or initializing an array.
+    # We can't tell in general, but we can for some common cases.
+    previous_line_number = line_number
+    while True:
+        (previous_line, previous_line_number) = get_previous_non_blank_line(clean_lines, previous_line_number)
+        if match(r'\s+{.*}\s*;', line) and not previous_line.count(';'):
+            line = previous_line + line
+        else:
+            break
+    if (search(r'{.*}\s*;', line)
+        and line.count('{') == line.count('}')
+        and not search(r'struct|class|enum|\s*=\s*{', line)):
+        error(line_number, 'readability/braces', 4,
+              "You don't need a ; after a }")
+
+
+def check_exit_statement_simplifications(clean_lines, line_number, error):
+    """Looks for else or else-if statements that should be written as an
+    if statement when the prior if concludes with a return, break, continue or
+    goto statement.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    line = clean_lines.elided[line_number] # Get rid of comments and strings.
+
+    else_match = match(r'(?P<else_indentation>\s*)(\}\s*)?else(\s+if\s*\(|(?P<else>\s*(\{\s*)?\Z))', line)
+    if not else_match:
+        return
+
+    else_indentation = else_match.group('else_indentation')
+    inner_indentation = else_indentation + ' ' * 4
+
+    previous_lines = clean_lines.elided[:line_number]
+    previous_lines.reverse()
+    line_offset = 0
+    encountered_exit_statement = False
+
+    for current_line in previous_lines:
+        line_offset -= 1
+
+        # Skip not only empty lines but also those with preprocessor directives
+        # and goto labels.
+        if current_line.strip() == '' or current_line.startswith('#') or match(r'\w+\s*:\s*$', current_line):
+            continue
+
+        # Skip lines with closing braces on the original indentation level.
+        # Even though the styleguide says they should be on the same line as
+        # the "else if" statement, we also want to check for instances where
+        # the current code does not comply with the coding style. Thus, ignore
+        # these lines and proceed to the line before that.
+        if current_line == else_indentation + '}':
+            continue
+
+        current_indentation_match = match(r'(?P<indentation>\s*)(?P<remaining_line>.*)$', current_line);
+        current_indentation = current_indentation_match.group('indentation')
+        remaining_line = current_indentation_match.group('remaining_line')
+
+        # As we're going up the lines, the first real statement to encounter
+        # has to be an exit statement (return, break, continue or goto) -
+        # otherwise, this check doesn't apply.
+        if not encountered_exit_statement:
+            # We only want to find exit statements if they are on exactly
+            # the same level of indentation as expected from the code inside
+            # the block. If the indentation doesn't strictly match then we
+            # might have a nested if or something, which must be ignored.
+            if current_indentation != inner_indentation:
+                break
+            if match(r'(return(\W+.*)|(break|continue)\s*;|goto\s*\w+;)$', remaining_line):
+                encountered_exit_statement = True
+                continue
+            break
+
+        # When code execution reaches this point, we've found an exit statement
+        # as last statement of the previous block. Now we only need to make
+        # sure that the block belongs to an "if", then we can throw an error.
+
+        # Skip lines with opening braces on the original indentation level,
+        # similar to the closing braces check above. ("if (condition)\n{")
+        if current_line == else_indentation + '{':
+            continue
+
+        # Skip everything that's further indented than our "else" or "else if".
+        if current_indentation.startswith(else_indentation) and current_indentation != else_indentation:
+            continue
+
+        # So we've got a line with same (or less) indentation. Is it an "if"?
+        # If yes: throw an error. If no: don't throw an error.
+        # Whatever the outcome, this is the end of our loop.
+        if match(r'if\s*\(', remaining_line):
+            if else_match.start('else') != -1:
+                error(line_number + line_offset, 'readability/control_flow', 4,
+                      'An else statement can be removed when the prior "if" '
+                      'concludes with a return, break, continue or goto statement.')
+            else:
+                error(line_number + line_offset, 'readability/control_flow', 4,
+                      'An else if statement should be written as an if statement '
+                      'when the prior "if" concludes with a return, break, '
+                      'continue or goto statement.')
+        break
+
+
+def replaceable_check(operator, macro, line):
+    """Determine whether a basic CHECK can be replaced with a more specific one.
+
+    For example suggest using CHECK_EQ instead of CHECK(a == b) and
+    similarly for CHECK_GE, CHECK_GT, CHECK_LE, CHECK_LT, CHECK_NE.
+
+    Args:
+      operator: The C++ operator used in the CHECK.
+      macro: The CHECK or EXPECT macro being called.
+      line: The current source line.
+
+    Returns:
+      True if the CHECK can be replaced with a more specific one.
+    """
+
+    # This matches decimal and hex integers, strings, and chars (in that order).
+    match_constant = r'([-+]?(\d+|0[xX][0-9a-fA-F]+)[lLuU]{0,3}|".*"|\'.*\')'
+
+    # Expression to match two sides of the operator with something that
+    # looks like a literal, since CHECK(x == iterator) won't compile.
+    # This means we can't catch all the cases where a more specific
+    # CHECK is possible, but it's less annoying than dealing with
+    # extraneous warnings.
+    match_this = (r'\s*' + macro + r'\((\s*' +
+                  match_constant + r'\s*' + operator + r'[^<>].*|'
+                  r'.*[^<>]' + operator + r'\s*' + match_constant +
+                  r'\s*\))')
+
+    # Don't complain about CHECK(x == NULL) or similar because
+    # CHECK_EQ(x, NULL) won't compile (requires a cast).
+    # Also, don't complain about more complex boolean expressions
+    # involving && or || such as CHECK(a == b || c == d).
+    return match(match_this, line) and not search(r'NULL|&&|\|\|', line)
+
+
+def check_check(clean_lines, line_number, error):
+    """Checks the use of CHECK and EXPECT macros.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      error: The function to call with any errors found.
+    """
+
+    # Decide the set of replacement macros that should be suggested
+    raw_lines = clean_lines.raw_lines
+    current_macro = ''
+    for macro in _CHECK_MACROS:
+        if raw_lines[line_number].find(macro) >= 0:
+            current_macro = macro
+            break
+    if not current_macro:
+        # Don't waste time here if line doesn't contain 'CHECK' or 'EXPECT'
+        return
+
+    line = clean_lines.elided[line_number]        # get rid of comments and strings
+
+    # Encourage replacing plain CHECKs with CHECK_EQ/CHECK_NE/etc.
+    for operator in ['==', '!=', '>=', '>', '<=', '<']:
+        if replaceable_check(operator, current_macro, line):
+            error(line_number, 'readability/check', 2,
+                  'Consider using %s instead of %s(a %s b)' % (
+                      _CHECK_REPLACEMENT[current_macro][operator],
+                      current_macro, operator))
+            break
+
+
+def check_for_comparisons_to_zero(clean_lines, line_number, error):
+    # Get the line without comments and strings.
+    line = clean_lines.elided[line_number]
+
+    # Include NULL here so that users don't have to convert NULL to 0 first and then get this error.
+    if search(r'[=!]=\s*(NULL|0|true|false)\W', line) or search(r'\W(NULL|0|true|false)\s*[=!]=', line):
+        error(line_number, 'readability/comparison_to_zero', 5,
+              'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.')
+
+
+def check_for_null(file_extension, clean_lines, line_number, error):
+    # This check doesn't apply to C or Objective-C implementation files.
+    if is_c_or_objective_c(file_extension):
+        return
+
+    line = clean_lines.elided[line_number]
+
+    # Don't warn about NULL usage in g_object_{get,set}(). See Bug 32858
+    if search(r'\bg_object_[sg]et\b', line):
+        return
+
+    if search(r'\bNULL\b', line):
+        error(line_number, 'readability/null', 5, 'Use 0 instead of NULL.')
+        return
+
+    line = clean_lines.raw_lines[line_number]
+    # See if NULL occurs in any comments in the line. If the search for NULL using the raw line
+    # matches, then do the check with strings collapsed to avoid giving errors for
+    # NULLs occurring in strings.
+    if search(r'\bNULL\b', line) and search(r'\bNULL\b', CleansedLines.collapse_strings(line)):
+        error(line_number, 'readability/null', 4, 'Use 0 instead of NULL.')
+
+def get_line_width(line):
+    """Determines the width of the line in column positions.
+
+    Args:
+      line: A string, which may be a Unicode string.
+
+    Returns:
+      The width of the line in column positions, accounting for Unicode
+      combining characters and wide characters.
+    """
+    if isinstance(line, unicode):
+        width = 0
+        for c in unicodedata.normalize('NFC', line):
+            if unicodedata.east_asian_width(c) in ('W', 'F'):
+                width += 2
+            elif not unicodedata.combining(c):
+                width += 1
+        return width
+    return len(line)
+
+
+def check_style(clean_lines, line_number, file_extension, file_state, error):
+    """Checks rules from the 'C++ style rules' section of cppguide.html.
+
+    Most of these rules are hard to test (naming, comment style), but we
+    do what we can.  In particular we check for 4-space indents, line lengths,
+    tab usage, spaces inside code, etc.
+
+    Args:
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      file_extension: The extension (without the dot) of the filename.
+      file_state: A _FileState instance which maintains information about
+                  the state of things in the file.
+      error: The function to call with any errors found.
+    """
+
+    raw_lines = clean_lines.raw_lines
+    line = raw_lines[line_number]
+
+    if line.find('\t') != -1:
+        error(line_number, 'whitespace/tab', 1,
+              'Tab found; better to use spaces')
+
+    # One or three blank spaces at the beginning of the line is weird; it's
+    # hard to reconcile that with 4-space indents.
+    # NOTE: here are the conditions rob pike used for his tests.  Mine aren't
+    # as sophisticated, but it may be worth becoming so:  RLENGTH==initial_spaces
+    # if(RLENGTH > 20) complain = 0;
+    # if(match($0, " +(error|private|public|protected):")) complain = 0;
+    # if(match(prev, "&& *$")) complain = 0;
+    # if(match(prev, "\\|\\| *$")) complain = 0;
+    # if(match(prev, "[\",=><] *$")) complain = 0;
+    # if(match($0, " <<")) complain = 0;
+    # if(match(prev, " +for \\(")) complain = 0;
+    # if(prevodd && match(prevprev, " +for \\(")) complain = 0;
+    initial_spaces = 0
+    cleansed_line = clean_lines.elided[line_number]
+    while initial_spaces < len(line) and line[initial_spaces] == ' ':
+        initial_spaces += 1
+    if line and line[-1].isspace():
+        error(line_number, 'whitespace/end_of_line', 4,
+              'Line ends in whitespace.  Consider deleting these extra spaces.')
+    # There are certain situations we allow one space, notably for labels
+    elif ((initial_spaces >= 1 and initial_spaces <= 3)
+          and not match(r'\s*\w+\s*:\s*$', cleansed_line)):
+        error(line_number, 'whitespace/indent', 3,
+              'Weird number of spaces at line-start.  '
+              'Are you using a 4-space indent?')
+    # Labels should always be indented at least one space.
+    elif not initial_spaces and line[:2] != '//':
+        label_match = match(r'(?P<label>[^:]+):\s*$', line)
+
+        if label_match:
+            label = label_match.group('label')
+            # Only throw errors for stuff that is definitely not a goto label,
+            # because goto labels can in fact occur at the start of the line.
+            if label in ['public', 'private', 'protected'] or label.find(' ') != -1:
+                error(line_number, 'whitespace/labels', 4,
+                      'Labels should always be indented at least one space.  '
+                      'If this is a member-initializer list in a constructor, '
+                      'the colon should be on the line after the definition header.')
+
+    if (cleansed_line.count(';') > 1
+        # for loops are allowed two ;'s (and may run over two lines).
+        and cleansed_line.find('for') == -1
+        and (get_previous_non_blank_line(clean_lines, line_number)[0].find('for') == -1
+             or get_previous_non_blank_line(clean_lines, line_number)[0].find(';') != -1)
+        # It's ok to have many commands in a switch case that fits in 1 line
+        and not ((cleansed_line.find('case ') != -1
+                  or cleansed_line.find('default:') != -1)
+                 and cleansed_line.find('break;') != -1)
+        and not cleansed_line.startswith('#define ')):
+        error(line_number, 'whitespace/newline', 4,
+              'More than one command on the same line')
+
+    if cleansed_line.strip().endswith('||') or cleansed_line.strip().endswith('&&'):
+        error(line_number, 'whitespace/operators', 4,
+              'Boolean expressions that span multiple lines should have their '
+              'operators on the left side of the line instead of the right side.')
+
+    # Some more style checks
+    check_namespace_indentation(clean_lines, line_number, file_extension, file_state, error)
+    check_using_std(file_extension, clean_lines, line_number, error)
+    check_max_min_macros(file_extension, clean_lines, line_number, error)
+    check_switch_indentation(clean_lines, line_number, error)
+    check_braces(clean_lines, line_number, error)
+    check_exit_statement_simplifications(clean_lines, line_number, error)
+    check_spacing(file_extension, clean_lines, line_number, error)
+    check_check(clean_lines, line_number, error)
+    check_for_comparisons_to_zero(clean_lines, line_number, error)
+    check_for_null(file_extension, clean_lines, line_number, error)
+
+
+_RE_PATTERN_INCLUDE_NEW_STYLE = re.compile(r'#include +"[^/]+\.h"')
+_RE_PATTERN_INCLUDE = re.compile(r'^\s*#\s*include\s*([<"])([^>"]*)[>"].*$')
+# Matches the first component of a filename delimited by -s and _s. That is:
+#  _RE_FIRST_COMPONENT.match('foo').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo.cpp').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo-bar_baz.cpp').group(0) == 'foo'
+#  _RE_FIRST_COMPONENT.match('foo_bar-baz.cpp').group(0) == 'foo'
+_RE_FIRST_COMPONENT = re.compile(r'^[^-_.]+')
+
+
+def _drop_common_suffixes(filename):
+    """Drops common suffixes like _test.cpp or -inl.h from filename.
+
+    For example:
+      >>> _drop_common_suffixes('foo/foo-inl.h')
+      'foo/foo'
+      >>> _drop_common_suffixes('foo/bar/foo.cpp')
+      'foo/bar/foo'
+      >>> _drop_common_suffixes('foo/foo_internal.h')
+      'foo/foo'
+      >>> _drop_common_suffixes('foo/foo_unusualinternal.h')
+      'foo/foo_unusualinternal'
+
+    Args:
+      filename: The input filename.
+
+    Returns:
+      The filename with the common suffix removed.
+    """
+    for suffix in ('test.cpp', 'regtest.cpp', 'unittest.cpp',
+                   'inl.h', 'impl.h', 'internal.h'):
+        if (filename.endswith(suffix) and len(filename) > len(suffix)
+            and filename[-len(suffix) - 1] in ('-', '_')):
+            return filename[:-len(suffix) - 1]
+    return os.path.splitext(filename)[0]
+
+
+def _is_test_filename(filename):
+    """Determines if the given filename has a suffix that identifies it as a test.
+
+    Args:
+      filename: The input filename.
+
+    Returns:
+      True if 'filename' looks like a test, False otherwise.
+    """
+    if (filename.endswith('_test.cpp')
+        or filename.endswith('_unittest.cpp')
+        or filename.endswith('_regtest.cpp')):
+        return True
+    return False
+
+
+def _classify_include(filename, include, is_system, include_state):
+    """Figures out what kind of header 'include' is.
+
+    Args:
+      filename: The current file cpp_style is running over.
+      include: The path to a #included file.
+      is_system: True if the #include used <> rather than "".
+      include_state: An _IncludeState instance in which the headers are inserted.
+
+    Returns:
+      One of the _XXX_HEADER constants.
+
+    For example:
+      >>> _classify_include('foo.cpp', 'config.h', False)
+      _CONFIG_HEADER
+      >>> _classify_include('foo.cpp', 'foo.h', False)
+      _PRIMARY_HEADER
+      >>> _classify_include('foo.cpp', 'bar.h', False)
+      _OTHER_HEADER
+    """
+
+    # If it is a system header we know it is classified as _OTHER_HEADER.
+    if is_system:
+        return _OTHER_HEADER
+
+    # If the include is named config.h then this is WebCore/config.h.
+    if include == "config.h":
+        return _CONFIG_HEADER
+
+    # There cannot be primary includes in header files themselves. Only an
+    # include exactly matches the header filename will be is flagged as
+    # primary, so that it triggers the "don't include yourself" check.
+    if filename.endswith('.h') and filename != include:
+        return _OTHER_HEADER;
+
+    # Qt's moc files do not follow the naming and ordering rules, so they should be skipped
+    if include.startswith('moc_') and include.endswith('.cpp'):
+        return _MOC_HEADER
+
+    if include.endswith('.moc'):
+        return _MOC_HEADER
+
+    # If the target file basename starts with the include we're checking
+    # then we consider it the primary header.
+    target_base = FileInfo(filename).base_name()
+    include_base = FileInfo(include).base_name()
+
+    # If we haven't encountered a primary header, then be lenient in checking.
+    if not include_state.visited_primary_section() and target_base.find(include_base) != -1:
+        return _PRIMARY_HEADER
+    # If we already encountered a primary header, perform a strict comparison.
+    # In case the two filename bases are the same then the above lenient check
+    # probably was a false positive.
+    elif include_state.visited_primary_section() and target_base == include_base:
+        if include == "ResourceHandleWin.h":
+            # FIXME: Thus far, we've only seen one example of these, but if we
+            # start to see more, please consider generalizing this check
+            # somehow.
+            return _OTHER_HEADER
+        return _PRIMARY_HEADER
+
+    return _OTHER_HEADER
+
+
+
+def check_include_line(filename, file_extension, clean_lines, line_number, include_state, error):
+    """Check rules that are applicable to #include lines.
+
+    Strings on #include lines are NOT removed from elided line, to make
+    certain tasks easier. However, to prevent false positives, checks
+    applicable to #include lines in CheckLanguage must be put here.
+
+    Args:
+      filename: The name of the current file.
+      file_extension: The current file extension, without the leading dot.
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      include_state: An _IncludeState instance in which the headers are inserted.
+      error: The function to call with any errors found.
+    """
+
+    if (filename.find('WebKitTools/WebKitAPITest/') >= 0
+        or filename.find('WebKit/qt/QGVLauncher/') >= 0):
+        # Files in this directory are consumers of the WebKit API and
+        # therefore do not follow the same header including discipline as
+        # WebCore.
+        return
+
+    line = clean_lines.lines[line_number]
+
+    matched = _RE_PATTERN_INCLUDE.search(line)
+    if not matched:
+        return
+
+    include = matched.group(2)
+    is_system = (matched.group(1) == '<')
+
+    # Look for any of the stream classes that are part of standard C++.
+    if match(r'(f|ind|io|i|o|parse|pf|stdio|str|)?stream$', include):
+        # Many unit tests use cout, so we exempt them.
+        if not _is_test_filename(filename):
+            error(line_number, 'readability/streams', 3,
+                  'Streams are highly discouraged.')
+
+    # Look for specific includes to fix.
+    if include.startswith('wtf/') and not is_system:
+        error(line_number, 'build/include', 4,
+              'wtf includes should be <wtf/file.h> instead of "wtf/file.h".')
+
+    duplicate_header = include in include_state
+    if duplicate_header:
+        error(line_number, 'build/include', 4,
+              '"%s" already included at %s:%s' %
+              (include, filename, include_state[include]))
+    else:
+        include_state[include] = line_number
+
+    header_type = _classify_include(filename, include, is_system, include_state)
+    include_state.header_types[line_number] = header_type
+
+    # Only proceed if this isn't a duplicate header.
+    if duplicate_header:
+        return
+
+    # We want to ensure that headers appear in the right order:
+    # 1) for implementation files: config.h, primary header, blank line, alphabetically sorted
+    # 2) for header files: alphabetically sorted
+    # The include_state object keeps track of the last type seen
+    # and complains if the header types are out of order or missing.
+    error_message = include_state.check_next_include_order(header_type, file_extension == "h")
+
+    # Check to make sure we have a blank line after primary header.
+    if not error_message and header_type == _PRIMARY_HEADER:
+         next_line = clean_lines.raw_lines[line_number + 1]
+         if not is_blank_line(next_line):
+            error(line_number, 'build/include_order', 4,
+                  'You should add a blank line after implementation file\'s own header.')
+
+    # Check to make sure all headers besides config.h and the primary header are
+    # alphabetically sorted. Skip Qt's moc files.
+    if not error_message and header_type == _OTHER_HEADER:
+         previous_line_number = line_number - 1;
+         previous_line = clean_lines.lines[previous_line_number]
+         previous_match = _RE_PATTERN_INCLUDE.search(previous_line)
+         while (not previous_match and previous_line_number > 0
+                and not search(r'\A(#if|#ifdef|#ifndef|#else|#elif|#endif)', previous_line)):
+            previous_line_number -= 1;
+            previous_line = clean_lines.lines[previous_line_number]
+            previous_match = _RE_PATTERN_INCLUDE.search(previous_line)
+         if previous_match:
+            previous_header_type = include_state.header_types[previous_line_number]
+            if previous_header_type == _OTHER_HEADER and previous_line.strip() > line.strip():
+                error(line_number, 'build/include_order', 4,
+                      'Alphabetical sorting problem.')
+
+    if error_message:
+        if file_extension == 'h':
+            error(line_number, 'build/include_order', 4,
+                  '%s Should be: alphabetically sorted.' %
+                  error_message)
+        else:
+            error(line_number, 'build/include_order', 4,
+                  '%s Should be: config.h, primary header, blank line, and then alphabetically sorted.' %
+                  error_message)
+
+
+def check_language(filename, clean_lines, line_number, file_extension, include_state,
+                   error):
+    """Checks rules from the 'C++ language rules' section of cppguide.html.
+
+    Some of these rules are hard to test (function overloading, using
+    uint32 inappropriately), but we do the best we can.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      line_number: The number of the line to check.
+      file_extension: The extension (without the dot) of the filename.
+      include_state: An _IncludeState instance in which the headers are inserted.
+      error: The function to call with any errors found.
+    """
+    # If the line is empty or consists of entirely a comment, no need to
+    # check it.
+    line = clean_lines.elided[line_number]
+    if not line:
+        return
+
+    matched = _RE_PATTERN_INCLUDE.search(line)
+    if matched:
+        check_include_line(filename, file_extension, clean_lines, line_number, include_state, error)
+        return
+
+    # FIXME: figure out if they're using default arguments in fn proto.
+
+    # Check to see if they're using an conversion function cast.
+    # I just try to capture the most common basic types, though there are more.
+    # Parameterless conversion functions, such as bool(), are allowed as they are
+    # probably a member operator declaration or default constructor.
+    matched = search(
+        r'\b(int|float|double|bool|char|int32|uint32|int64|uint64)\([^)]', line)
+    if matched:
+        # gMock methods are defined using some variant of MOCK_METHODx(name, type)
+        # where type may be float(), int(string), etc.  Without context they are
+        # virtually indistinguishable from int(x) casts.
+        if not match(r'^\s*MOCK_(CONST_)?METHOD\d+(_T)?\(', line):
+            error(line_number, 'readability/casting', 4,
+                  'Using deprecated casting style.  '
+                  'Use static_cast<%s>(...) instead' %
+                  matched.group(1))
+
+    check_c_style_cast(line_number, line, clean_lines.raw_lines[line_number],
+                       'static_cast',
+                       r'\((int|float|double|bool|char|u?int(16|32|64))\)',
+                       error)
+    # This doesn't catch all cases.  Consider (const char * const)"hello".
+    check_c_style_cast(line_number, line, clean_lines.raw_lines[line_number],
+                       'reinterpret_cast', r'\((\w+\s?\*+\s?)\)', error)
+
+    # In addition, we look for people taking the address of a cast.  This
+    # is dangerous -- casts can assign to temporaries, so the pointer doesn't
+    # point where you think.
+    if search(
+        r'(&\([^)]+\)[\w(])|(&(static|dynamic|reinterpret)_cast\b)', line):
+        error(line_number, 'runtime/casting', 4,
+              ('Are you taking an address of a cast?  '
+               'This is dangerous: could be a temp var.  '
+               'Take the address before doing the cast, rather than after'))
+
+    # Check for people declaring static/global STL strings at the top level.
+    # This is dangerous because the C++ language does not guarantee that
+    # globals with constructors are initialized before the first access.
+    matched = match(
+        r'((?:|static +)(?:|const +))string +([a-zA-Z0-9_:]+)\b(.*)',
+        line)
+    # Make sure it's not a function.
+    # Function template specialization looks like: "string foo<Type>(...".
+    # Class template definitions look like: "string Foo<Type>::Method(...".
+    if matched and not match(r'\s*(<.*>)?(::[a-zA-Z0-9_]+)?\s*\(([^"]|$)',
+                             matched.group(3)):
+        error(line_number, 'runtime/string', 4,
+              'For a static/global string constant, use a C style string instead: '
+              '"%schar %s[]".' %
+              (matched.group(1), matched.group(2)))
+
+    # Check that we're not using RTTI outside of testing code.
+    if search(r'\bdynamic_cast<', line) and not _is_test_filename(filename):
+        error(line_number, 'runtime/rtti', 5,
+              'Do not use dynamic_cast<>.  If you need to cast within a class '
+              "hierarchy, use static_cast<> to upcast.  Google doesn't support "
+              'RTTI.')
+
+    if search(r'\b([A-Za-z0-9_]*_)\(\1\)', line):
+        error(line_number, 'runtime/init', 4,
+              'You seem to be initializing a member variable with itself.')
+
+    if file_extension == 'h':
+        # FIXME: check that 1-arg constructors are explicit.
+        #        How to tell it's a constructor?
+        #        (handled in check_for_non_standard_constructs for now)
+        pass
+
+    # Check if people are using the verboten C basic types.  The only exception
+    # we regularly allow is "unsigned short port" for port.
+    if search(r'\bshort port\b', line):
+        if not search(r'\bunsigned short port\b', line):
+            error(line_number, 'runtime/int', 4,
+                  'Use "unsigned short" for ports, not "short"')
+
+    # When snprintf is used, the second argument shouldn't be a literal.
+    matched = search(r'snprintf\s*\(([^,]*),\s*([0-9]*)\s*,', line)
+    if matched:
+        error(line_number, 'runtime/printf', 3,
+              'If you can, use sizeof(%s) instead of %s as the 2nd arg '
+              'to snprintf.' % (matched.group(1), matched.group(2)))
+
+    # Check if some verboten C functions are being used.
+    if search(r'\bsprintf\b', line):
+        error(line_number, 'runtime/printf', 5,
+              'Never use sprintf.  Use snprintf instead.')
+    matched = search(r'\b(strcpy|strcat)\b', line)
+    if matched:
+        error(line_number, 'runtime/printf', 4,
+              'Almost always, snprintf is better than %s' % matched.group(1))
+
+    if search(r'\bsscanf\b', line):
+        error(line_number, 'runtime/printf', 1,
+              'sscanf can be ok, but is slow and can overflow buffers.')
+
+    # Check for suspicious usage of "if" like
+    # } if (a == b) {
+    if search(r'\}\s*if\s*\(', line):
+        error(line_number, 'readability/braces', 4,
+              'Did you mean "else if"? If not, start a new line for "if".')
+
+    # Check for potential format string bugs like printf(foo).
+    # We constrain the pattern not to pick things like DocidForPrintf(foo).
+    # Not perfect but it can catch printf(foo.c_str()) and printf(foo->c_str())
+    matched = re.search(r'\b((?:string)?printf)\s*\(([\w.\->()]+)\)', line, re.I)
+    if matched:
+        error(line_number, 'runtime/printf', 4,
+              'Potential format string bug. Do %s("%%s", %s) instead.'
+              % (matched.group(1), matched.group(2)))
+
+    # Check for potential memset bugs like memset(buf, sizeof(buf), 0).
+    matched = search(r'memset\s*\(([^,]*),\s*([^,]*),\s*0\s*\)', line)
+    if matched and not match(r"^''|-?[0-9]+|0x[0-9A-Fa-f]$", matched.group(2)):
+        error(line_number, 'runtime/memset', 4,
+              'Did you mean "memset(%s, 0, %s)"?'
+              % (matched.group(1), matched.group(2)))
+
+    # Detect variable-length arrays.
+    matched = match(r'\s*(.+::)?(\w+) [a-z]\w*\[(.+)];', line)
+    if (matched and matched.group(2) != 'return' and matched.group(2) != 'delete' and
+        matched.group(3).find(']') == -1):
+        # Split the size using space and arithmetic operators as delimiters.
+        # If any of the resulting tokens are not compile time constants then
+        # report the error.
+        tokens = re.split(r'\s|\+|\-|\*|\/|<<|>>]', matched.group(3))
+        is_const = True
+        skip_next = False
+        for tok in tokens:
+            if skip_next:
+                skip_next = False
+                continue
+
+            if search(r'sizeof\(.+\)', tok):
+                continue
+            if search(r'arraysize\(\w+\)', tok):
+                continue
+
+            tok = tok.lstrip('(')
+            tok = tok.rstrip(')')
+            if not tok:
+                continue
+            if match(r'\d+', tok):
+                continue
+            if match(r'0[xX][0-9a-fA-F]+', tok):
+                continue
+            if match(r'k[A-Z0-9]\w*', tok):
+                continue
+            if match(r'(.+::)?k[A-Z0-9]\w*', tok):
+                continue
+            if match(r'(.+::)?[A-Z][A-Z0-9_]*', tok):
+                continue
+            # A catch all for tricky sizeof cases, including 'sizeof expression',
+            # 'sizeof(*type)', 'sizeof(const type)', 'sizeof(struct StructName)'
+            # requires skipping the next token becasue we split on ' ' and '*'.
+            if tok.startswith('sizeof'):
+                skip_next = True
+                continue
+            is_const = False
+            break
+        if not is_const:
+            error(line_number, 'runtime/arrays', 1,
+                  'Do not use variable-length arrays.  Use an appropriately named '
+                  "('k' followed by CamelCase) compile-time constant for the size.")
+
+    # Check for use of unnamed namespaces in header files.  Registration
+    # macros are typically OK, so we allow use of "namespace {" on lines
+    # that end with backslashes.
+    if (file_extension == 'h'
+        and search(r'\bnamespace\s*{', line)
+        and line[-1] != '\\'):
+        error(line_number, 'build/namespaces', 4,
+              'Do not use unnamed namespaces in header files.  See '
+              'http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'
+              ' for more information.')
+
+    check_identifier_name_in_declaration(filename, line_number, line, error)
+
+
+def check_identifier_name_in_declaration(filename, line_number, line, error):
+    """Checks if identifier names contain any underscores.
+
+    As identifiers in libraries we are using have a bunch of
+    underscores, we only warn about the declarations of identifiers
+    and don't check use of identifiers.
+
+    Args:
+      filename: The name of the current file.
+      line_number: The number of the line to check.
+      line: The line of code to check.
+      error: The function to call with any errors found.
+    """
+    # We don't check a return statement.
+    if match(r'\s*(return|delete)\b', line):
+        return
+
+    # Basically, a declaration is a type name followed by whitespaces
+    # followed by an identifier. The type name can be complicated
+    # due to type adjectives and templates. We remove them first to
+    # simplify the process to find declarations of identifiers.
+
+    # Convert "long long", "long double", and "long long int" to
+    # simple types, but don't remove simple "long".
+    line = sub(r'long (long )?(?=long|double|int)', '', line)
+    line = sub(r'\b(unsigned|signed|inline|using|static|const|volatile|auto|register|extern|typedef|restrict|struct|class|virtual)(?=\W)', '', line)
+
+    # Remove all template parameters by removing matching < and >.
+    # Loop until no templates are removed to remove nested templates.
+    while True:
+        line, number_of_replacements = subn(r'<([\w\s:]|::)+\s*[*&]*\s*>', '', line)
+        if not number_of_replacements:
+            break
+
+    # Declarations of local variables can be in condition expressions
+    # of control flow statements (e.g., "if (RenderObject* p = o->parent())").
+    # We remove the keywords and the first parenthesis.
+    #
+    # Declarations in "while", "if", and "switch" are different from
+    # other declarations in two aspects:
+    #
+    # - There can be only one declaration between the parentheses.
+    #   (i.e., you cannot write "if (int i = 0, j = 1) {}")
+    # - The variable must be initialized.
+    #   (i.e., you cannot write "if (int i) {}")
+    #
+    # and we will need different treatments for them.
+    line = sub(r'^\s*for\s*\(', '', line)
+    line, control_statement = subn(r'^\s*(while|else if|if|switch)\s*\(', '', line)
+
+    # Detect variable and functions.
+    type_regexp = r'\w([\w]|\s*[*&]\s*|::)+'
+    identifier_regexp = r'(?P<identifier>[\w:]+)'
+    character_after_identifier_regexp = r'(?P<character_after_identifier>[[;()=,])(?!=)'
+    declaration_without_type_regexp = r'\s*' + identifier_regexp + r'\s*' + character_after_identifier_regexp
+    declaration_with_type_regexp = r'\s*' + type_regexp + r'\s' + declaration_without_type_regexp
+    is_function_arguments = False
+    number_of_identifiers = 0
+    while True:
+        # If we are seeing the first identifier or arguments of a
+        # function, there should be a type name before an identifier.
+        if not number_of_identifiers or is_function_arguments:
+            declaration_regexp = declaration_with_type_regexp
+        else:
+            declaration_regexp = declaration_without_type_regexp
+
+        matched = match(declaration_regexp, line)
+        if not matched:
+            return
+        identifier = matched.group('identifier')
+        character_after_identifier = matched.group('character_after_identifier')
+
+        # If we removed a non-for-control statement, the character after
+        # the identifier should be '='. With this rule, we can avoid
+        # warning for cases like "if (val & INT_MAX) {".
+        if control_statement and character_after_identifier != '=':
+            return
+
+        is_function_arguments = is_function_arguments or character_after_identifier == '('
+
+        # Remove "m_" and "s_" to allow them.
+        modified_identifier = sub(r'(^|(?<=::))[ms]_', '', identifier)
+        if modified_identifier.find('_') >= 0:
+            # Various exceptions to the rule: JavaScript op codes functions, const_iterator.
+            if (not (filename.find('JavaScriptCore') >= 0 and modified_identifier.find('_op_') >= 0)
+                and not filename.find('WebKit/gtk/webkit/') >= 0
+                and not modified_identifier.startswith('tst_')
+                and not modified_identifier.startswith('webkit_dom_object_')
+                and not modified_identifier.startswith('qt_')
+                and not modified_identifier.find('::qt_') >= 0
+                and not modified_identifier == "const_iterator"):
+                error(line_number, 'readability/naming', 4, identifier + " is incorrectly named. Don't use underscores in your identifier names.")
+
+        # There can be only one declaration in non-for-control statements.
+        if control_statement:
+            return
+        # We should continue checking if this is a function
+        # declaration because we need to check its arguments.
+        # Also, we need to check multiple declarations.
+        if character_after_identifier != '(' and character_after_identifier != ',':
+            return
+
+        number_of_identifiers += 1
+        line = line[matched.end():]
+
+
+def check_c_style_cast(line_number, line, raw_line, cast_type, pattern,
+                       error):
+    """Checks for a C-style cast by looking for the pattern.
+
+    This also handles sizeof(type) warnings, due to similarity of content.
+
+    Args:
+      line_number: The number of the line to check.
+      line: The line of code to check.
+      raw_line: The raw line of code to check, with comments.
+      cast_type: The string for the C++ cast to recommend.  This is either
+                 reinterpret_cast or static_cast, depending.
+      pattern: The regular expression used to find C-style casts.
+      error: The function to call with any errors found.
+    """
+    matched = search(pattern, line)
+    if not matched:
+        return
+
+    # e.g., sizeof(int)
+    sizeof_match = match(r'.*sizeof\s*$', line[0:matched.start(1) - 1])
+    if sizeof_match:
+        error(line_number, 'runtime/sizeof', 1,
+              'Using sizeof(type).  Use sizeof(varname) instead if possible')
+        return
+
+    remainder = line[matched.end(0):]
+
+    # The close paren is for function pointers as arguments to a function.
+    # eg, void foo(void (*bar)(int));
+    # The semicolon check is a more basic function check; also possibly a
+    # function pointer typedef.
+    # eg, void foo(int); or void foo(int) const;
+    # The equals check is for function pointer assignment.
+    # eg, void *(*foo)(int) = ...
+    #
+    # Right now, this will only catch cases where there's a single argument, and
+    # it's unnamed.  It should probably be expanded to check for multiple
+    # arguments with some unnamed.
+    function_match = match(r'\s*(\)|=|(const)?\s*(;|\{|throw\(\)))', remainder)
+    if function_match:
+        if (not function_match.group(3)
+            or function_match.group(3) == ';'
+            or raw_line.find('/*') < 0):
+            error(line_number, 'readability/function', 3,
+                  'All parameters should be named in a function')
+        return
+
+    # At this point, all that should be left is actual casts.
+    error(line_number, 'readability/casting', 4,
+          'Using C-style cast.  Use %s<%s>(...) instead' %
+          (cast_type, matched.group(1)))
+
+
+_HEADERS_CONTAINING_TEMPLATES = (
+    ('<deque>', ('deque',)),
+    ('<functional>', ('unary_function', 'binary_function',
+                      'plus', 'minus', 'multiplies', 'divides', 'modulus',
+                      'negate',
+                      'equal_to', 'not_equal_to', 'greater', 'less',
+                      'greater_equal', 'less_equal',
+                      'logical_and', 'logical_or', 'logical_not',
+                      'unary_negate', 'not1', 'binary_negate', 'not2',
+                      'bind1st', 'bind2nd',
+                      'pointer_to_unary_function',
+                      'pointer_to_binary_function',
+                      'ptr_fun',
+                      'mem_fun_t', 'mem_fun', 'mem_fun1_t', 'mem_fun1_ref_t',
+                      'mem_fun_ref_t',
+                      'const_mem_fun_t', 'const_mem_fun1_t',
+                      'const_mem_fun_ref_t', 'const_mem_fun1_ref_t',
+                      'mem_fun_ref',
+                     )),
+    ('<limits>', ('numeric_limits',)),
+    ('<list>', ('list',)),
+    ('<map>', ('map', 'multimap',)),
+    ('<memory>', ('allocator',)),
+    ('<queue>', ('queue', 'priority_queue',)),
+    ('<set>', ('set', 'multiset',)),
+    ('<stack>', ('stack',)),
+    ('<string>', ('char_traits', 'basic_string',)),
+    ('<utility>', ('pair',)),
+    ('<vector>', ('vector',)),
+
+    # gcc extensions.
+    # Note: std::hash is their hash, ::hash is our hash
+    ('<hash_map>', ('hash_map', 'hash_multimap',)),
+    ('<hash_set>', ('hash_set', 'hash_multiset',)),
+    ('<slist>', ('slist',)),
+    )
+
+_HEADERS_ACCEPTED_BUT_NOT_PROMOTED = {
+    # We can trust with reasonable confidence that map gives us pair<>, too.
+    'pair<>': ('map', 'multimap', 'hash_map', 'hash_multimap')
+}
+
+_RE_PATTERN_STRING = re.compile(r'\bstring\b')
+
+_re_pattern_algorithm_header = []
+for _template in ('copy', 'max', 'min', 'min_element', 'sort', 'swap',
+                  'transform'):
+    # Match max<type>(..., ...), max(..., ...), but not foo->max, foo.max or
+    # type::max().
+    _re_pattern_algorithm_header.append(
+        (re.compile(r'[^>.]\b' + _template + r'(<.*?>)?\([^\)]'),
+         _template,
+         '<algorithm>'))
+
+_re_pattern_templates = []
+for _header, _templates in _HEADERS_CONTAINING_TEMPLATES:
+    for _template in _templates:
+        _re_pattern_templates.append(
+            (re.compile(r'(\<|\b)' + _template + r'\s*\<'),
+             _template + '<>',
+             _header))
+
+
+def files_belong_to_same_module(filename_cpp, filename_h):
+    """Check if these two filenames belong to the same module.
+
+    The concept of a 'module' here is a as follows:
+    foo.h, foo-inl.h, foo.cpp, foo_test.cpp and foo_unittest.cpp belong to the
+    same 'module' if they are in the same directory.
+    some/path/public/xyzzy and some/path/internal/xyzzy are also considered
+    to belong to the same module here.
+
+    If the filename_cpp contains a longer path than the filename_h, for example,
+    '/absolute/path/to/base/sysinfo.cpp', and this file would include
+    'base/sysinfo.h', this function also produces the prefix needed to open the
+    header. This is used by the caller of this function to more robustly open the
+    header file. We don't have access to the real include paths in this context,
+    so we need this guesswork here.
+
+    Known bugs: tools/base/bar.cpp and base/bar.h belong to the same module
+    according to this implementation. Because of this, this function gives
+    some false positives. This should be sufficiently rare in practice.
+
+    Args:
+      filename_cpp: is the path for the .cpp file
+      filename_h: is the path for the header path
+
+    Returns:
+      Tuple with a bool and a string:
+      bool: True if filename_cpp and filename_h belong to the same module.
+      string: the additional prefix needed to open the header file.
+    """
+
+    if not filename_cpp.endswith('.cpp'):
+        return (False, '')
+    filename_cpp = filename_cpp[:-len('.cpp')]
+    if filename_cpp.endswith('_unittest'):
+        filename_cpp = filename_cpp[:-len('_unittest')]
+    elif filename_cpp.endswith('_test'):
+        filename_cpp = filename_cpp[:-len('_test')]
+    filename_cpp = filename_cpp.replace('/public/', '/')
+    filename_cpp = filename_cpp.replace('/internal/', '/')
+
+    if not filename_h.endswith('.h'):
+        return (False, '')
+    filename_h = filename_h[:-len('.h')]
+    if filename_h.endswith('-inl'):
+        filename_h = filename_h[:-len('-inl')]
+    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):
+    """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.
+    """
+    header_file = None
+    try:
+        header_file = io.open(filename, 'r', 'utf8', '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.
+            # What matters here is that the key is in include_state.
+            include_state.setdefault(include, '%s:%d' % (filename, line_number))
+    return True
+
+
+def check_for_include_what_you_use(filename, clean_lines, include_state, error,
+                                   io=codecs):
+    """Reports for missing stl includes.
+
+    This function will output warnings to make sure you are including the headers
+    necessary for the stl containers and functions that you use. We only give one
+    reason to include a header. For example, if you use both equal_to<> and
+    less<> in a .h file, only one (the latter in the file) of these will be
+    reported as a reason to include the <functional>.
+
+    Args:
+      filename: The name of the current file.
+      clean_lines: A CleansedLines instance containing the file.
+      include_state: An _IncludeState instance.
+      error: The function to call with any errors found.
+      io: The IO factory to use to read the header file. Provided for unittest
+          injection.
+    """
+    required = {}  # A map of header name to line_number and the template entity.
+        # Example of required: { '<functional>': (1219, 'less<>') }
+
+    for line_number in xrange(clean_lines.num_lines()):
+        line = clean_lines.elided[line_number]
+        if not line or line[0] == '#':
+            continue
+
+        # String is special -- it is a non-templatized type in STL.
+        if _RE_PATTERN_STRING.search(line):
+            required['<string>'] = (line_number, 'string')
+
+        for pattern, template, header in _re_pattern_algorithm_header:
+            if pattern.search(line):
+                required[header] = (line_number, template)
+
+        # The following function is just a speed up, no semantics are changed.
+        if not '<' in line:  # Reduces the cpu time usage by skipping lines.
+            continue
+
+        for pattern, template, header in _re_pattern_templates:
+            if pattern.search(line):
+                required[header] = (line_number, template)
+
+    # The policy is that if you #include something in foo.h you don't need to
+    # include it again in foo.cpp. Here, we will look at possible includes.
+    # Let's copy the include_state so it is only messed up within this function.
+    include_state = include_state.copy()
+
+    # Did we find the header for this file (if any) and succesfully load it?
+    header_found = False
+
+    # Use the absolute path so that matching works properly.
+    abs_filename = os.path.abspath(filename)
+
+    # For Emacs's flymake.
+    # If cpp_style is invoked from Emacs's flymake, a temporary file is generated
+    # by flymake and that file name might end with '_flymake.cpp'. In that case,
+    # restore original file name here so that the corresponding header file can be
+    # found.
+    # e.g. If the file name is 'foo_flymake.cpp', we should search for 'foo.h'
+    # instead of 'foo_flymake.h'
+    emacs_flymake_suffix = '_flymake.cpp'
+    if abs_filename.endswith(emacs_flymake_suffix):
+        abs_filename = abs_filename[:-len(emacs_flymake_suffix)] + '.cpp'
+
+    # include_state is modified during iteration, so we iterate over a copy of
+    # the keys.
+    for header in include_state.keys():  #NOLINT
+        (same_module, common_path) = files_belong_to_same_module(abs_filename, header)
+        fullpath = common_path + header
+        if same_module and update_include_state(fullpath, include_state, io):
+            header_found = True
+
+    # If we can't find the header file for a .cpp, assume it's because we don't
+    # know where to look. In that case we'll give up as we're not sure they
+    # didn't include it in the .h file.
+    # FIXME: Do a better job of finding .h files so we are confident that
+    #        not having the .h file means there isn't one.
+    if filename.endswith('.cpp') and not header_found:
+        return
+
+    # All the lines have been processed, report the errors found.
+    for required_header_unstripped in required:
+        template = required[required_header_unstripped][1]
+        if template in _HEADERS_ACCEPTED_BUT_NOT_PROMOTED:
+            headers = _HEADERS_ACCEPTED_BUT_NOT_PROMOTED[template]
+            if [True for header in headers if header in include_state]:
+                continue
+        if required_header_unstripped.strip('<>"') not in include_state:
+            error(required[required_header_unstripped][0],
+                  'build/include_what_you_use', 4,
+                  'Add #include ' + required_header_unstripped + ' for ' + template)
+
+
+def process_line(filename, file_extension,
+                 clean_lines, line, include_state, function_state,
+                 class_state, file_state, error):
+    """Processes a single line in the file.
+
+    Args:
+      filename: Filename of the file that is being processed.
+      file_extension: The extension (dot not included) of the file.
+      clean_lines: An array of strings, each representing a line of the file,
+                   with comments stripped.
+      line: Number of line being processed.
+      include_state: An _IncludeState instance in which the headers are inserted.
+      function_state: A _FunctionState instance which counts function lines, etc.
+      class_state: A _ClassState instance which maintains information about
+                   the current stack of nested class declarations being parsed.
+      file_state: A _FileState instance which maintains information about
+                  the state of things in the file.
+      error: A callable to which errors are reported, which takes arguments:
+             line number, error level, and message
+
+    """
+    raw_lines = clean_lines.raw_lines
+    check_for_function_lengths(clean_lines, line, function_state, error)
+    if search(r'\bNOLINT\b', raw_lines[line]):  # ignore nolint lines
+        return
+    check_for_multiline_comments_and_strings(clean_lines, line, error)
+    check_style(clean_lines, line, file_extension, file_state, error)
+    check_language(filename, clean_lines, line, file_extension, include_state,
+                   error)
+    check_for_non_standard_constructs(clean_lines, line, class_state, error)
+    check_posix_threading(clean_lines, line, error)
+    check_invalid_increment(clean_lines, line, error)
+
+
+def _process_lines(filename, file_extension, lines, error, verbosity):
+    """Performs lint checks and reports any errors to the given error function.
+
+    Args:
+      filename: Filename of the file that is being processed.
+      file_extension: The extension (dot not included) of the file.
+      lines: An array of strings, each representing a line of the file, with the
+             last element being empty if the file is termined with a newline.
+      error: A callable to which errors are reported, which takes 4 arguments:
+    """
+    lines = (['// marker so line numbers and indices both start at 1'] + lines +
+             ['// marker so line numbers end in a known way'])
+
+    include_state = _IncludeState()
+    function_state = _FunctionState(verbosity)
+    class_state = _ClassState()
+    file_state = _FileState()
+
+    check_for_copyright(lines, error)
+
+    if file_extension == 'h':
+        check_for_header_guard(filename, lines, error)
+
+    remove_multi_line_comments(lines, error)
+    clean_lines = CleansedLines(lines)
+    for line in xrange(clean_lines.num_lines()):
+        process_line(filename, file_extension, clean_lines, line,
+                     include_state, function_state, class_state, file_state, error)
+    class_state.check_finished(error)
+
+    check_for_include_what_you_use(filename, clean_lines, include_state, error)
+
+    # We check here rather than inside process_line so that we see raw
+    # lines rather than "cleaned" lines.
+    check_for_unicode_replacement_characters(lines, error)
+
+    check_for_new_line_at_eof(lines, error)
+
+
+class CppProcessor(object):
+
+    """Processes C++ lines for checking style."""
+
+    # This list is used to--
+    #
+    # (1) generate an explicit list of all possible categories,
+    # (2) unit test that all checked categories have valid names, and
+    # (3) unit test that all categories are getting unit tested.
+    #
+    categories = set([
+        'build/class',
+        'build/deprecated',
+        'build/endif_comment',
+        'build/forward_decl',
+        'build/header_guard',
+        'build/include',
+        'build/include_order',
+        'build/include_what_you_use',
+        'build/namespaces',
+        'build/printf_format',
+        'build/storage_class',
+        'build/using_std',
+        'legal/copyright',
+        'readability/braces',
+        'readability/casting',
+        'readability/check',
+        'readability/comparison_to_zero',
+        'readability/constructors',
+        'readability/control_flow',
+        'readability/fn_size',
+        'readability/function',
+        'readability/multiline_comment',
+        'readability/multiline_string',
+        'readability/naming',
+        'readability/null',
+        'readability/streams',
+        'readability/todo',
+        'readability/utf8',
+        'runtime/arrays',
+        'runtime/casting',
+        'runtime/explicit',
+        'runtime/init',
+        'runtime/int',
+        'runtime/invalid_increment',
+        'runtime/max_min_macros',
+        'runtime/memset',
+        'runtime/printf',
+        'runtime/printf_format',
+        'runtime/references',
+        'runtime/rtti',
+        'runtime/sizeof',
+        'runtime/string',
+        'runtime/threadsafe_fn',
+        'runtime/virtual',
+        'whitespace/blank_line',
+        'whitespace/braces',
+        'whitespace/comma',
+        'whitespace/comments',
+        'whitespace/declaration',
+        'whitespace/end_of_line',
+        'whitespace/ending_newline',
+        'whitespace/indent',
+        'whitespace/labels',
+        'whitespace/line_length',
+        'whitespace/newline',
+        'whitespace/operators',
+        'whitespace/parens',
+        'whitespace/semicolon',
+        'whitespace/tab',
+        'whitespace/todo',
+        ])
+
+    def __init__(self, file_path, file_extension, handle_style_error, verbosity):
+        """Create a CppProcessor 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.verbosity = verbosity
+
+    # Useful for unit testing.
+    def __eq__(self, other):
+        """Return whether this CppProcessor 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.verbosity != other.verbosity:
+            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 process(self, lines):
+        _process_lines(self.file_path, self.file_extension, lines,
+                       self.handle_style_error, self.verbosity)
+
+
+# FIXME: Remove this function (requires refactoring unit tests).
+def process_file_data(filename, file_extension, lines, error, verbosity):
+    processor = CppProcessor(filename, file_extension, error, verbosity)
+    processor.process(lines)
+
diff --git a/WebKitTools/Scripts/webkitpy/style/processors/cpp_unittest.py b/WebKitTools/Scripts/webkitpy/style/processors/cpp_unittest.py
new file mode 100644
index 0000000..e556cd3
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/processors/cpp_unittest.py
@@ -0,0 +1,3706 @@
+#!/usr/bin/python
+# -*- coding: utf-8; -*-
+#
+# Copyright (C) 2009 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:
+#
+#    * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#    * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#    * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# 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 unittest
+import cpp as cpp_style
+from cpp import CppProcessor
+
+# 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 = CppProcessor.categories
+    # This is a list including all categories seen in any unit test.
+    _seen_style_categories = {}
+
+    def __init__(self, assert_fn):
+        """assert_fn: a function to call when we notice a problem."""
+        self._assert_fn = assert_fn
+        self._errors = []
+
+    def __call__(self, unused_linenum, category, confidence, message):
+        self._assert_fn(category in self._all_style_categories,
+                        'Message "%s" has category "%s",'
+                        ' which is not in STYLE_CATEGORIES' % (message, category))
+        self._seen_style_categories[category] = 1
+        self._errors.append('%s  [%s] [%d]' % (message, category, confidence))
+
+    def results(self):
+        if len(self._errors) < 2:
+            return ''.join(self._errors)  # Most tests expect to have a string.
+        else:
+            return self._errors  # Let's give a list if there is more than one.
+
+    def result_list(self):
+        return self._errors
+
+    def verify_all_categories_are_seen(self):
+        """Fails if there's a category in _all_style_categories - _seen_style_categories.
+
+        This should only be called after all tests are run, so
+        _seen_style_categories has had a chance to fully populate.  Since
+        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)
+
+    def remove_if_present(self, substr):
+        for (index, error) in enumerate(self._errors):
+            if error.find(substr) != -1:
+                self._errors = self._errors[0:index] + self._errors[(index + 1):]
+                break
+
+
+# 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_is_c_or_objective_c(self):
+        self.assertTrue(cpp_style.is_c_or_objective_c("c"))
+        self.assertTrue(cpp_style.is_c_or_objective_c("m"))
+        self.assertFalse(cpp_style.is_c_or_objective_c("cpp"))
+
+
+class CppStyleTestBase(unittest.TestCase):
+    """Provides some useful helper functions for cpp_style tests.
+
+    Attributes:
+      verbosity: An integer that is the current verbosity level for
+                 the tests.
+
+    """
+
+    # FIXME: Refactor the unit tests so the verbosity level is passed
+    #        explicitly, just like it is in the real code.
+    verbosity = 1;
+
+    # Helper function to avoid needing to explicitly pass verbosity
+    # in all the unit test calls to cpp_style.process_file_data().
+    def process_file_data(self, filename, file_extension, lines, error):
+        """Call cpp_style.process_file_data() with the current verbosity."""
+        return cpp_style.process_file_data(filename, file_extension, lines, error, self.verbosity)
+
+    # Perform lint on single line of input and return the error message.
+    def perform_single_line_lint(self, code, file_name):
+        error_collector = ErrorCollector(self.assert_)
+        lines = code.split('\n')
+        cpp_style.remove_multi_line_comments(lines, error_collector)
+        clean_lines = cpp_style.CleansedLines(lines)
+        include_state = cpp_style._IncludeState()
+        function_state = cpp_style._FunctionState(self.verbosity)
+        ext = file_name[file_name.rfind('.') + 1:]
+        class_state = cpp_style._ClassState()
+        file_state = cpp_style._FileState()
+        cpp_style.process_line(file_name, ext, clean_lines, 0,
+                               include_state, function_state,
+                               class_state, file_state, error_collector)
+        # Single-line lint tests are allowed to fail the 'unlintable function'
+        # check.
+        error_collector.remove_if_present(
+            'Lint failed to find start of function body.')
+        return error_collector.results()
+
+    # Perform lint over multiple lines and return the error message.
+    def perform_multi_line_lint(self, code, file_extension):
+        error_collector = ErrorCollector(self.assert_)
+        lines = code.split('\n')
+        cpp_style.remove_multi_line_comments(lines, error_collector)
+        lines = cpp_style.CleansedLines(lines)
+        class_state = cpp_style._ClassState()
+        file_state = cpp_style._FileState()
+        for i in xrange(lines.num_lines()):
+            cpp_style.check_style(lines, i, file_extension, file_state, error_collector)
+            cpp_style.check_for_non_standard_constructs(lines, i, class_state,
+                                                        error_collector)
+        class_state.check_finished(error_collector)
+        return error_collector.results()
+
+    # Similar to perform_multi_line_lint, but calls check_language instead of
+    # check_for_non_standard_constructs
+    def perform_language_rules_check(self, file_name, code):
+        error_collector = ErrorCollector(self.assert_)
+        include_state = cpp_style._IncludeState()
+        lines = code.split('\n')
+        cpp_style.remove_multi_line_comments(lines, error_collector)
+        lines = cpp_style.CleansedLines(lines)
+        ext = file_name[file_name.rfind('.') + 1:]
+        for i in xrange(lines.num_lines()):
+            cpp_style.check_language(file_name, lines, i, ext, include_state,
+                                     error_collector)
+        return error_collector.results()
+
+    def perform_function_lengths_check(self, code):
+        """Perform Lint function length check on block of code and return warnings.
+
+        Builds up an array of lines corresponding to the code and strips comments
+        using cpp_style functions.
+
+        Establishes an error collector and invokes the function length checking
+        function following cpp_style's pattern.
+
+        Args:
+          code: C++ source code expected to generate a warning message.
+
+        Returns:
+          The accumulated errors.
+        """
+        error_collector = ErrorCollector(self.assert_)
+        function_state = cpp_style._FunctionState(self.verbosity)
+        lines = code.split('\n')
+        cpp_style.remove_multi_line_comments(lines, error_collector)
+        lines = cpp_style.CleansedLines(lines)
+        for i in xrange(lines.num_lines()):
+            cpp_style.check_for_function_lengths(lines, i,
+                                                 function_state, error_collector)
+        return error_collector.results()
+
+    def perform_include_what_you_use(self, code, filename='foo.h', io=codecs):
+        # First, build up the include state.
+        error_collector = ErrorCollector(self.assert_)
+        include_state = cpp_style._IncludeState()
+        lines = code.split('\n')
+        cpp_style.remove_multi_line_comments(lines, error_collector)
+        lines = cpp_style.CleansedLines(lines)
+        file_extension = filename[filename.rfind('.') + 1:]
+        for i in xrange(lines.num_lines()):
+            cpp_style.check_language(filename, lines, i, file_extension, include_state,
+                                     error_collector)
+        # We could clear the error_collector here, but this should
+        # also be fine, since our IncludeWhatYouUse unittests do not
+        # have language problems.
+
+        # Second, look for missing includes.
+        cpp_style.check_for_include_what_you_use(filename, lines, include_state,
+                                                 error_collector, io)
+        return error_collector.results()
+
+    # Perform lint and compare the error message with "expected_message".
+    def assert_lint(self, code, expected_message, file_name='foo.cpp'):
+        self.assertEquals(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
+
+        self.assertEquals(expected_message, messages)
+
+    def assert_multi_line_lint(self, code, expected_message, file_name='foo.h'):
+        file_extension = file_name[file_name.rfind('.') + 1:]
+        self.assertEquals(expected_message, self.perform_multi_line_lint(code, file_extension))
+
+    def assert_multi_line_lint_re(self, code, expected_message_re, file_name='foo.h'):
+        file_extension = file_name[file_name.rfind('.') + 1:]
+        message = self.perform_multi_line_lint(code, file_extension)
+        if not re.search(expected_message_re, message):
+            self.fail('Message was:\n' + message + 'Expected match to "' + expected_message_re + '"')
+
+    def assert_language_rules_check(self, file_name, code, expected_message):
+        self.assertEquals(expected_message,
+                          self.perform_language_rules_check(file_name, code))
+
+    def assert_include_what_you_use(self, code, expected_message):
+        self.assertEquals(expected_message,
+                          self.perform_include_what_you_use(code))
+
+    def assert_blank_lines_check(self, lines, start_errors, end_errors):
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data('foo.cpp', 'cpp', lines, error_collector)
+        self.assertEquals(
+            start_errors,
+            error_collector.results().count(
+                'Blank line at the start of a code block.  Is this needed?'
+                '  [whitespace/blank_line] [2]'))
+        self.assertEquals(
+            end_errors,
+            error_collector.results().count(
+                'Blank line at the end of a code block.  Is this needed?'
+                '  [whitespace/blank_line] [3]'))
+
+
+class CppStyleTest(CppStyleTestBase):
+
+    # Test get line width.
+    def test_get_line_width(self):
+        self.assertEquals(0, cpp_style.get_line_width(''))
+        self.assertEquals(10, cpp_style.get_line_width(u'x' * 10))
+        self.assertEquals(16, cpp_style.get_line_width(u'都|道|府|県|支庁'))
+
+    def test_find_next_multi_line_comment_start(self):
+        self.assertEquals(1, cpp_style.find_next_multi_line_comment_start([''], 0))
+
+        lines = ['a', 'b', '/* c']
+        self.assertEquals(2, cpp_style.find_next_multi_line_comment_start(lines, 0))
+
+        lines = ['char a[] = "/*";']  # not recognized as comment.
+        self.assertEquals(1, cpp_style.find_next_multi_line_comment_start(lines, 0))
+
+    def test_find_next_multi_line_comment_end(self):
+        self.assertEquals(1, cpp_style.find_next_multi_line_comment_end([''], 0))
+        lines = ['a', 'b', ' c */']
+        self.assertEquals(2, cpp_style.find_next_multi_line_comment_end(lines, 0))
+
+    def test_remove_multi_line_comments_from_range(self):
+        lines = ['a', '  /* comment ', ' * still comment', ' comment */   ', 'b']
+        cpp_style.remove_multi_line_comments_from_range(lines, 1, 4)
+        self.assertEquals(['a', '// dummy', '// dummy', '// dummy', 'b'], lines)
+
+    def test_spaces_at_end_of_line(self):
+        self.assert_lint(
+            '// Hello there ',
+            'Line ends in whitespace.  Consider deleting these extra spaces.'
+            '  [whitespace/end_of_line] [4]')
+
+    # Test C-style cast cases.
+    def test_cstyle_cast(self):
+        self.assert_lint(
+            'int a = (int)1.0;',
+            'Using C-style cast.  Use static_cast<int>(...) instead'
+            '  [readability/casting] [4]')
+        self.assert_lint(
+            'int *a = (int *)DEFINED_VALUE;',
+            'Using C-style cast.  Use reinterpret_cast<int *>(...) instead'
+            '  [readability/casting] [4]', 'foo.c')
+        self.assert_lint(
+            'uint16 a = (uint16)1.0;',
+            'Using C-style cast.  Use static_cast<uint16>(...) instead'
+            '  [readability/casting] [4]')
+        self.assert_lint(
+            'int32 a = (int32)1.0;',
+            'Using C-style cast.  Use static_cast<int32>(...) instead'
+            '  [readability/casting] [4]')
+        self.assert_lint(
+            'uint64 a = (uint64)1.0;',
+            'Using C-style cast.  Use static_cast<uint64>(...) instead'
+            '  [readability/casting] [4]')
+
+    # Test taking address of casts (runtime/casting)
+    def test_runtime_casting(self):
+        self.assert_lint(
+            'int* x = &static_cast<int*>(foo);',
+            'Are you taking an address of a cast?  '
+            'This is dangerous: could be a temp var.  '
+            'Take the address before doing the cast, rather than after'
+            '  [runtime/casting] [4]')
+
+        self.assert_lint(
+            'int* x = &dynamic_cast<int *>(foo);',
+            ['Are you taking an address of a cast?  '
+             'This is dangerous: could be a temp var.  '
+             'Take the address before doing the cast, rather than after'
+             '  [runtime/casting] [4]',
+             '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]'])
+
+        self.assert_lint(
+            'int* x = &reinterpret_cast<int *>(foo);',
+            'Are you taking an address of a cast?  '
+            'This is dangerous: could be a temp var.  '
+            'Take the address before doing the cast, rather than after'
+            '  [runtime/casting] [4]')
+
+        # It's OK to cast an address.
+        self.assert_lint(
+            'int* x = reinterpret_cast<int *>(&foo);',
+            '')
+
+    def test_runtime_selfinit(self):
+        self.assert_lint(
+            'Foo::Foo(Bar r, Bel l) : r_(r_), l_(l_) { }',
+            'You seem to be initializing a member variable with itself.'
+            '  [runtime/init] [4]')
+        self.assert_lint(
+            'Foo::Foo(Bar r, Bel l) : r_(r), l_(l) { }',
+            '')
+        self.assert_lint(
+            'Foo::Foo(Bar r) : r_(r), l_(r_), ll_(l_) { }',
+            '')
+
+    def test_runtime_rtti(self):
+        statement = 'int* x = dynamic_cast<int*>(&foo);'
+        error_message = (
+            '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)
+        # It is explicitly allowed in tests, however.
+        self.assert_language_rules_check('foo_test.cpp', statement, '')
+        self.assert_language_rules_check('foo_unittest.cpp', statement, '')
+        self.assert_language_rules_check('foo_regtest.cpp', statement, '')
+
+    # 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)
+    #   self.assert_lint('virtual void C(int*);', message)
+    #   self.assert_lint('void *(*f)(void *) = x;', message)
+    #   self.assert_lint('void Method(char*) {', message)
+    #   self.assert_lint('void Method(char*);', message)
+    #   self.assert_lint('void Method(char* /*x*/);', message)
+    #   self.assert_lint('typedef void (*Method)(int32);', message)
+    #   self.assert_lint('static void operator delete[](void*) throw();', message)
+    # 
+    #   self.assert_lint('virtual void D(int* p);', '')
+    #   self.assert_lint('void operator delete(void* x) throw();', '')
+    #   self.assert_lint('void Method(char* x)\n{', '')
+    #   self.assert_lint('void Method(char* /*x*/)\n{', '')
+    #   self.assert_lint('void Method(char* x);', '')
+    #   self.assert_lint('typedef void (*Method)(int32 x);', '')
+    #   self.assert_lint('static void operator delete[](void* x) throw();', '')
+    #   self.assert_lint('static void operator delete[](void* /*x*/) throw();', '')
+    # 
+    #   # This one should technically warn, but doesn't because the function
+    #   # pointer is confusing.
+    #   self.assert_lint('virtual void E(void (*fn)(int* p));', '')
+
+    # Test deprecated casts such as int(d)
+    def test_deprecated_cast(self):
+        self.assert_lint(
+            'int a = int(2.2);',
+            'Using deprecated casting style.  '
+            'Use static_cast<int>(...) instead'
+            '  [readability/casting] [4]')
+        # Checks for false positives...
+        self.assert_lint(
+            'int a = int(); // Constructor, o.k.',
+            '')
+        self.assert_lint(
+            'X::X() : a(int()) {} // default Constructor, o.k.',
+            '')
+        self.assert_lint(
+            'operator bool(); // Conversion operator, o.k.',
+            '')
+
+    # The second parameter to a gMock method definition is a function signature
+    # that often looks like a bad cast but should not picked up by lint.
+    def test_mock_method(self):
+        self.assert_lint(
+            'MOCK_METHOD0(method, int());',
+            '')
+        self.assert_lint(
+            'MOCK_CONST_METHOD1(method, float(string));',
+            '')
+        self.assert_lint(
+            'MOCK_CONST_METHOD2_T(method, double(float, float));',
+            '')
+
+    # Test sizeof(type) cases.
+    def test_sizeof_type(self):
+        self.assert_lint(
+            'sizeof(int);',
+            'Using sizeof(type).  Use sizeof(varname) instead if possible'
+            '  [runtime/sizeof] [1]')
+        self.assert_lint(
+            'sizeof(int *);',
+            'Using sizeof(type).  Use sizeof(varname) instead if possible'
+            '  [runtime/sizeof] [1]')
+
+    # Test typedef cases.  There was a bug that cpp_style misidentified
+    # typedef for pointer to function as C-style cast and produced
+    # false-positive error messages.
+    def test_typedef_for_pointer_to_function(self):
+        self.assert_lint(
+            'typedef void (*Func)(int x);',
+            '')
+        self.assert_lint(
+            'typedef void (*Func)(int *x);',
+            '')
+        self.assert_lint(
+            'typedef void Func(int x);',
+            '')
+        self.assert_lint(
+            'typedef void Func(int *x);',
+            '')
+
+    def test_include_what_you_use_no_implementation_files(self):
+        code = 'std::vector<int> foo;'
+        self.assertEquals('Add #include <vector> for vector<>'
+                          '  [build/include_what_you_use] [4]',
+                          self.perform_include_what_you_use(code, 'foo.h'))
+        self.assertEquals('',
+                          self.perform_include_what_you_use(code, 'foo.cpp'))
+
+    def test_include_what_you_use(self):
+        self.assert_include_what_you_use(
+            '''#include <vector>
+               std::vector<int> foo;
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <map>
+               std::pair<int,int> foo;
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <multimap>
+               std::pair<int,int> foo;
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <hash_map>
+               std::pair<int,int> foo;
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <utility>
+               std::pair<int,int> foo;
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <vector>
+               DECLARE_string(foobar);
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <vector>
+               DEFINE_string(foobar, "", "");
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <vector>
+               std::pair<int,int> foo;
+            ''',
+            'Add #include <utility> for pair<>'
+            '  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include "base/foobar.h"
+               std::vector<int> foo;
+            ''',
+            'Add #include <vector> for vector<>'
+            '  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include <vector>
+               std::set<int> foo;
+            ''',
+            'Add #include <set> for set<>'
+            '  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include "base/foobar.h"
+              hash_map<int, int> foobar;
+            ''',
+            'Add #include <hash_map> for hash_map<>'
+            '  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include "base/foobar.h"
+               bool foobar = std::less<int>(0,1);
+            ''',
+            'Add #include <functional> for less<>'
+            '  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include "base/foobar.h"
+               bool foobar = min<int>(0,1);
+            ''',
+            'Add #include <algorithm> for min  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            'void a(const string &foobar);',
+            'Add #include <string> for string  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include "base/foobar.h"
+               bool foobar = swap(0,1);
+            ''',
+            'Add #include <algorithm> for swap  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include "base/foobar.h"
+               bool foobar = transform(a.begin(), a.end(), b.start(), Foo);
+            ''',
+            'Add #include <algorithm> for transform  '
+            '[build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include "base/foobar.h"
+               bool foobar = min_element(a.begin(), a.end());
+            ''',
+            'Add #include <algorithm> for min_element  '
+            '[build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''foo->swap(0,1);
+               foo.swap(0,1);
+            ''',
+            '')
+        self.assert_include_what_you_use(
+            '''#include <string>
+               void a(const std::multimap<int,string> &foobar);
+            ''',
+            'Add #include <map> for multimap<>'
+            '  [build/include_what_you_use] [4]')
+        self.assert_include_what_you_use(
+            '''#include <queue>
+               void a(const std::priority_queue<int> &foobar);
+            ''',
+            '')
+        self.assert_include_what_you_use(
+             '''#include "base/basictypes.h"
+                #include "base/port.h"
+                #include <assert.h>
+                #include <string>
+                #include <vector>
+                vector<string> hajoa;''', '')
+        self.assert_include_what_you_use(
+            '''#include <string>
+               int i = numeric_limits<int>::max()
+            ''',
+            '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.assertEquals(message, '')
+
+        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',
+            io=MockIo(mock_header_contents))
+        self.assertEquals(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"
+
+               std::set<int> foo;''',
+            filename='blah/a.cpp')
+        self.assertEquals(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/a.h"
+
+               std::set<int> foo;''' % os.path.basename(os.getcwd()),
+            filename='a.cpp',
+            io=MockIo(mock_header_contents))
+        self.assertEquals(message, 'Add #include <set> for set<>  '
+                                   '[build/include_what_you_use] [4]')
+
+    def test_files_belong_to_same_module(self):
+        f = cpp_style.files_belong_to_same_module
+        self.assertEquals((True, ''), f('a.cpp', 'a.h'))
+        self.assertEquals((True, ''), f('base/google.cpp', 'base/google.h'))
+        self.assertEquals((True, ''), f('base/google_test.cpp', 'base/google.h'))
+        self.assertEquals((True, ''),
+                          f('base/google_unittest.cpp', 'base/google.h'))
+        self.assertEquals((True, ''),
+                          f('base/internal/google_unittest.cpp',
+                            'base/public/google.h'))
+        self.assertEquals((True, 'xxx/yyy/'),
+                          f('xxx/yyy/base/internal/google_unittest.cpp',
+                            'base/public/google.h'))
+        self.assertEquals((True, 'xxx/yyy/'),
+                          f('xxx/yyy/base/google_unittest.cpp',
+                            'base/public/google.h'))
+        self.assertEquals((True, ''),
+                          f('base/google_unittest.cpp', 'base/google-inl.h'))
+        self.assertEquals((True, '/home/build/google3/'),
+                          f('/home/build/google3/base/google.cpp', 'base/google.h'))
+
+        self.assertEquals((False, ''),
+                          f('/home/build/google3/base/google.cpp', 'basu/google.h'))
+        self.assertEquals((False, ''), f('a.cpp', 'b.h'))
+
+    def test_cleanse_line(self):
+        self.assertEquals('int foo = 0;  ',
+                          cpp_style.cleanse_comments('int foo = 0;  // danger!'))
+        self.assertEquals('int o = 0;',
+                          cpp_style.cleanse_comments('int /* foo */ o = 0;'))
+        self.assertEquals('foo(int a, int b);',
+                          cpp_style.cleanse_comments('foo(int a /* abc */, int b);'))
+        self.assertEqual('f(a, b);',
+                         cpp_style.cleanse_comments('f(a, /* name */ b);'))
+        self.assertEqual('f(a, b);',
+                         cpp_style.cleanse_comments('f(a /* name */, b);'))
+        self.assertEqual('f(a, b);',
+                         cpp_style.cleanse_comments('f(a, /* name */b);'))
+
+    def test_multi_line_comments(self):
+        # missing explicit is bad
+        self.assert_multi_line_lint(
+            r'''int a = 0;
+                /* multi-liner
+                class Foo {
+                Foo(int f);  // should cause a lint warning in code
+                }
+            */ ''',
+        '')
+        self.assert_multi_line_lint(
+            r'''/* int a = 0; multi-liner
+            static const int b = 0;''',
+      'Could not find end of multi-line comment'
+      '  [readability/multiline_comment] [5]')
+        self.assert_multi_line_lint(r'''    /* multi-line comment''',
+                                    'Could not find end of multi-line comment'
+                                    '  [readability/multiline_comment] [5]')
+        self.assert_multi_line_lint(r'''    // /* comment, but not multi-line''', '')
+
+    def test_multiline_strings(self):
+        multiline_string_error_message = (
+            'Multi-line string ("...") found.  This lint script doesn\'t '
+            'do well with such strings, and may give bogus warnings.  They\'re '
+            'ugly and unnecessary, and you should use concatenation instead".'
+            '  [readability/multiline_string] [5]')
+
+        file_path = 'mydir/foo.cpp'
+
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'cpp',
+                               ['const char* str = "This is a\\',
+                                ' multiline string.";'],
+                               error_collector)
+        self.assertEquals(
+            2,  # One per line.
+            error_collector.result_list().count(multiline_string_error_message))
+
+    # Test non-explicit single-argument constructors
+    def test_explicit_single_argument_constructors(self):
+        # missing explicit is bad
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(int f);
+               };''',
+            'Single-argument constructors should be marked explicit.'
+            '  [runtime/explicit] [5]')
+        # missing explicit is bad, even with whitespace
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo (int f);
+               };''',
+            ['Extra space before ( in function call  [whitespace/parens] [4]',
+             'Single-argument constructors should be marked explicit.'
+             '  [runtime/explicit] [5]'])
+        # missing explicit, with distracting comment, is still bad
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(int f); // simpler than Foo(blargh, blarg)
+               };''',
+            'Single-argument constructors should be marked explicit.'
+            '  [runtime/explicit] [5]')
+        # missing explicit, with qualified classname
+        self.assert_multi_line_lint(
+            '''class Qualifier::AnotherOne::Foo {
+                 Foo(int f);
+               };''',
+            'Single-argument constructors should be marked explicit.'
+            '  [runtime/explicit] [5]')
+        # structs are caught as well.
+        self.assert_multi_line_lint(
+            '''struct Foo {
+                 Foo(int f);
+               };''',
+            'Single-argument constructors should be marked explicit.'
+            '  [runtime/explicit] [5]')
+        # Templatized classes are caught as well.
+        self.assert_multi_line_lint(
+            '''template<typename T> class Foo {
+                 Foo(int f);
+               };''',
+            'Single-argument constructors should be marked explicit.'
+            '  [runtime/explicit] [5]')
+        # proper style is okay
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 explicit Foo(int f);
+               };''',
+            '')
+        # two argument constructor is okay
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(int f, int b);
+               };''',
+            '')
+        # two argument constructor, across two lines, is okay
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(int f,
+                     int b);
+               };''',
+            '')
+        # non-constructor (but similar name), is okay
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 aFoo(int f);
+               };''',
+            '')
+        # constructor with void argument is okay
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(void);
+               };''',
+            '')
+        # single argument method is okay
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Bar(int b);
+               };''',
+            '')
+        # comments should be ignored
+        self.assert_multi_line_lint(
+            '''class Foo {
+               // Foo(int f);
+               };''',
+            '')
+        # single argument function following class definition is okay
+        # (okay, it's not actually valid, but we don't want a false positive)
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(int f, int b);
+               };
+               Foo(int f);''',
+            '')
+        # single argument function is okay
+        self.assert_multi_line_lint(
+            '''static Foo(int f);''',
+            '')
+        # single argument copy constructor is okay.
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(const Foo&);
+               };''',
+            '')
+        self.assert_multi_line_lint(
+            '''class Foo {
+                 Foo(Foo&);
+               };''',
+            '')
+
+    def test_slash_star_comment_on_single_line(self):
+        self.assert_multi_line_lint(
+            '''/* static */ Foo(int f);''',
+            '')
+        self.assert_multi_line_lint(
+            '''/*/ static */  Foo(int f);''',
+            '')
+        self.assert_multi_line_lint(
+            '''/*/ static Foo(int f);''',
+            'Could not find end of multi-line comment'
+            '  [readability/multiline_comment] [5]')
+        self.assert_multi_line_lint(
+            '''    /*/ static Foo(int f);''',
+            'Could not find end of multi-line comment'
+            '  [readability/multiline_comment] [5]')
+        self.assert_multi_line_lint(
+            '''    /**/ static Foo(int f);''',
+            '')
+
+    # Test suspicious usage of "if" like this:
+    # if (a == b) {
+    #   DoSomething();
+    # } if (a == c) {   // Should be "else if".
+    #   DoSomething();  // This gets called twice if a == b && a == c.
+    # }
+    def test_suspicious_usage_of_if(self):
+        self.assert_lint(
+            '    if (a == b) {',
+            '')
+        self.assert_lint(
+            '    } if (a == b) {',
+            'Did you mean "else if"? If not, start a new line for "if".'
+            '  [readability/braces] [4]')
+
+    # Test suspicious usage of memset. Specifically, a 0
+    # as the final argument is almost certainly an error.
+    def test_suspicious_usage_of_memset(self):
+        # Normal use is okay.
+        self.assert_lint(
+            '    memset(buf, 0, sizeof(buf))',
+            '')
+
+        # A 0 as the final argument is almost certainly an error.
+        self.assert_lint(
+            '    memset(buf, sizeof(buf), 0)',
+            'Did you mean "memset(buf, 0, sizeof(buf))"?'
+            '  [runtime/memset] [4]')
+        self.assert_lint(
+            '    memset(buf, xsize * ysize, 0)',
+            'Did you mean "memset(buf, 0, xsize * ysize)"?'
+            '  [runtime/memset] [4]')
+
+        # There is legitimate test code that uses this form.
+        # This is okay since the second argument is a literal.
+        self.assert_lint(
+            "    memset(buf, 'y', 0)",
+            '')
+        self.assert_lint(
+            '    memset(buf, 4, 0)',
+            '')
+        self.assert_lint(
+            '    memset(buf, -1, 0)',
+            '')
+        self.assert_lint(
+            '    memset(buf, 0xF1, 0)',
+            '')
+        self.assert_lint(
+            '    memset(buf, 0xcd, 0)',
+            '')
+
+    def test_check_posix_threading(self):
+        self.assert_lint('sctime_r()', '')
+        self.assert_lint('strtok_r()', '')
+        self.assert_lint('    strtok_r(foo, ba, r)', '')
+        self.assert_lint('brand()', '')
+        self.assert_lint('_rand()', '')
+        self.assert_lint('.rand()', '')
+        self.assert_lint('>rand()', '')
+        self.assert_lint('rand()',
+                         'Consider using rand_r(...) instead of rand(...)'
+                         ' for improved thread safety.'
+                         '  [runtime/threadsafe_fn] [2]')
+        self.assert_lint('strtok()',
+                         'Consider using strtok_r(...) '
+                         'instead of strtok(...)'
+                         ' for improved thread safety.'
+                         '  [runtime/threadsafe_fn] [2]')
+
+    # Test potential format string bugs like printf(foo).
+    def test_format_strings(self):
+        self.assert_lint('printf("foo")', '')
+        self.assert_lint('printf("foo: %s", foo)', '')
+        self.assert_lint('DocidForPrintf(docid)', '')  # Should not trigger.
+        self.assert_lint(
+            'printf(foo)',
+            'Potential format string bug. Do printf("%s", foo) instead.'
+            '  [runtime/printf] [4]')
+        self.assert_lint(
+            'printf(foo.c_str())',
+            'Potential format string bug. '
+            'Do printf("%s", foo.c_str()) instead.'
+            '  [runtime/printf] [4]')
+        self.assert_lint(
+            'printf(foo->c_str())',
+            'Potential format string bug. '
+            'Do printf("%s", foo->c_str()) instead.'
+            '  [runtime/printf] [4]')
+        self.assert_lint(
+            'StringPrintf(foo)',
+            'Potential format string bug. Do StringPrintf("%s", foo) instead.'
+            ''
+            '  [runtime/printf] [4]')
+
+    # Variable-length arrays are not permitted.
+    def test_variable_length_array_detection(self):
+        errmsg = ('Do not use variable-length arrays.  Use an appropriately named '
+                  "('k' followed by CamelCase) compile-time constant for the size."
+                  '  [runtime/arrays] [1]')
+
+        self.assert_lint('int a[any_old_variable];', errmsg)
+        self.assert_lint('int doublesize[some_var * 2];', errmsg)
+        self.assert_lint('int a[afunction()];', errmsg)
+        self.assert_lint('int a[function(kMaxFooBars)];', errmsg)
+        self.assert_lint('bool aList[items_->size()];', errmsg)
+        self.assert_lint('namespace::Type buffer[len+1];', errmsg)
+
+        self.assert_lint('int a[64];', '')
+        self.assert_lint('int a[0xFF];', '')
+        self.assert_lint('int first[256], second[256];', '')
+        self.assert_lint('int arrayName[kCompileTimeConstant];', '')
+        self.assert_lint('char buf[somenamespace::kBufSize];', '')
+        self.assert_lint('int arrayName[ALL_CAPS];', '')
+        self.assert_lint('AClass array1[foo::bar::ALL_CAPS];', '')
+        self.assert_lint('int a[kMaxStrLen + 1];', '')
+        self.assert_lint('int a[sizeof(foo)];', '')
+        self.assert_lint('int a[sizeof(*foo)];', '')
+        self.assert_lint('int a[sizeof foo];', '')
+        self.assert_lint('int a[sizeof(struct Foo)];', '')
+        self.assert_lint('int a[128 - sizeof(const bar)];', '')
+        self.assert_lint('int a[(sizeof(foo) * 4)];', '')
+        self.assert_lint('int a[(arraysize(fixed_size_array)/2) << 1];', 'Missing spaces around /  [whitespace/operators] [3]')
+        self.assert_lint('delete a[some_var];', '')
+        self.assert_lint('return a[some_var];', '')
+
+    # Brace usage
+    def test_braces(self):
+        # Braces shouldn't be followed by a ; unless they're defining a struct
+        # or initializing an array
+        self.assert_lint('int a[3] = { 1, 2, 3 };', '')
+        self.assert_lint(
+            '''const int foo[] =
+                   {1, 2, 3 };''',
+            '')
+        # For single line, unmatched '}' with a ';' is ignored (not enough context)
+        self.assert_multi_line_lint(
+            '''int a[3] = { 1,
+                            2,
+                            3 };''',
+            '')
+        self.assert_multi_line_lint(
+            '''int a[2][3] = { { 1, 2 },
+                             { 3, 4 } };''',
+            '')
+        self.assert_multi_line_lint(
+            '''int a[2][3] =
+                   { { 1, 2 },
+                     { 3, 4 } };''',
+            '')
+
+    # CHECK/EXPECT_TRUE/EXPECT_FALSE replacements
+    def test_check_check(self):
+        self.assert_lint('CHECK(x == 42)',
+                         'Consider using CHECK_EQ instead of CHECK(a == b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('CHECK(x != 42)',
+                         'Consider using CHECK_NE instead of CHECK(a != b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('CHECK(x >= 42)',
+                         'Consider using CHECK_GE instead of CHECK(a >= b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('CHECK(x > 42)',
+                         'Consider using CHECK_GT instead of CHECK(a > b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('CHECK(x <= 42)',
+                         'Consider using CHECK_LE instead of CHECK(a <= b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('CHECK(x < 42)',
+                         'Consider using CHECK_LT instead of CHECK(a < b)'
+                         '  [readability/check] [2]')
+
+        self.assert_lint('DCHECK(x == 42)',
+                         'Consider using DCHECK_EQ instead of DCHECK(a == b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('DCHECK(x != 42)',
+                         'Consider using DCHECK_NE instead of DCHECK(a != b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('DCHECK(x >= 42)',
+                         'Consider using DCHECK_GE instead of DCHECK(a >= b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('DCHECK(x > 42)',
+                         'Consider using DCHECK_GT instead of DCHECK(a > b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('DCHECK(x <= 42)',
+                         'Consider using DCHECK_LE instead of DCHECK(a <= b)'
+                         '  [readability/check] [2]')
+        self.assert_lint('DCHECK(x < 42)',
+                         'Consider using DCHECK_LT instead of DCHECK(a < b)'
+                         '  [readability/check] [2]')
+
+        self.assert_lint(
+            'EXPECT_TRUE("42" == x)',
+            'Consider using EXPECT_EQ instead of EXPECT_TRUE(a == b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_TRUE("42" != x)',
+            'Consider using EXPECT_NE instead of EXPECT_TRUE(a != b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_TRUE(+42 >= x)',
+            'Consider using EXPECT_GE instead of EXPECT_TRUE(a >= b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_TRUE_M(-42 > x)',
+            'Consider using EXPECT_GT_M instead of EXPECT_TRUE_M(a > b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_TRUE_M(42U <= x)',
+            'Consider using EXPECT_LE_M instead of EXPECT_TRUE_M(a <= b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_TRUE_M(42L < x)',
+            'Consider using EXPECT_LT_M instead of EXPECT_TRUE_M(a < b)'
+            '  [readability/check] [2]')
+
+        self.assert_lint(
+            'EXPECT_FALSE(x == 42)',
+            'Consider using EXPECT_NE instead of EXPECT_FALSE(a == b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_FALSE(x != 42)',
+            'Consider using EXPECT_EQ instead of EXPECT_FALSE(a != b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_FALSE(x >= 42)',
+            'Consider using EXPECT_LT instead of EXPECT_FALSE(a >= b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'ASSERT_FALSE(x > 42)',
+            'Consider using ASSERT_LE instead of ASSERT_FALSE(a > b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'ASSERT_FALSE(x <= 42)',
+            'Consider using ASSERT_GT instead of ASSERT_FALSE(a <= b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'ASSERT_FALSE_M(x < 42)',
+            'Consider using ASSERT_GE_M instead of ASSERT_FALSE_M(a < b)'
+            '  [readability/check] [2]')
+
+        self.assert_lint('CHECK(some_iterator == obj.end())', '')
+        self.assert_lint('EXPECT_TRUE(some_iterator == obj.end())', '')
+        self.assert_lint('EXPECT_FALSE(some_iterator == obj.end())', '')
+
+        self.assert_lint('CHECK(CreateTestFile(dir, (1 << 20)));', '')
+        self.assert_lint('CHECK(CreateTestFile(dir, (1 >> 20)));', '')
+
+        self.assert_lint('CHECK(x<42)',
+                         ['Missing spaces around <'
+                          '  [whitespace/operators] [3]',
+                          'Consider using CHECK_LT instead of CHECK(a < b)'
+                          '  [readability/check] [2]'])
+        self.assert_lint('CHECK(x>42)',
+                         'Consider using CHECK_GT instead of CHECK(a > b)'
+                         '  [readability/check] [2]')
+
+        self.assert_lint(
+            '    EXPECT_TRUE(42 < x) // Random comment.',
+            'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)'
+            '  [readability/check] [2]')
+        self.assert_lint(
+            'EXPECT_TRUE( 42 < x )',
+            ['Extra space after ( in function call'
+             '  [whitespace/parens] [4]',
+             'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)'
+             '  [readability/check] [2]'])
+        self.assert_lint(
+            'CHECK("foo" == "foo")',
+            'Consider using CHECK_EQ instead of CHECK(a == b)'
+            '  [readability/check] [2]')
+
+        self.assert_lint('CHECK_EQ("foo", "foo")', '')
+
+    def test_brace_at_begin_of_line(self):
+        self.assert_lint('{',
+                         'This { should be at the end of the previous line'
+                         '  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            '#endif\n'
+            '{\n'
+            '}\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition) {',
+            '')
+        self.assert_multi_line_lint(
+            '    MACRO1(macroArg) {',
+            '')
+        self.assert_multi_line_lint(
+            'ACCESSOR_GETTER(MessageEventPorts) {',
+            'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'int foo() {',
+            'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'int foo() const {',
+            'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'int foo() const\n'
+            '{\n'
+            '}\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition\n'
+            '    && condition2\n'
+            '    && condition3) {\n'
+            '}\n',
+            '')
+
+    def test_mismatching_spaces_in_parens(self):
+        self.assert_lint('if (foo ) {', 'Mismatching spaces inside () in if'
+                         '  [whitespace/parens] [5]')
+        self.assert_lint('switch ( foo) {', 'Mismatching spaces inside () in switch'
+                         '  [whitespace/parens] [5]')
+        self.assert_lint('for (foo; ba; bar ) {', 'Mismatching spaces inside () in for'
+                         '  [whitespace/parens] [5]')
+        self.assert_lint('for ((foo); (ba); (bar) ) {', 'Mismatching spaces inside () in for'
+                         '  [whitespace/parens] [5]')
+        self.assert_lint('for (; foo; bar) {', '')
+        self.assert_lint('for (; (foo); (bar)) {', '')
+        self.assert_lint('for ( ; foo; bar) {', '')
+        self.assert_lint('for ( ; (foo); (bar)) {', '')
+        self.assert_lint('for ( ; foo; bar ) {', '')
+        self.assert_lint('for ( ; (foo); (bar) ) {', '')
+        self.assert_lint('for (foo; bar; ) {', '')
+        self.assert_lint('for ((foo); (bar); ) {', '')
+        self.assert_lint('foreach (foo, foos ) {', 'Mismatching spaces inside () in foreach'
+                         '  [whitespace/parens] [5]')
+        self.assert_lint('foreach ( foo, foos) {', 'Mismatching spaces inside () in foreach'
+                         '  [whitespace/parens] [5]')
+        self.assert_lint('while (  foo  ) {', 'Should have zero or one spaces inside'
+                         ' ( and ) in while  [whitespace/parens] [5]')
+
+    def test_spacing_for_fncall(self):
+        self.assert_lint('if (foo) {', '')
+        self.assert_lint('for (foo;bar;baz) {', '')
+        self.assert_lint('foreach (foo, foos) {', '')
+        self.assert_lint('while (foo) {', '')
+        self.assert_lint('switch (foo) {', '')
+        self.assert_lint('new (RenderArena()) RenderInline(document())', '')
+        self.assert_lint('foo( bar)', 'Extra space after ( in function call'
+                         '  [whitespace/parens] [4]')
+        self.assert_lint('foobar( \\', '')
+        self.assert_lint('foobar(     \\', '')
+        self.assert_lint('( a + b)', 'Extra space after ('
+                         '  [whitespace/parens] [2]')
+        self.assert_lint('((a+b))', '')
+        self.assert_lint('foo (foo)', 'Extra space before ( in function call'
+                         '  [whitespace/parens] [4]')
+        self.assert_lint('typedef foo (*foo)(foo)', '')
+        self.assert_lint('typedef foo (*foo12bar_)(foo)', '')
+        self.assert_lint('typedef foo (Foo::*bar)(foo)', '')
+        self.assert_lint('foo (Foo::*bar)(',
+                         'Extra space before ( in function call'
+                         '  [whitespace/parens] [4]')
+        self.assert_lint('typedef foo (Foo::*bar)(', '')
+        self.assert_lint('(foo)(bar)', '')
+        self.assert_lint('Foo (*foo)(bar)', '')
+        self.assert_lint('Foo (*foo)(Bar bar,', '')
+        self.assert_lint('char (*p)[sizeof(foo)] = &foo', '')
+        self.assert_lint('char (&ref)[sizeof(foo)] = &foo', '')
+        self.assert_lint('const char32 (*table[])[6];', '')
+
+    def test_spacing_before_braces(self):
+        self.assert_lint('if (foo){', 'Missing space before {'
+                         '  [whitespace/braces] [5]')
+        self.assert_lint('for{', 'Missing space before {'
+                         '  [whitespace/braces] [5]')
+        self.assert_lint('for {', '')
+        self.assert_lint('EXPECT_DEBUG_DEATH({', '')
+
+    def test_spacing_around_else(self):
+        self.assert_lint('}else {', 'Missing space before else'
+                         '  [whitespace/braces] [5]')
+        self.assert_lint('} else{', 'Missing space before {'
+                         '  [whitespace/braces] [5]')
+        self.assert_lint('} else {', '')
+        self.assert_lint('} else if', '')
+
+    def test_spacing_for_binary_ops(self):
+        self.assert_lint('if (foo<=bar) {', 'Missing spaces around <='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('if (foo<bar) {', 'Missing spaces around <'
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('if (foo<bar->baz) {', 'Missing spaces around <'
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('if (foo<bar->bar) {', 'Missing spaces around <'
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('typedef hash_map<Foo, Bar', 'Missing spaces around <'
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('typedef hash_map<FoooooType, BaaaaarType,', '')
+        self.assert_lint('a<Foo> t+=b;', 'Missing spaces around +='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo> t-=b;', 'Missing spaces around -='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t*=b;', 'Missing spaces around *='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t/=b;', 'Missing spaces around /='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t|=b;', 'Missing spaces around |='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t&=b;', 'Missing spaces around &='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t<<=b;', 'Missing spaces around <<='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t>>=b;', 'Missing spaces around >>='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t>>=&b|c;', 'Missing spaces around >>='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t<<=*b/c;', 'Missing spaces around <<='
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo> t -= b;', '')
+        self.assert_lint('a<Foo> t += b;', '')
+        self.assert_lint('a<Foo*> t *= b;', '')
+        self.assert_lint('a<Foo*> t /= b;', '')
+        self.assert_lint('a<Foo*> t |= b;', '')
+        self.assert_lint('a<Foo*> t &= b;', '')
+        self.assert_lint('a<Foo*> t <<= b;', '')
+        self.assert_lint('a<Foo*> t >>= b;', '')
+        self.assert_lint('a<Foo*> t >>= &b|c;', 'Missing spaces around |'
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t <<= *b/c;', 'Missing spaces around /'
+                         '  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t <<= b/c; //Test', [
+                         'Should have a space between // and comment  '
+                         '[whitespace/comments] [4]', 'Missing'
+                         ' spaces around /  [whitespace/operators] [3]'])
+        self.assert_lint('a<Foo*> t <<= b||c;  //Test', ['One space before end'
+                         ' of line comments  [whitespace/comments] [5]',
+                         'Should have a space between // and comment  '
+                         '[whitespace/comments] [4]',
+                         'Missing spaces around ||  [whitespace/operators] [3]'])
+        self.assert_lint('a<Foo*> t <<= b&&c; // Test', 'Missing spaces around'
+                         ' &&  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t <<= b&&&c; // Test', 'Missing spaces around'
+                         ' &&  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t <<= b&&*c; // Test', 'Missing spaces around'
+                         ' &&  [whitespace/operators] [3]')
+        self.assert_lint('a<Foo*> t <<= b && *c; // Test', '')
+        self.assert_lint('a<Foo*> t <<= b && &c; // Test', '')
+        self.assert_lint('a<Foo*> t <<= b || &c;  /*Test', 'Complex multi-line '
+                         '/*...*/-style comment found. Lint may give bogus '
+                         'warnings.  Consider replacing these with //-style'
+                         ' comments, with #if 0...#endif, or with more clearly'
+                         ' structured multi-line comments.  [readability/multiline_comment] [5]')
+        self.assert_lint('a<Foo&> t <<= &b | &c;', '')
+        self.assert_lint('a<Foo*> t <<= &b & &c; // Test', '')
+        self.assert_lint('a<Foo*> t <<= *b / &c; // Test', '')
+        self.assert_lint('if (a=b == 1)', 'Missing spaces around =  [whitespace/operators] [4]')
+        self.assert_lint('a = 1<<20', 'Missing spaces around <<  [whitespace/operators] [3]')
+        self.assert_lint('if (a = b == 1)', '')
+        self.assert_lint('a = 1 << 20', '')
+        self.assert_multi_line_lint('#include "config.h"\n#include <sys/io.h>\n',
+                                    '')
+        self.assert_multi_line_lint('#include "config.h"\n#import <foo/bar.h>\n',
+                                    '')
+
+    def test_spacing_before_last_semicolon(self):
+        self.assert_lint('call_function() ;',
+                         'Extra space before last semicolon. If this should be an '
+                         'empty statement, use { } instead.'
+                         '  [whitespace/semicolon] [5]')
+        self.assert_lint('while (true) ;',
+                         'Extra space before last semicolon. If this should be an '
+                         'empty statement, use { } instead.'
+                         '  [whitespace/semicolon] [5]')
+        self.assert_lint('default:;',
+                         'Semicolon defining empty statement. Use { } instead.'
+                         '  [whitespace/semicolon] [5]')
+        self.assert_lint('      ;',
+                         'Line contains only semicolon. If this should be an empty '
+                         'statement, use { } instead.'
+                         '  [whitespace/semicolon] [5]')
+        self.assert_lint('for (int i = 0; ;', '')
+
+    # Static or global STL strings.
+    def test_static_or_global_stlstrings(self):
+        self.assert_lint('string foo;',
+                         'For a static/global string constant, use a C style '
+                         'string instead: "char foo[]".'
+                         '  [runtime/string] [4]')
+        self.assert_lint('string kFoo = "hello"; // English',
+                         'For a static/global string constant, use a C style '
+                         'string instead: "char kFoo[]".'
+                         '  [runtime/string] [4]')
+        self.assert_lint('static string foo;',
+                         'For a static/global string constant, use a C style '
+                         'string instead: "static char foo[]".'
+                         '  [runtime/string] [4]')
+        self.assert_lint('static const string foo;',
+                         'For a static/global string constant, use a C style '
+                         'string instead: "static const char foo[]".'
+                         '  [runtime/string] [4]')
+        self.assert_lint('string Foo::bar;',
+                         'For a static/global string constant, use a C style '
+                         'string instead: "char Foo::bar[]".'
+                         '  [runtime/string] [4]')
+        # Rare case.
+        self.assert_lint('string foo("foobar");',
+                         'For a static/global string constant, use a C style '
+                         'string instead: "char foo[]".'
+                         '  [runtime/string] [4]')
+        # Should not catch local or member variables.
+        self.assert_lint('    string foo', '')
+        # Should not catch functions.
+        self.assert_lint('string EmptyString() { return ""; }', '')
+        self.assert_lint('string EmptyString () { return ""; }', '')
+        self.assert_lint('string VeryLongNameFunctionSometimesEndsWith(\n'
+                         '    VeryLongNameType very_long_name_variable) {}', '')
+        self.assert_lint('template<>\n'
+                         'string FunctionTemplateSpecialization<SomeType>(\n'
+                         '      int x) { return ""; }', '')
+        self.assert_lint('template<>\n'
+                         'string FunctionTemplateSpecialization<vector<A::B>* >(\n'
+                         '      int x) { return ""; }', '')
+
+        # should not catch methods of template classes.
+        self.assert_lint('string Class<Type>::Method() const\n'
+                         '{\n'
+                         '  return "";\n'
+                         '}\n', '')
+        self.assert_lint('string Class<Type>::Method(\n'
+                         '   int arg) const\n'
+                         '{\n'
+                         '  return "";\n'
+                         '}\n', '')
+
+    def test_no_spaces_in_function_calls(self):
+        self.assert_lint('TellStory(1, 3);',
+                         '')
+        self.assert_lint('TellStory(1, 3 );',
+                         'Extra space before )'
+                         '  [whitespace/parens] [2]')
+        self.assert_lint('TellStory(1 /* wolf */, 3 /* pigs */);',
+                         '')
+        self.assert_multi_line_lint('#endif\n    );',
+                                    '')
+
+    def test_two_spaces_between_code_and_comments(self):
+        self.assert_lint('} // namespace foo',
+                         '')
+        self.assert_lint('}// namespace foo',
+                         'One space before end of line comments'
+                         '  [whitespace/comments] [5]')
+        self.assert_lint('printf("foo"); // Outside quotes.',
+                         '')
+        self.assert_lint('int i = 0; // Having one space is fine.','')
+        self.assert_lint('int i = 0;  // Having two spaces is bad.',
+                         'One space before end of line comments'
+                         '  [whitespace/comments] [5]')
+        self.assert_lint('int i = 0;   // Having three spaces is bad.',
+                         'One space before end of line comments'
+                         '  [whitespace/comments] [5]')
+        self.assert_lint('// Top level comment', '')
+        self.assert_lint('    // Line starts with four spaces.', '')
+        self.assert_lint('foo();\n'
+                         '{ // A scope is opening.', '')
+        self.assert_lint('    foo();\n'
+                         '    { // An indented scope is opening.', '')
+        self.assert_lint('if (foo) { // not a pure scope',
+                         '')
+        self.assert_lint('printf("// In quotes.")', '')
+        self.assert_lint('printf("\\"%s // In quotes.")', '')
+        self.assert_lint('printf("%s", "// In quotes.")', '')
+
+    def test_space_after_comment_marker(self):
+        self.assert_lint('//', '')
+        self.assert_lint('//x', 'Should have a space between // and comment'
+                         '  [whitespace/comments] [4]')
+        self.assert_lint('// x', '')
+        self.assert_lint('//----', '')
+        self.assert_lint('//====', '')
+        self.assert_lint('//////', '')
+        self.assert_lint('////// x', '')
+        self.assert_lint('/// x', '')
+        self.assert_lint('////x', 'Should have a space between // and comment'
+                         '  [whitespace/comments] [4]')
+
+    def test_newline_at_eof(self):
+        def do_test(self, data, is_missing_eof):
+            error_collector = ErrorCollector(self.assert_)
+            self.process_file_data('foo.cpp', 'cpp', data.split('\n'),
+                                   error_collector)
+            # The warning appears only once.
+            self.assertEquals(
+                int(is_missing_eof),
+                error_collector.results().count(
+                    'Could not find a newline character at the end of the file.'
+                    '  [whitespace/ending_newline] [5]'))
+
+        do_test(self, '// Newline\n// at EOF\n', False)
+        do_test(self, '// No newline\n// at EOF', True)
+
+    def test_invalid_utf8(self):
+        def do_test(self, raw_bytes, has_invalid_utf8):
+            error_collector = ErrorCollector(self.assert_)
+            self.process_file_data('foo.cpp', 'cpp',
+                                   unicode(raw_bytes, 'utf8', 'replace').split('\n'),
+                                   error_collector)
+            # The warning appears only once.
+            self.assertEquals(
+                int(has_invalid_utf8),
+                error_collector.results().count(
+                    'Line contains invalid UTF-8'
+                    ' (or Unicode replacement character).'
+                    '  [readability/utf8] [5]'))
+
+        do_test(self, 'Hello world\n', False)
+        do_test(self, '\xe9\x8e\xbd\n', False)
+        do_test(self, '\xe9x\x8e\xbd\n', True)
+        # This is the encoding of the replacement character itself (which
+        # you can see by evaluating codecs.getencoder('utf8')(u'\ufffd')).
+        do_test(self, '\xef\xbf\xbd\n', True)
+
+    def test_is_blank_line(self):
+        self.assert_(cpp_style.is_blank_line(''))
+        self.assert_(cpp_style.is_blank_line(' '))
+        self.assert_(cpp_style.is_blank_line(' \t\r\n'))
+        self.assert_(not cpp_style.is_blank_line('int a;'))
+        self.assert_(not cpp_style.is_blank_line('{'))
+
+    def test_blank_lines_check(self):
+        self.assert_blank_lines_check(['{\n', '\n', '\n', '}\n'], 1, 1)
+        self.assert_blank_lines_check(['  if (foo) {\n', '\n', '  }\n'], 1, 1)
+        self.assert_blank_lines_check(
+            ['\n', '// {\n', '\n', '\n', '// Comment\n', '{\n', '}\n'], 0, 0)
+        self.assert_blank_lines_check(['\n', 'run("{");\n', '\n'], 0, 0)
+        self.assert_blank_lines_check(['\n', '  if (foo) { return 0; }\n', '\n'], 0, 0)
+
+    def test_allow_blank_line_before_closing_namespace(self):
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data('foo.cpp', 'cpp',
+                               ['namespace {', '', '}  // namespace'],
+                               error_collector)
+        self.assertEquals(0, error_collector.results().count(
+            'Blank line at the end of a code block.  Is this needed?'
+            '  [whitespace/blank_line] [3]'))
+
+    def test_allow_blank_line_before_if_else_chain(self):
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data('foo.cpp', 'cpp',
+                               ['if (hoge) {',
+                                '',  # No warning
+                                '} else if (piyo) {',
+                                '',  # No warning
+                                '} else if (piyopiyo) {',
+                                '  hoge = true;',  # No warning
+                                '} else {',
+                                '',  # Warning on this line
+                                '}'],
+                               error_collector)
+        self.assertEquals(1, error_collector.results().count(
+            'Blank line at the end of a code block.  Is this needed?'
+            '  [whitespace/blank_line] [3]'))
+
+    def test_else_on_same_line_as_closing_braces(self):
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data('foo.cpp', 'cpp',
+                               ['if (hoge) {',
+                                '',
+                                '}',
+                                ' else {'  # Warning on this line
+                                '',
+                                '}'],
+                               error_collector)
+        self.assertEquals(1, error_collector.results().count(
+            'An else should appear on the same line as the preceding }'
+            '  [whitespace/newline] [4]'))
+
+    def test_else_clause_not_on_same_line_as_else(self):
+        self.assert_lint('    else DoSomethingElse();',
+                         'Else clause should never be on same line as else '
+                         '(use 2 lines)  [whitespace/newline] [4]')
+        self.assert_lint('    else ifDoSomethingElse();',
+                         'Else clause should never be on same line as else '
+                         '(use 2 lines)  [whitespace/newline] [4]')
+        self.assert_lint('    else if (blah) {', '')
+        self.assert_lint('    variable_ends_in_else = true;', '')
+
+    def test_comma(self):
+        self.assert_lint('a = f(1,2);',
+                         'Missing space after ,  [whitespace/comma] [3]')
+        self.assert_lint('int tmp=a,a=b,b=tmp;',
+                         ['Missing spaces around =  [whitespace/operators] [4]',
+                          'Missing space after ,  [whitespace/comma] [3]'])
+        self.assert_lint('f(a, /* name */ b);', '')
+        self.assert_lint('f(a, /* name */b);', '')
+
+    def test_pointer_reference_marker_location(self):
+        self.assert_lint('int* b;', '', 'foo.cpp')
+        self.assert_lint('int *b;',
+                         'Declaration has space between type name and * in int *b  [whitespace/declaration] [3]',
+                         'foo.cpp')
+        self.assert_lint('return *b;', '', 'foo.cpp')
+        self.assert_lint('int *b;', '', 'foo.c')
+        self.assert_lint('int* b;',
+                         'Declaration has space between * and variable name in int* b  [whitespace/declaration] [3]',
+                         'foo.c')
+        self.assert_lint('int& b;', '', 'foo.cpp')
+        self.assert_lint('int &b;',
+                         'Declaration has space between type name and & in int &b  [whitespace/declaration] [3]',
+                         'foo.cpp')
+        self.assert_lint('return &b;', '', 'foo.cpp')
+
+    def test_indent(self):
+        self.assert_lint('static int noindent;', '')
+        self.assert_lint('    int fourSpaceIndent;', '')
+        self.assert_lint(' int oneSpaceIndent;',
+                         'Weird number of spaces at line-start.  '
+                         'Are you using a 4-space indent?  [whitespace/indent] [3]')
+        self.assert_lint('   int threeSpaceIndent;',
+                         'Weird number of spaces at line-start.  '
+                         'Are you using a 4-space indent?  [whitespace/indent] [3]')
+        self.assert_lint(' char* oneSpaceIndent = "public:";',
+                         'Weird number of spaces at line-start.  '
+                         'Are you using a 4-space indent?  [whitespace/indent] [3]')
+        self.assert_lint(' public:', '')
+        self.assert_lint('  public:', '')
+        self.assert_lint('   public:', '')
+
+    def test_label(self):
+        self.assert_lint('public:',
+                         'Labels should always be indented at least one space.  '
+                         'If this is a member-initializer list in a constructor, '
+                         'the colon should be on the line after the definition '
+                         'header.  [whitespace/labels] [4]')
+        self.assert_lint('  public:', '')
+        self.assert_lint('   public:', '')
+        self.assert_lint(' public:', '')
+        self.assert_lint('  public:', '')
+        self.assert_lint('   public:', '')
+
+    def test_not_alabel(self):
+        self.assert_lint('MyVeryLongNamespace::MyVeryLongClassName::', '')
+
+    def test_tab(self):
+        self.assert_lint('\tint a;',
+                         'Tab found; better to use spaces  [whitespace/tab] [1]')
+        self.assert_lint('int a = 5;\t// set a to 5',
+                         'Tab found; better to use spaces  [whitespace/tab] [1]')
+
+    def test_unnamed_namespaces_in_headers(self):
+        self.assert_language_rules_check(
+            'foo.h', 'namespace {',
+            'Do not use unnamed namespaces in header files.  See'
+            ' http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'
+            ' for more information.  [build/namespaces] [4]')
+        # namespace registration macros are OK.
+        self.assert_language_rules_check('foo.h', 'namespace {  \\', '')
+        # named namespaces are OK.
+        self.assert_language_rules_check('foo.h', 'namespace foo {', '')
+        self.assert_language_rules_check('foo.h', 'namespace foonamespace {', '')
+        self.assert_language_rules_check('foo.cpp', 'namespace {', '')
+        self.assert_language_rules_check('foo.cpp', 'namespace foo {', '')
+
+    def test_build_class(self):
+        # Test that the linter can parse to the end of class definitions,
+        # and that it will report when it can't.
+        # Use multi-line linter because it performs the ClassState check.
+        self.assert_multi_line_lint(
+            'class Foo {',
+            'Failed to find complete declaration of class Foo'
+            '  [build/class] [5]')
+        # Don't warn on forward declarations of various types.
+        self.assert_multi_line_lint(
+            'class Foo;',
+            '')
+        self.assert_multi_line_lint(
+            '''struct Foo*
+                 foo = NewFoo();''',
+            '')
+        # Here is an example where the linter gets confused, even though
+        # the code doesn't violate the style guide.
+        self.assert_multi_line_lint(
+            '''class Foo
+            #ifdef DERIVE_FROM_GOO
+              : public Goo {
+            #else
+              : public Hoo {
+            #endif
+              };''',
+            'Failed to find complete declaration of class Foo'
+            '  [build/class] [5]')
+
+    def test_build_end_comment(self):
+        # The crosstool compiler we currently use will fail to compile the
+        # code in this test, so we might consider removing the lint check.
+        self.assert_lint('#endif Not a comment',
+                         'Uncommented text after #endif is non-standard.'
+                         '  Use a comment.'
+                         '  [build/endif_comment] [5]')
+
+    def test_build_forward_decl(self):
+        # The crosstool compiler we currently use will fail to compile the
+        # code in this test, so we might consider removing the lint check.
+        self.assert_lint('class Foo::Goo;',
+                         'Inner-style forward declarations are invalid.'
+                         '  Remove this line.'
+                         '  [build/forward_decl] [5]')
+
+    def test_build_header_guard(self):
+        file_path = 'mydir/Foo.h'
+
+        # We can't rely on our internal stuff to get a sane path on the open source
+        # side of things, so just parse out the suggested header guard. This
+        # doesn't allow us to test the suggested header guard, but it does let us
+        # test all the other header tests.
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'h', [], error_collector)
+        expected_guard = ''
+        matcher = re.compile(
+            'No \#ifndef header guard found\, suggested CPP variable is\: ([A-Za-z_0-9]+) ')
+        for error in error_collector.result_list():
+            matches = matcher.match(error)
+            if matches:
+                expected_guard = matches.group(1)
+                break
+
+        # Make sure we extracted something for our header guard.
+        self.assertNotEqual(expected_guard, '')
+
+        # Wrong guard
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'h',
+                               ['#ifndef FOO_H', '#define FOO_H'], error_collector)
+        self.assertEquals(
+            1,
+            error_collector.result_list().count(
+                '#ifndef header guard has wrong style, please use: %s'
+                '  [build/header_guard] [5]' % expected_guard),
+            error_collector.result_list())
+
+        # No define
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'h',
+                               ['#ifndef %s' % expected_guard], error_collector)
+        self.assertEquals(
+            1,
+            error_collector.result_list().count(
+                'No #ifndef header guard found, suggested CPP variable is: %s'
+                '  [build/header_guard] [5]' % expected_guard),
+            error_collector.result_list())
+
+        # Mismatched define
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'h',
+                               ['#ifndef %s' % expected_guard,
+                                '#define FOO_H'],
+                               error_collector)
+        self.assertEquals(
+            1,
+            error_collector.result_list().count(
+                'No #ifndef header guard found, suggested CPP variable is: %s'
+                '  [build/header_guard] [5]' % expected_guard),
+            error_collector.result_list())
+
+        # No header guard errors
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'h',
+                               ['#ifndef %s' % expected_guard,
+                                '#define %s' % expected_guard,
+                                '#endif // %s' % expected_guard],
+                               error_collector)
+        for line in error_collector.result_list():
+            if line.find('build/header_guard') != -1:
+                self.fail('Unexpected error: %s' % line)
+
+        # Completely incorrect header guard
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'h',
+                               ['#ifndef FOO',
+                                '#define FOO',
+                                '#endif  // FOO'],
+                               error_collector)
+        self.assertEquals(
+            1,
+            error_collector.result_list().count(
+                '#ifndef header guard has wrong style, please use: %s'
+                '  [build/header_guard] [5]' % expected_guard),
+            error_collector.result_list())
+
+    def test_build_printf_format(self):
+        self.assert_lint(
+            r'printf("\%%d", value);',
+            '%, [, (, and { are undefined character escapes.  Unescape them.'
+            '  [build/printf_format] [3]')
+
+        self.assert_lint(
+            r'snprintf(buffer, sizeof(buffer), "\[%d", value);',
+            '%, [, (, and { are undefined character escapes.  Unescape them.'
+            '  [build/printf_format] [3]')
+
+        self.assert_lint(
+            r'fprintf(file, "\(%d", value);',
+            '%, [, (, and { are undefined character escapes.  Unescape them.'
+            '  [build/printf_format] [3]')
+
+        self.assert_lint(
+            r'vsnprintf(buffer, sizeof(buffer), "\\\{%d", ap);',
+            '%, [, (, and { are undefined character escapes.  Unescape them.'
+            '  [build/printf_format] [3]')
+
+        # Don't warn if double-slash precedes the symbol
+        self.assert_lint(r'printf("\\%%%d", value);',
+                         '')
+
+    def test_runtime_printf_format(self):
+        self.assert_lint(
+            r'fprintf(file, "%q", value);',
+            '%q in format strings is deprecated.  Use %ll instead.'
+            '  [runtime/printf_format] [3]')
+
+        self.assert_lint(
+            r'aprintf(file, "The number is %12q", value);',
+            '%q in format strings is deprecated.  Use %ll instead.'
+            '  [runtime/printf_format] [3]')
+
+        self.assert_lint(
+            r'printf(file, "The number is" "%-12q", value);',
+            '%q in format strings is deprecated.  Use %ll instead.'
+            '  [runtime/printf_format] [3]')
+
+        self.assert_lint(
+            r'printf(file, "The number is" "%+12q", value);',
+            '%q in format strings is deprecated.  Use %ll instead.'
+            '  [runtime/printf_format] [3]')
+
+        self.assert_lint(
+            r'printf(file, "The number is" "% 12q", value);',
+            '%q in format strings is deprecated.  Use %ll instead.'
+            '  [runtime/printf_format] [3]')
+
+        self.assert_lint(
+            r'snprintf(file, "Never mix %d and %1$d parmaeters!", value);',
+            '%N$ formats are unconventional.  Try rewriting to avoid them.'
+            '  [runtime/printf_format] [2]')
+
+    def assert_lintLogCodeOnError(self, code, expected_message):
+        # Special assert_lint which logs the input code on error.
+        result = self.perform_single_line_lint(code, 'foo.cpp')
+        if result != expected_message:
+            self.fail('For code: "%s"\nGot: "%s"\nExpected: "%s"'
+                      % (code, result, expected_message))
+
+    def test_build_storage_class(self):
+        qualifiers = [None, 'const', 'volatile']
+        signs = [None, 'signed', 'unsigned']
+        types = ['void', 'char', 'int', 'float', 'double',
+                 'schar', 'int8', 'uint8', 'int16', 'uint16',
+                 'int32', 'uint32', 'int64', 'uint64']
+        storage_classes = ['auto', 'extern', 'register', 'static', 'typedef']
+
+        build_storage_class_error_message = (
+            'Storage class (static, extern, typedef, etc) should be first.'
+            '  [build/storage_class] [5]')
+
+        # Some explicit cases. Legal in C++, deprecated in C99.
+        self.assert_lint('const int static foo = 5;',
+                         build_storage_class_error_message)
+
+        self.assert_lint('char static foo;',
+                         build_storage_class_error_message)
+
+        self.assert_lint('double const static foo = 2.0;',
+                         build_storage_class_error_message)
+
+        self.assert_lint('uint64 typedef unsignedLongLong;',
+                         build_storage_class_error_message)
+
+        self.assert_lint('int register foo = 0;',
+                         build_storage_class_error_message)
+
+        # Since there are a very large number of possibilities, randomly
+        # construct declarations.
+        # Make sure that the declaration is logged if there's an error.
+        # Seed generator with an integer for absolute reproducibility.
+        random.seed(25)
+        for unused_i in range(10):
+            # Build up random list of non-storage-class declaration specs.
+            other_decl_specs = [random.choice(qualifiers), random.choice(signs),
+                                random.choice(types)]
+            # remove None
+            other_decl_specs = filter(lambda x: x is not None, other_decl_specs)
+
+            # shuffle
+            random.shuffle(other_decl_specs)
+
+            # insert storage class after the first
+            storage_class = random.choice(storage_classes)
+            insertion_point = random.randint(1, len(other_decl_specs))
+            decl_specs = (other_decl_specs[0:insertion_point]
+                          + [storage_class]
+                          + other_decl_specs[insertion_point:])
+
+            self.assert_lintLogCodeOnError(
+                ' '.join(decl_specs) + ';',
+                build_storage_class_error_message)
+
+            # but no error if storage class is first
+            self.assert_lintLogCodeOnError(
+                storage_class + ' ' + ' '.join(other_decl_specs),
+                '')
+
+    def test_legal_copyright(self):
+        legal_copyright_message = (
+            'No copyright message found.  '
+            'You should have a line: "Copyright [year] <Copyright Owner>"'
+            '  [legal/copyright] [5]')
+
+        copyright_line = '// Copyright 2008 Google Inc. All Rights Reserved.'
+
+        file_path = 'mydir/googleclient/foo.cpp'
+
+        # There should be a copyright message in the first 10 lines
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'cpp', [], error_collector)
+        self.assertEquals(
+            1,
+            error_collector.result_list().count(legal_copyright_message))
+
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(
+            file_path, 'cpp',
+            ['' for unused_i in range(10)] + [copyright_line],
+            error_collector)
+        self.assertEquals(
+            1,
+            error_collector.result_list().count(legal_copyright_message))
+
+        # Test that warning isn't issued if Copyright line appears early enough.
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(file_path, 'cpp', [copyright_line], error_collector)
+        for message in error_collector.result_list():
+            if message.find('legal/copyright') != -1:
+                self.fail('Unexpected error: %s' % message)
+
+        error_collector = ErrorCollector(self.assert_)
+        self.process_file_data(
+            file_path, 'cpp',
+            ['' for unused_i in range(9)] + [copyright_line],
+            error_collector)
+        for message in error_collector.result_list():
+            if message.find('legal/copyright') != -1:
+                self.fail('Unexpected error: %s' % message)
+
+    def test_invalid_increment(self):
+        self.assert_lint('*count++;',
+                         'Changing pointer instead of value (or unused value of '
+                         'operator*).  [runtime/invalid_increment] [5]')
+
+
+class CleansedLinesTest(unittest.TestCase):
+    def test_init(self):
+        lines = ['Line 1',
+                 'Line 2',
+                 'Line 3 // Comment test',
+                 'Line 4 "foo"']
+
+        clean_lines = cpp_style.CleansedLines(lines)
+        self.assertEquals(lines, clean_lines.raw_lines)
+        self.assertEquals(4, clean_lines.num_lines())
+
+        self.assertEquals(['Line 1',
+                           'Line 2',
+                           'Line 3 ',
+                           'Line 4 "foo"'],
+                          clean_lines.lines)
+
+        self.assertEquals(['Line 1',
+                           'Line 2',
+                           'Line 3 ',
+                           'Line 4 ""'],
+                          clean_lines.elided)
+
+    def test_init_empty(self):
+        clean_lines = cpp_style.CleansedLines([])
+        self.assertEquals([], clean_lines.raw_lines)
+        self.assertEquals(0, clean_lines.num_lines())
+
+    def test_collapse_strings(self):
+        collapse = cpp_style.CleansedLines.collapse_strings
+        self.assertEquals('""', collapse('""'))             # ""     (empty)
+        self.assertEquals('"""', collapse('"""'))           # """    (bad)
+        self.assertEquals('""', collapse('"xyz"'))          # "xyz"  (string)
+        self.assertEquals('""', collapse('"\\\""'))         # "\""   (string)
+        self.assertEquals('""', collapse('"\'"'))           # "'"    (string)
+        self.assertEquals('"\"', collapse('"\"'))           # "\"    (bad)
+        self.assertEquals('""', collapse('"\\\\"'))         # "\\"   (string)
+        self.assertEquals('"', collapse('"\\\\\\"'))        # "\\\"  (bad)
+        self.assertEquals('""', collapse('"\\\\\\\\"'))     # "\\\\" (string)
+
+        self.assertEquals('\'\'', collapse('\'\''))         # ''     (empty)
+        self.assertEquals('\'\'', collapse('\'a\''))        # 'a'    (char)
+        self.assertEquals('\'\'', collapse('\'\\\'\''))     # '\''   (char)
+        self.assertEquals('\'', collapse('\'\\\''))         # '\'    (bad)
+        self.assertEquals('', collapse('\\012'))            # '\012' (char)
+        self.assertEquals('', collapse('\\xfF0'))           # '\xfF0' (char)
+        self.assertEquals('', collapse('\\n'))              # '\n' (char)
+        self.assertEquals('\#', collapse('\\#'))            # '\#' (bad)
+
+        self.assertEquals('StringReplace(body, "", "");',
+                          collapse('StringReplace(body, "\\\\", "\\\\\\\\");'))
+        self.assertEquals('\'\' ""',
+                          collapse('\'"\' "foo"'))
+
+
+class OrderOfIncludesTest(CppStyleTestBase):
+    def setUp(self):
+        self.include_state = cpp_style._IncludeState()
+
+        # Cheat os.path.abspath called in FileInfo class.
+        self.os_path_abspath_orig = os.path.abspath
+        os.path.abspath = lambda value: value
+
+    def tearDown(self):
+        os.path.abspath = self.os_path_abspath_orig
+
+    def test_try_drop_common_suffixes(self):
+        self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo-inl.h'))
+        self.assertEqual('foo/bar/foo',
+                         cpp_style._drop_common_suffixes('foo/bar/foo_inl.h'))
+        self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo.cpp'))
+        self.assertEqual('foo/foo_unusualinternal',
+                         cpp_style._drop_common_suffixes('foo/foo_unusualinternal.h'))
+        self.assertEqual('',
+                         cpp_style._drop_common_suffixes('_test.cpp'))
+        self.assertEqual('test',
+                         cpp_style._drop_common_suffixes('test.cpp'))
+
+
+class OrderOfIncludesTest(CppStyleTestBase):
+    def setUp(self):
+        self.include_state = cpp_style._IncludeState()
+
+        # Cheat os.path.abspath called in FileInfo class.
+        self.os_path_abspath_orig = os.path.abspath
+        os.path.abspath = lambda value: value
+
+    def tearDown(self):
+        os.path.abspath = self.os_path_abspath_orig
+
+    def test_check_next_include_order__no_config(self):
+        self.assertEqual('Header file should not contain WebCore config.h.',
+                         self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, True))
+
+    def test_check_next_include_order__no_self(self):
+        self.assertEqual('Header file should not contain itself.',
+                         self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, True))
+        # Test actual code to make sure that header types are correctly assigned.
+        self.assert_language_rules_check('Foo.h',
+                                         '#include "Foo.h"\n',
+                                         'Header file should not contain itself. Should be: alphabetically sorted.'
+                                         '  [build/include_order] [4]')
+        self.assert_language_rules_check('FooBar.h',
+                                         '#include "Foo.h"\n',
+                                         '')
+
+    def test_check_next_include_order__likely_then_config(self):
+        self.assertEqual('Found header this file implements before WebCore config.h.',
+                         self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, False))
+        self.assertEqual('Found WebCore config.h after a header this file implements.',
+                         self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False))
+
+    def test_check_next_include_order__other_then_config(self):
+        self.assertEqual('Found other header before WebCore config.h.',
+                         self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False))
+        self.assertEqual('Found WebCore config.h after other header.',
+                         self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False))
+
+    def test_check_next_include_order__config_then_other_then_likely(self):
+        self.assertEqual('', self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False))
+        self.assertEqual('Found other header before a header this file implements.',
+                         self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False))
+        self.assertEqual('Found header this file implements after other header.',
+                         self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, False))
+
+    def test_check_alphabetical_include_order(self):
+        self.assert_language_rules_check('foo.h',
+                                         '#include "a.h"\n'
+                                         '#include "c.h"\n'
+                                         '#include "b.h"\n',
+                                         'Alphabetical sorting problem.  [build/include_order] [4]')
+
+        self.assert_language_rules_check('foo.h',
+                                         '#include "a.h"\n'
+                                         '#include "b.h"\n'
+                                         '#include "c.h"\n',
+                                         '')
+
+        self.assert_language_rules_check('foo.h',
+                                         '#include <assert.h>\n'
+                                         '#include "bar.h"\n',
+                                         'Alphabetical sorting problem.  [build/include_order] [4]')
+
+        self.assert_language_rules_check('foo.h',
+                                         '#include "bar.h"\n'
+                                         '#include <assert.h>\n',
+                                         '')
+
+    def test_webkit_api_test_excluded(self):
+        self.assert_language_rules_check('WebKitTools/WebKitAPITest/Test.h',
+                                         '#include "foo.h"\n',
+                                         '')
+
+    def test_webkit_api_test_excluded(self):
+        self.assert_language_rules_check('WebKit/qt/QGVLauncher/main.cpp',
+                                         '#include "foo.h"\n',
+                                         '')
+
+    def test_check_line_break_after_own_header(self):
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '#include "bar.h"\n',
+                                         'You should add a blank line after implementation file\'s own header.  [build/include_order] [4]')
+
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#include "bar.h"\n',
+                                         '')
+
+    def test_check_preprocessor_in_include_section(self):
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#ifdef BAZ\n'
+                                         '#include "baz.h"\n'
+                                         '#else\n'
+                                         '#include "foobar.h"\n'
+                                         '#endif"\n'
+                                         '#include "bar.h"\n', # No flag because previous is in preprocessor section
+                                         '')
+
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#ifdef BAZ\n'
+                                         '#include "baz.h"\n'
+                                         '#endif"\n'
+                                         '#include "bar.h"\n'
+                                         '#include "a.h"\n', # Should still flag this.
+                                         'Alphabetical sorting problem.  [build/include_order] [4]')
+
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#ifdef BAZ\n'
+                                         '#include "baz.h"\n'
+                                         '#include "bar.h"\n' #Should still flag this
+                                         '#endif"\n',
+                                         'Alphabetical sorting problem.  [build/include_order] [4]')
+
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#ifdef BAZ\n'
+                                         '#include "baz.h"\n'
+                                         '#endif"\n'
+                                         '#ifdef FOOBAR\n'
+                                         '#include "foobar.h"\n'
+                                         '#endif"\n'
+                                         '#include "bar.h"\n'
+                                         '#include "a.h"\n', # Should still flag this.
+                                         'Alphabetical sorting problem.  [build/include_order] [4]')
+
+        # Check that after an already included error, the sorting rules still work.
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#include "foo.h"\n'
+                                         '#include "g.h"\n',
+                                         '"foo.h" already included at foo.cpp:1  [build/include] [4]')
+
+    def test_check_wtf_includes(self):
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#include <wtf/Assertions.h>\n',
+                                         '')
+        self.assert_language_rules_check('foo.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "foo.h"\n'
+                                         '\n'
+                                         '#include "wtf/Assertions.h"\n',
+                                         'wtf includes should be <wtf/file.h> instead of "wtf/file.h".'
+                                         '  [build/include] [4]')
+
+    def test_classify_include(self):
+        classify_include = cpp_style._classify_include
+        include_state = cpp_style._IncludeState()
+        self.assertEqual(cpp_style._CONFIG_HEADER,
+                         classify_include('foo/foo.cpp',
+                                          'config.h',
+                                          False, include_state))
+        self.assertEqual(cpp_style._PRIMARY_HEADER,
+                         classify_include('foo/internal/foo.cpp',
+                                          'foo/public/foo.h',
+                                          False, include_state))
+        self.assertEqual(cpp_style._PRIMARY_HEADER,
+                         classify_include('foo/internal/foo.cpp',
+                                          'foo/other/public/foo.h',
+                                          False, include_state))
+        self.assertEqual(cpp_style._OTHER_HEADER,
+                         classify_include('foo/internal/foo.cpp',
+                                          'foo/other/public/foop.h',
+                                          False, include_state))
+        self.assertEqual(cpp_style._OTHER_HEADER,
+                         classify_include('foo/foo.cpp',
+                                          'string',
+                                          True, include_state))
+        self.assertEqual(cpp_style._PRIMARY_HEADER,
+                         classify_include('fooCustom.cpp',
+                                          'foo.h',
+                                          False, include_state))
+        self.assertEqual(cpp_style._PRIMARY_HEADER,
+                         classify_include('PrefixFooCustom.cpp',
+                                          'Foo.h',
+                                          False, include_state))
+        self.assertEqual(cpp_style._MOC_HEADER,
+                         classify_include('foo.cpp',
+                                          'foo.moc',
+                                          False, include_state))
+        self.assertEqual(cpp_style._MOC_HEADER,
+                         classify_include('foo.cpp',
+                                          'moc_foo.cpp',
+                                          False, include_state))
+        # Tricky example where both includes might be classified as primary.
+        self.assert_language_rules_check('ScrollbarThemeWince.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "ScrollbarThemeWince.h"\n'
+                                         '\n'
+                                         '#include "Scrollbar.h"\n',
+                                         '')
+        self.assert_language_rules_check('ScrollbarThemeWince.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "Scrollbar.h"\n'
+                                         '\n'
+                                         '#include "ScrollbarThemeWince.h"\n',
+                                         'Found header this file implements after a header this file implements.'
+                                         ' Should be: config.h, primary header, blank line, and then alphabetically sorted.'
+                                         '  [build/include_order] [4]')
+        self.assert_language_rules_check('ResourceHandleWin.cpp',
+                                         '#include "config.h"\n'
+                                         '#include "ResourceHandle.h"\n'
+                                         '\n'
+                                         '#include "ResourceHandleWin.h"\n',
+                                         '')
+
+    def test_try_drop_common_suffixes(self):
+        self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo-inl.h'))
+        self.assertEqual('foo/bar/foo',
+                         cpp_style._drop_common_suffixes('foo/bar/foo_inl.h'))
+        self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo.cpp'))
+        self.assertEqual('foo/foo_unusualinternal',
+                         cpp_style._drop_common_suffixes('foo/foo_unusualinternal.h'))
+        self.assertEqual('',
+                         cpp_style._drop_common_suffixes('_test.cpp'))
+        self.assertEqual('test',
+                         cpp_style._drop_common_suffixes('test.cpp'))
+        self.assertEqual('test',
+                         cpp_style._drop_common_suffixes('test.cpp'))
+
+class CheckForFunctionLengthsTest(CppStyleTestBase):
+    def setUp(self):
+        # Reducing these thresholds for the tests speeds up tests significantly.
+        self.old_normal_trigger = cpp_style._FunctionState._NORMAL_TRIGGER
+        self.old_test_trigger = cpp_style._FunctionState._TEST_TRIGGER
+
+        cpp_style._FunctionState._NORMAL_TRIGGER = 10
+        cpp_style._FunctionState._TEST_TRIGGER = 25
+
+    def tearDown(self):
+        cpp_style._FunctionState._NORMAL_TRIGGER = self.old_normal_trigger
+        cpp_style._FunctionState._TEST_TRIGGER = self.old_test_trigger
+
+    # FIXME: Eliminate the need for this function.
+    def set_verbosity(self, verbosity):
+        """Set new test verbosity and return old test verbosity."""
+        old_verbosity = self.verbosity
+        self.verbosity = verbosity
+        return old_verbosity
+
+    def assert_function_lengths_check(self, code, expected_message):
+        """Check warnings for long function bodies are as expected.
+
+        Args:
+          code: C++ source code expected to generate a warning message.
+          expected_message: Message expected to be generated by the C++ code.
+        """
+        self.assertEquals(expected_message,
+                          self.perform_function_lengths_check(code))
+
+    def trigger_lines(self, error_level):
+        """Return number of lines needed to trigger a function length warning.
+
+        Args:
+          error_level: --v setting for cpp_style.
+
+        Returns:
+          Number of lines needed to trigger a function length warning.
+        """
+        return cpp_style._FunctionState._NORMAL_TRIGGER * 2 ** error_level
+
+    def trigger_test_lines(self, error_level):
+        """Return number of lines needed to trigger a test function length warning.
+
+        Args:
+          error_level: --v setting for cpp_style.
+
+        Returns:
+          Number of lines needed to trigger a test function length warning.
+        """
+        return cpp_style._FunctionState._TEST_TRIGGER * 2 ** error_level
+
+    def assert_function_length_check_definition(self, lines, error_level):
+        """Generate long function definition and check warnings are as expected.
+
+        Args:
+          lines: Number of lines to generate.
+          error_level:  --v setting for cpp_style.
+        """
+        trigger_level = self.trigger_lines(self.verbosity)
+        self.assert_function_lengths_check(
+            'void test(int x)' + self.function_body(lines),
+            ('Small and focused functions are preferred: '
+             'test() has %d non-comment lines '
+             '(error triggered by exceeding %d lines).'
+             '  [readability/fn_size] [%d]'
+             % (lines, trigger_level, error_level)))
+
+    def assert_function_length_check_definition_ok(self, lines):
+        """Generate shorter function definition and check no warning is produced.
+
+        Args:
+          lines: Number of lines to generate.
+        """
+        self.assert_function_lengths_check(
+            'void test(int x)' + self.function_body(lines),
+            '')
+
+    def assert_function_length_check_at_error_level(self, error_level):
+        """Generate and check function at the trigger level for --v setting.
+
+        Args:
+          error_level: --v setting for cpp_style.
+        """
+        self.assert_function_length_check_definition(self.trigger_lines(error_level),
+                                                     error_level)
+
+    def assert_function_length_check_below_error_level(self, error_level):
+        """Generate and check function just below the trigger level for --v setting.
+
+        Args:
+          error_level: --v setting for cpp_style.
+        """
+        self.assert_function_length_check_definition(self.trigger_lines(error_level) - 1,
+                                                     error_level - 1)
+
+    def assert_function_length_check_above_error_level(self, error_level):
+        """Generate and check function just above the trigger level for --v setting.
+
+        Args:
+          error_level: --v setting for cpp_style.
+        """
+        self.assert_function_length_check_definition(self.trigger_lines(error_level) + 1,
+                                                     error_level)
+
+    def function_body(self, number_of_lines):
+        return ' {\n' + '    this_is_just_a_test();\n' * number_of_lines + '}'
+
+    def function_body_with_blank_lines(self, number_of_lines):
+        return ' {\n' + '    this_is_just_a_test();\n\n' * number_of_lines + '}'
+
+    def function_body_with_no_lints(self, number_of_lines):
+        return ' {\n' + '    this_is_just_a_test();  // NOLINT\n' * number_of_lines + '}'
+
+    # Test line length checks.
+    def test_function_length_check_declaration(self):
+        self.assert_function_lengths_check(
+            'void test();',  # Not a function definition
+            '')
+
+    def test_function_length_check_declaration_with_block_following(self):
+        self.assert_function_lengths_check(
+            ('void test();\n'
+             + self.function_body(66)),  # Not a function definition
+            '')
+
+    def test_function_length_check_class_definition(self):
+        self.assert_function_lengths_check(  # Not a function definition
+            'class Test' + self.function_body(66) + ';',
+            '')
+
+    def test_function_length_check_trivial(self):
+        self.assert_function_lengths_check(
+            'void test() {}',  # Not counted
+            '')
+
+    def test_function_length_check_empty(self):
+        self.assert_function_lengths_check(
+            'void test() {\n}',
+            '')
+
+    def test_function_length_check_definition_below_severity0(self):
+        old_verbosity = self.set_verbosity(0)
+        self.assert_function_length_check_definition_ok(self.trigger_lines(0) - 1)
+        self.set_verbosity(old_verbosity)
+
+    def test_function_length_check_definition_at_severity0(self):
+        old_verbosity = self.set_verbosity(0)
+        self.assert_function_length_check_definition_ok(self.trigger_lines(0))
+        self.set_verbosity(old_verbosity)
+
+    def test_function_length_check_definition_above_severity0(self):
+        old_verbosity = self.set_verbosity(0)
+        self.assert_function_length_check_above_error_level(0)
+        self.set_verbosity(old_verbosity)
+
+    def test_function_length_check_definition_below_severity1v0(self):
+        old_verbosity = self.set_verbosity(0)
+        self.assert_function_length_check_below_error_level(1)
+        self.set_verbosity(old_verbosity)
+
+    def test_function_length_check_definition_at_severity1v0(self):
+        old_verbosity = self.set_verbosity(0)
+        self.assert_function_length_check_at_error_level(1)
+        self.set_verbosity(old_verbosity)
+
+    def test_function_length_check_definition_below_severity1(self):
+        self.assert_function_length_check_definition_ok(self.trigger_lines(1) - 1)
+
+    def test_function_length_check_definition_at_severity1(self):
+        self.assert_function_length_check_definition_ok(self.trigger_lines(1))
+
+    def test_function_length_check_definition_above_severity1(self):
+        self.assert_function_length_check_above_error_level(1)
+
+    def test_function_length_check_definition_severity1_plus_blanks(self):
+        error_level = 1
+        error_lines = self.trigger_lines(error_level) + 1
+        trigger_level = self.trigger_lines(self.verbosity)
+        self.assert_function_lengths_check(
+            'void test_blanks(int x)' + self.function_body(error_lines),
+            ('Small and focused functions are preferred: '
+             'test_blanks() has %d non-comment lines '
+             '(error triggered by exceeding %d lines).'
+             '  [readability/fn_size] [%d]')
+            % (error_lines, trigger_level, error_level))
+
+    def test_function_length_check_complex_definition_severity1(self):
+        error_level = 1
+        error_lines = self.trigger_lines(error_level) + 1
+        trigger_level = self.trigger_lines(self.verbosity)
+        self.assert_function_lengths_check(
+            ('my_namespace::my_other_namespace::MyVeryLongTypeName*\n'
+             'my_namespace::my_other_namespace::MyFunction(int arg1, char* arg2)'
+             + self.function_body(error_lines)),
+            ('Small and focused functions are preferred: '
+             'my_namespace::my_other_namespace::MyFunction()'
+             ' has %d non-comment lines '
+             '(error triggered by exceeding %d lines).'
+             '  [readability/fn_size] [%d]')
+            % (error_lines, trigger_level, error_level))
+
+    def test_function_length_check_definition_severity1_for_test(self):
+        error_level = 1
+        error_lines = self.trigger_test_lines(error_level) + 1
+        trigger_level = self.trigger_test_lines(self.verbosity)
+        self.assert_function_lengths_check(
+            'TEST_F(Test, Mutator)' + self.function_body(error_lines),
+            ('Small and focused functions are preferred: '
+             'TEST_F(Test, Mutator) has %d non-comment lines '
+             '(error triggered by exceeding %d lines).'
+             '  [readability/fn_size] [%d]')
+            % (error_lines, trigger_level, error_level))
+
+    def test_function_length_check_definition_severity1_for_split_line_test(self):
+        error_level = 1
+        error_lines = self.trigger_test_lines(error_level) + 1
+        trigger_level = self.trigger_test_lines(self.verbosity)
+        self.assert_function_lengths_check(
+            ('TEST_F(GoogleUpdateRecoveryRegistryProtectedTest,\n'
+             '    FixGoogleUpdate_AllValues_MachineApp)'  # note: 4 spaces
+             + self.function_body(error_lines)),
+            ('Small and focused functions are preferred: '
+             'TEST_F(GoogleUpdateRecoveryRegistryProtectedTest, '  # 1 space
+             'FixGoogleUpdate_AllValues_MachineApp) has %d non-comment lines '
+             '(error triggered by exceeding %d lines).'
+             '  [readability/fn_size] [%d]')
+            % (error_lines+1, trigger_level, error_level))
+
+    def test_function_length_check_definition_severity1_for_bad_test_doesnt_break(self):
+        error_level = 1
+        error_lines = self.trigger_test_lines(error_level) + 1
+        trigger_level = self.trigger_test_lines(self.verbosity)
+        self.assert_function_lengths_check(
+            ('TEST_F('
+             + self.function_body(error_lines)),
+            ('Small and focused functions are preferred: '
+             'TEST_F has %d non-comment lines '
+             '(error triggered by exceeding %d lines).'
+             '  [readability/fn_size] [%d]')
+            % (error_lines, trigger_level, error_level))
+
+    def test_function_length_check_definition_severity1_with_embedded_no_lints(self):
+        error_level = 1
+        error_lines = self.trigger_lines(error_level) + 1
+        trigger_level = self.trigger_lines(self.verbosity)
+        self.assert_function_lengths_check(
+            'void test(int x)' + self.function_body_with_no_lints(error_lines),
+            ('Small and focused functions are preferred: '
+             'test() has %d non-comment lines '
+             '(error triggered by exceeding %d lines).'
+             '  [readability/fn_size] [%d]')
+            % (error_lines, trigger_level, error_level))
+
+    def test_function_length_check_definition_severity1_with_no_lint(self):
+        self.assert_function_lengths_check(
+            ('void test(int x)' + self.function_body(self.trigger_lines(1))
+             + '  // NOLINT -- long function'),
+            '')
+
+    def test_function_length_check_definition_below_severity2(self):
+        self.assert_function_length_check_below_error_level(2)
+
+    def test_function_length_check_definition_severity2(self):
+        self.assert_function_length_check_at_error_level(2)
+
+    def test_function_length_check_definition_above_severity2(self):
+        self.assert_function_length_check_above_error_level(2)
+
+    def test_function_length_check_definition_below_severity3(self):
+        self.assert_function_length_check_below_error_level(3)
+
+    def test_function_length_check_definition_severity3(self):
+        self.assert_function_length_check_at_error_level(3)
+
+    def test_function_length_check_definition_above_severity3(self):
+        self.assert_function_length_check_above_error_level(3)
+
+    def test_function_length_check_definition_below_severity4(self):
+        self.assert_function_length_check_below_error_level(4)
+
+    def test_function_length_check_definition_severity4(self):
+        self.assert_function_length_check_at_error_level(4)
+
+    def test_function_length_check_definition_above_severity4(self):
+        self.assert_function_length_check_above_error_level(4)
+
+    def test_function_length_check_definition_below_severity5(self):
+        self.assert_function_length_check_below_error_level(5)
+
+    def test_function_length_check_definition_at_severity5(self):
+        self.assert_function_length_check_at_error_level(5)
+
+    def test_function_length_check_definition_above_severity5(self):
+        self.assert_function_length_check_above_error_level(5)
+
+    def test_function_length_check_definition_huge_lines(self):
+        # 5 is the limit
+        self.assert_function_length_check_definition(self.trigger_lines(10), 5)
+
+    def test_function_length_not_determinable(self):
+        # Macro invocation without terminating semicolon.
+        self.assert_function_lengths_check(
+            'MACRO(arg)',
+            '')
+
+        # Macro with underscores
+        self.assert_function_lengths_check(
+            'MACRO_WITH_UNDERSCORES(arg1, arg2, arg3)',
+            '')
+
+        self.assert_function_lengths_check(
+            'NonMacro(arg)',
+            'Lint failed to find start of function body.'
+            '  [readability/fn_size] [5]')
+
+
+class NoNonVirtualDestructorsTest(CppStyleTestBase):
+
+    def test_no_error(self):
+        self.assert_multi_line_lint(
+            '''class Foo {
+                   virtual ~Foo();
+                   virtual void foo();
+               };''',
+            '')
+
+        self.assert_multi_line_lint(
+            '''class Foo {
+                   virtual inline ~Foo();
+                   virtual void foo();
+               };''',
+            '')
+
+        self.assert_multi_line_lint(
+            '''class Foo {
+                   inline virtual ~Foo();
+                   virtual void foo();
+               };''',
+            '')
+
+        self.assert_multi_line_lint(
+            '''class Foo::Goo {
+                   virtual ~Goo();
+                   virtual void goo();
+               };''',
+            '')
+        self.assert_multi_line_lint(
+            'class Foo { void foo(); };',
+            'More than one command on the same line  [whitespace/newline] [4]')
+
+        self.assert_multi_line_lint(
+            '''class Qualified::Goo : public Foo {
+                   virtual void goo();
+               };''',
+            '')
+
+        self.assert_multi_line_lint(
+            # Line-ending :
+            '''class Goo :
+               public Foo {
+                    virtual void goo();
+               };''',
+            'Labels should always be indented at least one space.  If this is a '
+            'member-initializer list in a constructor, the colon should be on the '
+            'line after the definition header.  [whitespace/labels] [4]')
+
+    def test_no_destructor_when_virtual_needed(self):
+        self.assert_multi_line_lint_re(
+            '''class Foo {
+                   virtual void foo();
+               };''',
+            'The class Foo probably needs a virtual destructor')
+
+    def test_destructor_non_virtual_when_virtual_needed(self):
+        self.assert_multi_line_lint_re(
+            '''class Foo {
+                   ~Foo();
+                   virtual void foo();
+               };''',
+            'The class Foo probably needs a virtual destructor')
+
+    def test_no_warn_when_derived(self):
+        self.assert_multi_line_lint(
+            '''class Foo : public Goo {
+                   virtual void foo();
+               };''',
+            '')
+
+    def test_internal_braces(self):
+        self.assert_multi_line_lint_re(
+            '''class Foo {
+                   enum Goo {
+                       GOO
+                   };
+                   virtual void foo();
+               };''',
+            'The class Foo probably needs a virtual destructor')
+
+    def test_inner_class_needs_virtual_destructor(self):
+        self.assert_multi_line_lint_re(
+            '''class Foo {
+                   class Goo {
+                       virtual void goo();
+                   };
+               };''',
+            'The class Goo probably needs a virtual destructor')
+
+    def test_outer_class_needs_virtual_destructor(self):
+        self.assert_multi_line_lint_re(
+            '''class Foo {
+                   class Goo {
+                   };
+                   virtual void foo();
+               };''',
+            'The class Foo probably needs a virtual destructor')
+
+    def test_qualified_class_needs_virtual_destructor(self):
+        self.assert_multi_line_lint_re(
+            '''class Qualified::Foo {
+                   virtual void foo();
+               };''',
+            'The class Qualified::Foo probably needs a virtual destructor')
+
+    def test_multi_line_declaration_no_error(self):
+        self.assert_multi_line_lint_re(
+            '''class Foo
+                   : public Goo {
+                   virtual void foo();
+               };''',
+            '')
+
+    def test_multi_line_declaration_with_error(self):
+        self.assert_multi_line_lint(
+            '''class Foo
+               {
+                   virtual void foo();
+               };''',
+            ['This { should be at the end of the previous line  '
+             '[whitespace/braces] [4]',
+             'The class Foo probably needs a virtual destructor due to having '
+             'virtual method(s), one declared at line 2.  [runtime/virtual] [4]'])
+
+
+class WebKitStyleTest(CppStyleTestBase):
+
+    # for http://webkit.org/coding/coding-style.html
+    def test_indentation(self):
+        # 1. Use spaces, not tabs. Tabs should only appear in files that
+        #    require them for semantic meaning, like Makefiles.
+        self.assert_multi_line_lint(
+            'class Foo {\n'
+            '    int goo;\n'
+            '};',
+            '')
+        self.assert_multi_line_lint(
+            'class Foo {\n'
+            '\tint goo;\n'
+            '};',
+            'Tab found; better to use spaces  [whitespace/tab] [1]')
+
+        # 2. The indent size is 4 spaces.
+        self.assert_multi_line_lint(
+            'class Foo {\n'
+            '    int goo;\n'
+            '};',
+            '')
+        self.assert_multi_line_lint(
+            'class Foo {\n'
+            '   int goo;\n'
+            '};',
+            'Weird number of spaces at line-start.  Are you using a 4-space indent?  [whitespace/indent] [3]')
+        # FIXME: No tests for 8-spaces.
+
+        # 3. In a header, code inside a namespace should not be indented.
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n\n'
+            'class Document {\n'
+            '    int myVariable;\n'
+            '};\n'
+            '}',
+            '',
+            'foo.h')
+        self.assert_multi_line_lint(
+            'namespace OuterNamespace {\n'
+            '    namespace InnerNamespace {\n'
+            '    class Document {\n'
+            '};\n'
+            '};\n'
+            '}',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.h')
+        self.assert_multi_line_lint(
+            'namespace OuterNamespace {\n'
+            '    class Document {\n'
+            '    namespace InnerNamespace {\n'
+            '};\n'
+            '};\n'
+            '}',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.h')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n'
+            '#if 0\n'
+            '    class Document {\n'
+            '};\n'
+            '#endif\n'
+            '}',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.h')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n'
+            'class Document {\n'
+            '};\n'
+            '}',
+            '',
+            'foo.h')
+
+        # 4. In an implementation file (files with the extension .cpp, .c
+        #    or .mm), code inside a namespace should not be indented.
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n\n'
+            'Document::Foo()\n'
+            '    : foo(bar)\n'
+            '    , boo(far)\n'
+            '{\n'
+            '    stuff();\n'
+            '}',
+            '',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace OuterNamespace {\n'
+            'namespace InnerNamespace {\n'
+            'Document::Foo() { }\n'
+            '    void* p;\n'
+            '}\n'
+            '}\n',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace OuterNamespace {\n'
+            'namespace InnerNamespace {\n'
+            'Document::Foo() { }\n'
+            '}\n'
+            '    void* p;\n'
+            '}\n',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n\n'
+            '    const char* foo = "start:;"\n'
+            '        "dfsfsfs";\n'
+            '}\n',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n\n'
+            'const char* foo(void* a = ";", // ;\n'
+            '    void* b);\n'
+            '    void* p;\n'
+            '}\n',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n\n'
+            'const char* foo[] = {\n'
+            '    "void* b);", // ;\n'
+            '    "asfdf",\n'
+            '    }\n'
+            '    void* p;\n'
+            '}\n',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n\n'
+            'const char* foo[] = {\n'
+            '    "void* b);", // }\n'
+            '    "asfdf",\n'
+            '    }\n'
+            '}\n',
+            '',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            '    namespace WebCore {\n\n'
+            '    void Document::Foo()\n'
+            '    {\n'
+            'start: // infinite loops are fun!\n'
+            '        goto start;\n'
+            '    }',
+            'namespace should never be indented.  [whitespace/indent] [4]',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n'
+            '    Document::Foo() { }\n'
+            '}',
+            'Code inside a namespace should not be indented.'
+            '  [whitespace/indent] [4]',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n'
+            '#define abc(x) x; \\\n'
+            '    x\n'
+            '}',
+            '',
+            'foo.cpp')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n'
+            '#define abc(x) x; \\\n'
+            '    x\n'
+            '    void* x;'
+            '}',
+            'Code inside a namespace should not be indented.  [whitespace/indent] [4]',
+            'foo.cpp')
+
+        # 5. A case label should line up with its switch statement. The
+        #    case statement is indented.
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '    case fooCondition:\n'
+            '    case barCondition:\n'
+            '        i++;\n'
+            '        break;\n'
+            '    default:\n'
+            '        i--;\n'
+            '    }\n',
+            '')
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '    case fooCondition:\n'
+            '        switch (otherCondition) {\n'
+            '        default:\n'
+            '            return;\n'
+            '        }\n'
+            '    default:\n'
+            '        i--;\n'
+            '    }\n',
+            '')
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '    case fooCondition: break;\n'
+            '    default: return;\n'
+            '    }\n',
+            '')
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '        case fooCondition:\n'
+            '        case barCondition:\n'
+            '            i++;\n'
+            '            break;\n'
+            '        default:\n'
+            '            i--;\n'
+            '    }\n',
+            'A case label should not be indented, but line up with its switch statement.'
+            '  [whitespace/indent] [4]')
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '        case fooCondition:\n'
+            '            break;\n'
+            '    default:\n'
+            '            i--;\n'
+            '    }\n',
+            'A case label should not be indented, but line up with its switch statement.'
+            '  [whitespace/indent] [4]')
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '    case fooCondition:\n'
+            '    case barCondition:\n'
+            '        switch (otherCondition) {\n'
+            '            default:\n'
+            '            return;\n'
+            '        }\n'
+            '    default:\n'
+            '        i--;\n'
+            '    }\n',
+            'A case label should not be indented, but line up with its switch statement.'
+            '  [whitespace/indent] [4]')
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '    case fooCondition:\n'
+            '    case barCondition:\n'
+            '    i++;\n'
+            '    break;\n\n'
+            '    default:\n'
+            '    i--;\n'
+            '    }\n',
+            'Non-label code inside switch statements should be indented.'
+            '  [whitespace/indent] [4]')
+        self.assert_multi_line_lint(
+            '    switch (condition) {\n'
+            '    case fooCondition:\n'
+            '    case barCondition:\n'
+            '        switch (otherCondition) {\n'
+            '        default:\n'
+            '        return;\n'
+            '        }\n'
+            '    default:\n'
+            '        i--;\n'
+            '    }\n',
+            'Non-label code inside switch statements should be indented.'
+            '  [whitespace/indent] [4]')
+
+        # 6. Boolean expressions at the same nesting level that span
+        #   multiple lines should have their operators on the left side of
+        #   the line instead of the right side.
+        self.assert_multi_line_lint(
+            '    return attr->name() == srcAttr\n'
+            '        || attr->name() == lowsrcAttr;\n',
+            '')
+        self.assert_multi_line_lint(
+            '    return attr->name() == srcAttr ||\n'
+            '        attr->name() == lowsrcAttr;\n',
+            'Boolean expressions that span multiple lines should have their '
+            'operators on the left side of the line instead of the right side.'
+            '  [whitespace/operators] [4]')
+
+    def test_spacing(self):
+        # 1. Do not place spaces around unary operators.
+        self.assert_multi_line_lint(
+            'i++;',
+            '')
+        self.assert_multi_line_lint(
+            'i ++;',
+            'Extra space for operator  ++;  [whitespace/operators] [4]')
+
+        # 2. Do place spaces around binary and ternary operators.
+        self.assert_multi_line_lint(
+            'y = m * x + b;',
+            '')
+        self.assert_multi_line_lint(
+            'f(a, b);',
+            '')
+        self.assert_multi_line_lint(
+            'c = a | b;',
+            '')
+        self.assert_multi_line_lint(
+            'return condition ? 1 : 0;',
+            '')
+        self.assert_multi_line_lint(
+            'y=m*x+b;',
+            'Missing spaces around =  [whitespace/operators] [4]')
+        self.assert_multi_line_lint(
+            'f(a,b);',
+            'Missing space after ,  [whitespace/comma] [3]')
+        self.assert_multi_line_lint(
+            'c = a|b;',
+            'Missing spaces around |  [whitespace/operators] [3]')
+        # FIXME: We cannot catch this lint error.
+        # self.assert_multi_line_lint(
+        #     'return condition ? 1:0;',
+        #     '')
+
+        # 3. Place spaces between control statements and their parentheses.
+        self.assert_multi_line_lint(
+            '    if (condition)\n'
+            '        doIt();\n',
+            '')
+        self.assert_multi_line_lint(
+            '    if(condition)\n'
+            '        doIt();\n',
+            'Missing space before ( in if(  [whitespace/parens] [5]')
+
+        # 4. Do not place spaces between a function and its parentheses,
+        #    or between a parenthesis and its content.
+        self.assert_multi_line_lint(
+            'f(a, b);',
+            '')
+        self.assert_multi_line_lint(
+            'f (a, b);',
+            'Extra space before ( in function call  [whitespace/parens] [4]')
+        self.assert_multi_line_lint(
+            'f( a, b );',
+            ['Extra space after ( in function call  [whitespace/parens] [4]',
+             'Extra space before )  [whitespace/parens] [2]'])
+
+    def test_line_breaking(self):
+        # 1. Each statement should get its own line.
+        self.assert_multi_line_lint(
+            '    x++;\n'
+            '    y++;\n'
+            '    if (condition);\n'
+            '        doIt();\n',
+            '')
+        self.assert_multi_line_lint(
+            '    if (condition) \\\n'
+            '        doIt();\n',
+            '')
+        self.assert_multi_line_lint(
+            '    x++; y++;',
+            'More than one command on the same line  [whitespace/newline] [4]')
+        self.assert_multi_line_lint(
+            '    if (condition) doIt();\n',
+            'More than one command on the same line in if  [whitespace/parens] [4]')
+
+        # 2. An else statement should go on the same line as a preceding
+        #   close brace if one is present, else it should line up with the
+        #   if statement.
+        self.assert_multi_line_lint(
+            'if (condition) {\n'
+            '    doSomething();\n'
+            '    doSomethingAgain();\n'
+            '} else {\n'
+            '    doSomethingElse();\n'
+            '    doSomethingElseAgain();\n'
+            '}\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '    doSomething();\n'
+            'else\n'
+            '    doSomethingElse();\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '    doSomething();\n'
+            'else {\n'
+            '    doSomethingElse();\n'
+            '    doSomethingElseAgain();\n'
+            '}\n',
+            '')
+        self.assert_multi_line_lint(
+            '#define TEST_ASSERT(expression) do { if (!(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0)\n',
+            '')
+        self.assert_multi_line_lint(
+            '#define TEST_ASSERT(expression) do { if ( !(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0)\n',
+            'Mismatching spaces inside () in if  [whitespace/parens] [5]')
+        # FIXME: currently we only check first conditional, so we cannot detect errors in next ones.
+        # self.assert_multi_line_lint(
+        #     '#define TEST_ASSERT(expression) do { if (!(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0 )\n',
+        #     'Mismatching spaces inside () in if  [whitespace/parens] [5]')
+        self.assert_multi_line_lint(
+            'if (condition) {\n'
+            '    doSomething();\n'
+            '    doSomethingAgain();\n'
+            '}\n'
+            'else {\n'
+            '    doSomethingElse();\n'
+            '    doSomethingElseAgain();\n'
+            '}\n',
+            'An else should appear on the same line as the preceding }  [whitespace/newline] [4]')
+        self.assert_multi_line_lint(
+            'if (condition) doSomething(); else doSomethingElse();\n',
+            ['More than one command on the same line  [whitespace/newline] [4]',
+             'Else clause should never be on same line as else (use 2 lines)  [whitespace/newline] [4]',
+             'More than one command on the same line in if  [whitespace/parens] [4]'])
+        self.assert_multi_line_lint(
+            'if (condition) doSomething(); else {\n'
+            '    doSomethingElse();\n'
+            '}\n',
+            ['More than one command on the same line in if  [whitespace/parens] [4]',
+             'One line control clauses should not use braces.  [whitespace/braces] [4]'])
+
+        # 3. An else if statement should be written as an if statement
+        #    when the prior if concludes with a return statement.
+        self.assert_multi_line_lint(
+            'if (motivated) {\n'
+            '    if (liquid)\n'
+            '        return money;\n'
+            '} else if (tired)\n'
+            '    break;\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '    doSomething();\n'
+            'else if (otherCondition)\n'
+            '    doSomethingElse();\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '    doSomething();\n'
+            'else\n'
+            '    doSomethingElse();\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '    returnValue = foo;\n'
+            'else if (otherCondition)\n'
+            '    returnValue = bar;\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '    returnValue = foo;\n'
+            'else\n'
+            '    returnValue = bar;\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '    doSomething();\n'
+            'else if (liquid)\n'
+            '    return money;\n'
+            'else if (broke)\n'
+            '    return favor;\n'
+            'else\n'
+            '    sleep(28800);\n',
+            '')
+        self.assert_multi_line_lint(
+            'if (liquid) {\n'
+            '    prepare();\n'
+            '    return money;\n'
+            '} else if (greedy) {\n'
+            '    keep();\n'
+            '    return nothing;\n'
+            '}\n',
+            'An else if statement should be written as an if statement when the '
+            'prior "if" concludes with a return, break, continue or goto statement.'
+            '  [readability/control_flow] [4]')
+        self.assert_multi_line_lint(
+            '    if (stupid) {\n'
+            'infiniteLoop:\n'
+            '        goto infiniteLoop;\n'
+            '    } else if (evil)\n'
+            '        goto hell;\n',
+            'An else if statement should be written as an if statement when the '
+            'prior "if" concludes with a return, break, continue or goto statement.'
+            '  [readability/control_flow] [4]')
+        self.assert_multi_line_lint(
+            'if (liquid)\n'
+            '{\n'
+            '    prepare();\n'
+            '    return money;\n'
+            '}\n'
+            'else if (greedy)\n'
+            '    keep();\n',
+            ['This { should be at the end of the previous line  [whitespace/braces] [4]',
+            'An else should appear on the same line as the preceding }  [whitespace/newline] [4]',
+            'An else if statement should be written as an if statement when the '
+            'prior "if" concludes with a return, break, continue or goto statement.'
+            '  [readability/control_flow] [4]'])
+        self.assert_multi_line_lint(
+            'if (gone)\n'
+            '    return;\n'
+            'else if (here)\n'
+            '    go();\n',
+            'An else if statement should be written as an if statement when the '
+            'prior "if" concludes with a return, break, continue or goto statement.'
+            '  [readability/control_flow] [4]')
+        self.assert_multi_line_lint(
+            'if (gone)\n'
+            '    return;\n'
+            'else\n'
+            '    go();\n',
+            'An else statement can be removed when the prior "if" concludes '
+            'with a return, break, continue or goto statement.'
+            '  [readability/control_flow] [4]')
+        self.assert_multi_line_lint(
+            'if (motivated) {\n'
+            '    prepare();\n'
+            '    continue;\n'
+            '} else {\n'
+            '    cleanUp();\n'
+            '    break;\n'
+            '}\n',
+            'An else statement can be removed when the prior "if" concludes '
+            'with a return, break, continue or goto statement.'
+            '  [readability/control_flow] [4]')
+        self.assert_multi_line_lint(
+            'if (tired)\n'
+            '    break;\n'
+            'else {\n'
+            '    prepare();\n'
+            '    continue;\n'
+            '}\n',
+            'An else statement can be removed when the prior "if" concludes '
+            'with a return, break, continue or goto statement.'
+            '  [readability/control_flow] [4]')
+
+    def test_braces(self):
+        # 1. Function definitions: place each brace on its own line.
+        self.assert_multi_line_lint(
+            'int main()\n'
+            '{\n'
+            '    doSomething();\n'
+            '}\n',
+            '')
+        self.assert_multi_line_lint(
+            'int main() {\n'
+            '    doSomething();\n'
+            '}\n',
+            'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
+
+        # 2. Other braces: place the open brace on the line preceding the
+        #    code block; place the close brace on its own line.
+        self.assert_multi_line_lint(
+            'class MyClass {\n'
+            '    int foo;\n'
+            '};\n',
+            '')
+        self.assert_multi_line_lint(
+            'namespace WebCore {\n'
+            'int foo;\n'
+            '};\n',
+            '')
+        self.assert_multi_line_lint(
+            'for (int i = 0; i < 10; i++) {\n'
+            '    DoSomething();\n'
+            '};\n',
+            '')
+        self.assert_multi_line_lint(
+            'class MyClass\n'
+            '{\n'
+            '    int foo;\n'
+            '};\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '{\n'
+            '    int foo;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'for (int i = 0; i < 10; i++)\n'
+            '{\n'
+            '    int foo;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'while (true)\n'
+            '{\n'
+            '    int foo;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'foreach (Foo* foo, foos)\n'
+            '{\n'
+            '    int bar;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'switch (type)\n'
+            '{\n'
+            'case foo: return;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'if (condition)\n'
+            '{\n'
+            '    int foo;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'for (int i = 0; i < 10; i++)\n'
+            '{\n'
+            '    int foo;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'while (true)\n'
+            '{\n'
+            '    int foo;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'switch (type)\n'
+            '{\n'
+            'case foo: return;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+        self.assert_multi_line_lint(
+            'else if (type)\n'
+            '{\n'
+            'case foo: return;\n'
+            '}\n',
+            'This { should be at the end of the previous line  [whitespace/braces] [4]')
+
+        # 3. One-line control clauses should not use braces unless
+        #    comments are included or a single statement spans multiple
+        #    lines.
+        self.assert_multi_line_lint(
+            'if (true) {\n'
+            '    int foo;\n'
+            '}\n',
+            'One line control clauses should not use braces.  [whitespace/braces] [4]')
+
+        self.assert_multi_line_lint(
+            'for (; foo; bar) {\n'
+            '    int foo;\n'
+            '}\n',
+            'One line control clauses should not use braces.  [whitespace/braces] [4]')
+
+        self.assert_multi_line_lint(
+            'foreach (foo, foos) {\n'
+            '    int bar;\n'
+            '}\n',
+            'One line control clauses should not use braces.  [whitespace/braces] [4]')
+
+        self.assert_multi_line_lint(
+            'while (true) {\n'
+            '    int foo;\n'
+            '}\n',
+            'One line control clauses should not use braces.  [whitespace/braces] [4]')
+
+        self.assert_multi_line_lint(
+            'if (true)\n'
+            '    int foo;\n'
+            'else {\n'
+            '    int foo;\n'
+            '}\n',
+            'One line control clauses should not use braces.  [whitespace/braces] [4]')
+
+        self.assert_multi_line_lint(
+            'if (true) {\n'
+            '    int foo;\n'
+            '} else\n'
+            '    int foo;\n',
+            'One line control clauses should not use braces.  [whitespace/braces] [4]')
+
+        self.assert_multi_line_lint(
+            'if (true) {\n'
+            '    // Some comment\n'
+            '    int foo;\n'
+            '}\n',
+            '')
+
+        self.assert_multi_line_lint(
+            'if (true) {\n'
+            '    myFunction(reallyLongParam1, reallyLongParam2,\n'
+            '               reallyLongParam3);\n'
+            '}\n',
+            '')
+
+        # 4. Control clauses without a body should use empty braces.
+        self.assert_multi_line_lint(
+            'for ( ; current; current = current->next) { }\n',
+            '')
+        self.assert_multi_line_lint(
+            'for ( ; current;\n'
+            '     current = current->next) {}\n',
+            '')
+        self.assert_multi_line_lint(
+            'for ( ; current; current = current->next);\n',
+            'Semicolon defining empty statement for this loop. Use { } instead.  [whitespace/semicolon] [5]')
+        self.assert_multi_line_lint(
+            'while (true);\n',
+            'Semicolon defining empty statement for this loop. Use { } instead.  [whitespace/semicolon] [5]')
+        self.assert_multi_line_lint(
+            '} while (true);\n',
+            '')
+
+    def test_null_false_zero(self):
+        # 1. In C++, the null pointer value should be written as 0. In C,
+        #    it should be written as NULL. In Objective-C and Objective-C++,
+        #    follow the guideline for C or C++, respectively, but use nil to
+        #    represent a null Objective-C object.
+        self.assert_lint(
+            'functionCall(NULL)',
+            'Use 0 instead of NULL.'
+            '  [readability/null] [5]',
+            'foo.cpp')
+        self.assert_lint(
+            "// Don't use NULL in comments since it isn't in code.",
+            'Use 0 instead of NULL.'
+            '  [readability/null] [4]',
+            'foo.cpp')
+        self.assert_lint(
+            '"A string with NULL" // and a comment with NULL is tricky to flag correctly in cpp_style.',
+            'Use 0 instead of NULL.'
+            '  [readability/null] [4]',
+            'foo.cpp')
+        self.assert_lint(
+            '"A string containing NULL is ok"',
+            '',
+            'foo.cpp')
+        self.assert_lint(
+            'if (aboutNULL)',
+            '',
+            'foo.cpp')
+        self.assert_lint(
+            'myVariable = NULLify',
+            '',
+            'foo.cpp')
+        # Make sure that the NULL check does not apply to C and Objective-C files.
+        self.assert_lint(
+            'functionCall(NULL)',
+            '',
+            'foo.c')
+        self.assert_lint(
+            'functionCall(NULL)',
+            '',
+            'foo.m')
+
+        # Make sure that the NULL check does not apply to g_object_{set,get}
+        self.assert_lint(
+            'g_object_get(foo, "prop", &bar, NULL);',
+            '')
+        self.assert_lint(
+            'g_object_set(foo, "prop", bar, NULL);',
+            '')
+
+        # 2. C++ and C bool values should be written as true and
+        #    false. Objective-C BOOL values should be written as YES and NO.
+        # FIXME: Implement this.
+
+        # 3. Tests for true/false, null/non-null, and zero/non-zero should
+        #    all be done without equality comparisons.
+        self.assert_lint(
+            'if (count == 0)',
+            'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.'
+            '  [readability/comparison_to_zero] [5]')
+        self.assert_lint_one_of_many_errors_re(
+            'if (string != NULL)',
+            r'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons\.')
+        self.assert_lint(
+            'if (condition == true)',
+            'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.'
+            '  [readability/comparison_to_zero] [5]')
+        self.assert_lint(
+            'if (myVariable != /* Why would anyone put a comment here? */ false)',
+            'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.'
+            '  [readability/comparison_to_zero] [5]')
+
+        self.assert_lint(
+            'if (0 /* This comment also looks odd to me. */ != aLongerVariableName)',
+            'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.'
+            '  [readability/comparison_to_zero] [5]')
+        self.assert_lint_one_of_many_errors_re(
+            'if (NULL == thisMayBeNull)',
+            r'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons\.')
+        self.assert_lint(
+            'if (true != anotherCondition)',
+            'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.'
+            '  [readability/comparison_to_zero] [5]')
+        self.assert_lint(
+            'if (false == myBoolValue)',
+            'Tests for true/false, null/non-null, and zero/non-zero should all be done without equality comparisons.'
+            '  [readability/comparison_to_zero] [5]')
+
+        self.assert_lint(
+            'if (fontType == trueType)',
+            '')
+        self.assert_lint(
+            'if (othertrue == fontType)',
+            '')
+
+    def test_using_std(self):
+        self.assert_lint(
+            'using std::min;',
+            "Use 'using namespace std;' instead of 'using std::min;'."
+            "  [build/using_std] [4]",
+            'foo.cpp')
+
+    def test_max_macro(self):
+        self.assert_lint(
+            'int i = MAX(0, 1);',
+            '',
+            'foo.c')
+
+        self.assert_lint(
+            'int i = MAX(0, 1);',
+            'Use std::max() or std::max<type>() instead of the MAX() macro.'
+            '  [runtime/max_min_macros] [4]',
+            'foo.cpp')
+
+        self.assert_lint(
+            'inline int foo() { return MAX(0, 1); }',
+            'Use std::max() or std::max<type>() instead of the MAX() macro.'
+            '  [runtime/max_min_macros] [4]',
+            'foo.h')
+
+    def test_min_macro(self):
+        self.assert_lint(
+            'int i = MIN(0, 1);',
+            '',
+            'foo.c')
+
+        self.assert_lint(
+            'int i = MIN(0, 1);',
+            'Use std::min() or std::min<type>() instead of the MIN() macro.'
+            '  [runtime/max_min_macros] [4]',
+            'foo.cpp')
+
+        self.assert_lint(
+            'inline int foo() { return MIN(0, 1); }',
+            'Use std::min() or std::min<type>() instead of the MIN() macro.'
+            '  [runtime/max_min_macros] [4]',
+            'foo.h')
+
+    def test_names(self):
+        name_error_message = " is incorrectly named. Don't use underscores in your identifier names.  [readability/naming] [4]"
+
+        # Basic cases from WebKit style guide.
+        self.assert_lint('struct Data;', '')
+        self.assert_lint('size_t bufferSize;', '')
+        self.assert_lint('class HTMLDocument;', '')
+        self.assert_lint('String mimeType();', '')
+        self.assert_lint('size_t buffer_size;',
+                         'buffer_size' + name_error_message)
+        self.assert_lint('short m_length;', '')
+        self.assert_lint('short _length;',
+                         '_length' + name_error_message)
+        self.assert_lint('short length_;',
+                         'length_' + name_error_message)
+
+        # Pointers, references, functions, templates, and adjectives.
+        self.assert_lint('char* under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('const int UNDER_SCORE;',
+                         'UNDER_SCORE' + name_error_message)
+        self.assert_lint('static inline const char const& const under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('WebCore::RenderObject* under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('int func_name();',
+                         'func_name' + name_error_message)
+        self.assert_lint('RefPtr<RenderObject*> under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('WTF::Vector<WTF::RefPtr<const RenderObject* const> > under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('int under_score[];',
+                         'under_score' + name_error_message)
+        self.assert_lint('struct dirent* under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('long under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('long long under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('long double under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('long long int under_score;',
+                         'under_score' + name_error_message)
+
+        # Declarations in control statement.
+        self.assert_lint('if (int under_score = 42) {',
+                         'under_score' + name_error_message)
+        self.assert_lint('else if (int under_score = 42) {',
+                         'under_score' + name_error_message)
+        self.assert_lint('for (int under_score = 42; cond; i++) {',
+                         'under_score' + name_error_message)
+        self.assert_lint('while (foo & under_score = bar) {',
+                         'under_score' + name_error_message)
+        self.assert_lint('for (foo * under_score = p; cond; i++) {',
+                         'under_score' + name_error_message)
+        self.assert_lint('for (foo * under_score; cond; i++) {',
+                         'under_score' + name_error_message)
+        self.assert_lint('while (foo & value_in_thirdparty_library) {', '')
+        self.assert_lint('while (foo * value_in_thirdparty_library) {', '')
+        self.assert_lint('if (mli && S_OK == mli->foo()) {', '')
+
+        # More member variables and functions.
+        self.assert_lint('int SomeClass::s_validName', '')
+        self.assert_lint('int m_under_score;',
+                         'm_under_score' + name_error_message)
+        self.assert_lint('int SomeClass::s_under_score = 0;',
+                         'SomeClass::s_under_score' + name_error_message)
+        self.assert_lint('int SomeClass::under_score = 0;',
+                         'SomeClass::under_score' + name_error_message)
+
+        # Other statements.
+        self.assert_lint('return INT_MAX;', '')
+        self.assert_lint('return_t under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('goto under_score;',
+                         'under_score' + name_error_message)
+        self.assert_lint('delete static_cast<Foo*>(p);', '')
+
+        # Multiple variables in one line.
+        self.assert_lint('void myFunction(int variable1, int another_variable);',
+                         'another_variable' + name_error_message)
+        self.assert_lint('int variable1, another_variable;',
+                         'another_variable' + name_error_message)
+        self.assert_lint('int first_variable, secondVariable;',
+                         'first_variable' + name_error_message)
+        self.assert_lint('void my_function(int variable_1, int variable_2);',
+                         ['my_function' + name_error_message,
+                          'variable_1' + name_error_message,
+                          'variable_2' + name_error_message])
+        self.assert_lint('for (int variable_1, variable_2;;) {',
+                         ['variable_1' + name_error_message,
+                          'variable_2' + name_error_message])
+
+        # There is an exception for op code functions but only in the JavaScriptCore directory.
+        self.assert_lint('void this_op_code(int var1, int var2)', '', 'JavaScriptCore/foo.cpp')
+        self.assert_lint('void this_op_code(int var1, int var2)', 'this_op_code' + name_error_message)
+
+        # GObject requires certain magical names in class declarations.
+        self.assert_lint('void webkit_dom_object_init();', '')
+        self.assert_lint('void webkit_dom_object_class_init();', '')
+
+        # The GTK+ APIs use GTK+ naming style, which includes lower-cased, _-separated values.
+        self.assert_lint('void this_is_a_gtk_style_name(int var1, int var2)', '', 'WebKit/gtk/webkit/foo.cpp')
+
+        # There is an exception for some unit tests that begin with "tst_".
+        self.assert_lint('void tst_QWebFrame::arrayObjectEnumerable(int var1, int var2)', '')
+
+        # The Qt API uses names that begin with "qt_".
+        self.assert_lint('void QTFrame::qt_drt_is_awesome(int var1, int var2)', '')
+        self.assert_lint('void qt_drt_is_awesome(int var1, int var2);', '')
+
+        # const_iterator is allowed as well.
+        self.assert_lint('typedef VectorType::const_iterator const_iterator;', '')
+
+
+    def test_comments(self):
+        # A comment at the beginning of a line is ok.
+        self.assert_lint('// comment', '')
+        self.assert_lint('    // comment', '')
+
+        self.assert_lint('}  // namespace WebCore',
+                         'One space before end of line comments'
+                         '  [whitespace/comments] [5]')
+
+    def test_other(self):
+        # FIXME: Implement this.
+        pass
+
+
+class CppProcessorTest(unittest.TestCase):
+
+    """Tests CppProcessor class."""
+
+    def mock_handle_style_error(self):
+        pass
+
+    def _processor(self):
+        return CppProcessor("foo", "h", self.mock_handle_style_error, 3)
+
+    def test_init(self):
+        """Test __init__ constructor."""
+        processor = self._processor()
+        self.assertEquals(processor.file_extension, "h")
+        self.assertEquals(processor.file_path, "foo")
+        self.assertEquals(processor.handle_style_error, self.mock_handle_style_error)
+        self.assertEquals(processor.verbosity, 3)
+
+    def test_eq(self):
+        """Test __eq__ equality function."""
+        processor1 = self._processor()
+        processor2 = self._processor()
+
+        # == calls __eq__.
+        self.assertTrue(processor1 == processor2)
+
+        def mock_handle_style_error2(self):
+            pass
+
+        # Verify that a difference in any argument cause equality to fail.
+        processor = CppProcessor("foo", "h", self.mock_handle_style_error, 3)
+        self.assertFalse(processor == CppProcessor("bar", "h", self.mock_handle_style_error, 3))
+        self.assertFalse(processor == CppProcessor("foo", "c", self.mock_handle_style_error, 3))
+        self.assertFalse(processor == CppProcessor("foo", "h", mock_handle_style_error2, 3))
+        self.assertFalse(processor == CppProcessor("foo", "h", self.mock_handle_style_error, 4))
+
+    def test_ne(self):
+        """Test __ne__ inequality function."""
+        processor1 = self._processor()
+        processor2 = self._processor()
+
+        # != 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(processor1 != processor2)
+
+
+def tearDown():
+    """A global check to make sure all error-categories have been tested.
+
+    The main tearDown() routine is the only code we can guarantee will be
+    run after all other tests have been executed.
+    """
+    try:
+        if _run_verifyallcategoriesseen:
+            ErrorCollector(None).verify_all_categories_are_seen()
+    except NameError:
+        # If nobody set the global _run_verifyallcategoriesseen, then
+        # we assume we shouldn't run the test
+        pass
+
+if __name__ == '__main__':
+    import sys
+    # We don't want to run the verify_all_categories_are_seen() test unless
+    # we're running the full test suite: if we only run one test,
+    # obviously we're not going to see all the error categories.  So we
+    # only run verify_all_categories_are_seen() when no commandline flags
+    # are passed in.
+    global _run_verifyallcategoriesseen
+    _run_verifyallcategoriesseen = (len(sys.argv) == 1)
+
+    unittest.main()
diff --git a/WebKitTools/Scripts/webkitpy/style/processors/text.py b/WebKitTools/Scripts/webkitpy/style/processors/text.py
new file mode 100644
index 0000000..307e5b8
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/processors/text.py
@@ -0,0 +1,56 @@
+# Copyright (C) 2009 Google 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:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# 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.
+
+"""Checks WebKit style for text files."""
+
+
+class TextProcessor(object):
+
+    """Processes text lines for checking style."""
+
+    def __init__(self, file_path, handle_style_error):
+        self.file_path = file_path
+        self.handle_style_error = handle_style_error
+
+    def process(self, lines):
+        lines = (["// adjust line numbers to make the first line 1."] + lines)
+
+        # FIXME: share with cpp_style.
+        for line_number, line in enumerate(lines):
+            if "\t" in line:
+                self.handle_style_error(line_number,
+                                        "whitespace/tab", 5,
+                                        "Line contains tab character.")
+
+
+# FIXME: Remove this function (requires refactoring unit tests).
+def process_file_data(filename, lines, error):
+    processor = TextProcessor(filename, error)
+    processor.process(lines)
+
diff --git a/WebKitTools/Scripts/webkitpy/style/processors/text_unittest.py b/WebKitTools/Scripts/webkitpy/style/processors/text_unittest.py
new file mode 100644
index 0000000..62f825b
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/processors/text_unittest.py
@@ -0,0 +1,94 @@
+#!/usr/bin/python
+# Copyright (C) 2009 Google Inc. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# 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 text_style.py."""
+
+import unittest
+
+import text as text_style
+from text import TextProcessor
+
+class TextStyleTestCase(unittest.TestCase):
+    """TestCase for text_style.py"""
+
+    def assertNoError(self, lines):
+        """Asserts that the specified lines has no errors."""
+        self.had_error = False
+
+        def error_for_test(line_number, category, confidence, message):
+            """Records if an error occurs."""
+            self.had_error = True
+
+        text_style.process_file_data('', lines, error_for_test)
+        self.assert_(not self.had_error, '%s should not have any errors.' % lines)
+
+    def assertError(self, lines, expected_line_number):
+        """Asserts that the specified lines has an error."""
+        self.had_error = False
+
+        def error_for_test(line_number, category, confidence, message):
+            """Checks if the expected error occurs."""
+            self.assertEquals(expected_line_number, line_number)
+            self.assertEquals('whitespace/tab', category)
+            self.had_error = True
+
+        text_style.process_file_data('', lines, error_for_test)
+        self.assert_(self.had_error, '%s should have an error [whitespace/tab].' % lines)
+
+
+    def test_no_error(self):
+        """Tests for no error cases."""
+        self.assertNoError([''])
+        self.assertNoError(['abc def', 'ggg'])
+
+
+    def test_error(self):
+        """Tests for error cases."""
+        self.assertError(['2009-12-16\tKent Tamura\t<tkent@chromium.org>'], 1)
+        self.assertError(['2009-12-16 Kent Tamura <tkent@chromium.org>',
+                          '',
+                          '\tReviewed by NOBODY.'], 3)
+
+
+class TextProcessorTest(unittest.TestCase):
+
+    """Tests TextProcessor class."""
+
+    def mock_handle_style_error(self):
+        pass
+
+    def test_init(self):
+        """Test __init__ constructor."""
+        processor = TextProcessor("foo.txt", self.mock_handle_style_error)
+        self.assertEquals(processor.file_path, "foo.txt")
+        self.assertEquals(processor.handle_style_error, self.mock_handle_style_error)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/WebKitTools/Scripts/webkitpy/style/unittests.py b/WebKitTools/Scripts/webkitpy/style/unittests.py
new file mode 100644
index 0000000..11c10e7
--- /dev/null
+++ b/WebKitTools/Scripts/webkitpy/style/unittests.py
@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Apple Computer, Inc. ("Apple") nor the names of
+# its contributors may be used to endorse or promote products derived
+# from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# 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.
+
+"""Runs style package unit tests."""
+
+# This module is imported by test-webkitpy.
+
+import sys
+import unittest
+
+from checker_unittest import *
+from error_handlers_unittest import *
+from processors.cpp_unittest import *
+from processors.text_unittest import *