cpplint_unittest.py

#!/usr/bin/env 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 cpplint.py."""

# TODO(google): Add a good test that tests UpdateIncludeState.

import codecs
import os
import platform
import random
import re
import shutil
import subprocess
import sys
import tempfile

import pytest

import cpplint


def codecs_latin_encode(x):
    return codecs.latin_1_encode(x)[0]


# This class works as an error collector and replaces cpplint.Error
# function for the unit tests.  We also verify each category we see
# is in cpplint._ERROR_CATEGORIES, to help keep that list up to date.
class ErrorCollector:
    # These are a global list, covering all categories seen ever.
    _ERROR_CATEGORIES = cpplint._ERROR_CATEGORIES
    _SEEN_ERROR_CATEGORIES: set[str] = set()

    def __init__(self, assert_fn):
        """assert_fn: a function to call when we notice a problem."""
        self._assert_fn = assert_fn
        self._errors = []
        cpplint.ResetNolintSuppressions()

    def __call__(self, filename, linenum, category, confidence, message):
        self._assert_fn(
            category in self._ERROR_CATEGORIES,
            'Message "%s" has category "%s",'
            " which is not in _ERROR_CATEGORIES" % (message, category),
        )
        self._SEEN_ERROR_CATEGORIES.add(category)
        if cpplint._ShouldPrintError(category, confidence, filename, linenum):
            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.
        return self._errors  # Let's give a list if there is more than one.

    def ResultList(self):
        return self._errors

    def VerifyAllCategoriesAreSeen(self):
        """Fails if there's a category in _ERROR_CATEGORIES~_SEEN_ERROR_CATEGORIES.

        This should only be called after all tests are run, so
        _SEEN_ERROR_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._ERROR_CATEGORIES:
            if category not in self._SEEN_ERROR_CATEGORIES:
                sys.exit('FATAL ERROR: There are no tests for category "%s"' % category)

    def RemoveIfPresent(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):
        # wrap list to allow "with open(mock)"
        class EnterableList(list):
            def __enter__(self):
                return self

            def __exit__(self, type, value, tb):  # noqa: A002
                return self

        self.mock_file = EnterableList(mock_file)

    def open(
        self,  # pylint: disable=C6409
        unused_filename,
        unused_mode,
        unused_encoding,
        _,
    ):
        return self.mock_file


class CpplintTestBase:
    """Provides some useful helper functions for cpplint tests."""

    def setUp(self):
        # Allow subclasses to cheat os.path.abspath called in FileInfo class.
        self.os_path_abspath_orig = os.path.abspath

    def tearDown(self):
        os.path.abspath = self.os_path_abspath_orig

    def assertTrue(self, condition, message=""):
        assert condition, message

    # Perform lint on single line of input and return the error message.
    def PerformSingleLineLint(self, code):
        error_collector = ErrorCollector(self.assertTrue)
        lines = code.split("\n")
        cpplint.RemoveMultiLineComments("foo.h", lines, error_collector)
        clean_lines = cpplint.CleansedLines(lines)
        include_state = cpplint._IncludeState()
        function_state = cpplint._FunctionState()
        nesting_state = cpplint.NestingState()
        cpplint.ProcessLine(
            "foo.cc",
            "cc",
            clean_lines,
            0,
            include_state,
            function_state,
            nesting_state,
            error_collector,
        )
        # Single-line lint tests are allowed to fail the 'unlintable function'
        # check.
        error_collector.RemoveIfPresent("Lint failed to find start of function body.")
        return error_collector.Results()

    # Perform lint over multiple lines and return the error message.
    def PerformMultiLineLint(self, code):
        error_collector = ErrorCollector(self.assertTrue)
        lines = code.split("\n")
        cpplint.RemoveMultiLineComments("foo.h", lines, error_collector)
        lines = cpplint.CleansedLines(lines)
        nesting_state = cpplint.NestingState()
        for i in range(lines.NumLines()):
            nesting_state.Update("foo.h", lines, i, error_collector)
            cpplint.CheckStyle("foo.h", lines, i, "h", nesting_state, error_collector)
            cpplint.CheckForNonStandardConstructs("foo.h", lines, i, nesting_state, error_collector)
        return error_collector.Results()

    # Similar to PerformMultiLineLint, but calls CheckLanguage instead of
    # CheckForNonStandardConstructs
    def PerformLanguageRulesCheck(self, file_name, code):
        error_collector = ErrorCollector(self.assertTrue)
        include_state = cpplint._IncludeState()
        nesting_state = cpplint.NestingState()
        lines = code.split("\n")
        cpplint.RemoveMultiLineComments(file_name, lines, error_collector)
        lines = cpplint.CleansedLines(lines)
        ext = file_name[file_name.rfind(".") + 1 :]
        for i in range(lines.NumLines()):
            cpplint.CheckLanguage(
                file_name, lines, i, ext, include_state, nesting_state, error_collector
            )
        return error_collector.Results()

    def PerformFunctionLengthsCheck(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 cpplint functions.

        Establishes an error collector and invokes the function length checking
        function following cpplint's pattern.

        Args:
          code: C++ source code expected to generate a warning message.

        Returns:
          The accumulated errors.
        """
        file_name = "foo.cc"
        error_collector = ErrorCollector(self.assertTrue)
        function_state = cpplint._FunctionState()
        lines = code.split("\n")
        cpplint.RemoveMultiLineComments(file_name, lines, error_collector)
        lines = cpplint.CleansedLines(lines)
        for i in range(lines.NumLines()):
            cpplint.CheckForFunctionLengths(file_name, lines, i, function_state, error_collector)
        return error_collector.Results()

    def PerformIncludeWhatYouUse(self, code, filename="foo.h", io=codecs):
        # First, build up the include state.
        error_collector = ErrorCollector(self.assertTrue)
        include_state = cpplint._IncludeState()
        nesting_state = cpplint.NestingState()
        lines = code.split("\n")
        cpplint.RemoveMultiLineComments(filename, lines, error_collector)
        lines = cpplint.CleansedLines(lines)
        for i in range(lines.NumLines()):
            cpplint.CheckLanguage(
                filename, lines, i, ".h", include_state, nesting_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.
        cpplint.CheckForIncludeWhatYouUse(filename, lines, include_state, error_collector, io)
        return error_collector.Results()

    # Perform lint and make sure one of the errors is what we want
    def TestLintContains(self, code, expected_message):
        assert expected_message in self.PerformSingleLineLint(code)

    def TestLintNotContains(self, code, expected_message):
        assert expected_message not in self.PerformSingleLineLint(code)

    # Perform lint and compare the error message with "expected_message".
    def TestLint(self, code, expected_message):
        assert expected_message == self.PerformSingleLineLint(code)

    def TestMultiLineLint(self, code, expected_message):
        assert expected_message == self.PerformMultiLineLint(code)

    def TestMultiLineLintRE(self, code, expected_message_re):
        message = self.PerformMultiLineLint(code)
        assert re.search(expected_message_re, message)

    def TestLanguageRulesCheck(self, file_name, code, expected_message):
        assert expected_message == self.PerformLanguageRulesCheck(file_name, code)

    def TestIncludeWhatYouUse(self, code, expected_message):
        assert expected_message == self.PerformIncludeWhatYouUse(code)

    def TestBlankLinesCheck(self, lines, start_errors, end_errors):
        for extension in ["c", "cc", "cpp", "cxx", "c++", "cu"]:
            self.doTestBlankLinesCheck(lines, start_errors, end_errors, extension)

    def doTestBlankLinesCheck(self, lines, start_errors, end_errors, extension):
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData("foo." + extension, extension, lines, error_collector)
        assert start_errors == error_collector.Results().count(
            "Redundant blank line at the start of a code block should be deleted.  "
            "[whitespace/blank_line] [2]"
        )
        assert end_errors == error_collector.Results().count(
            "Redundant blank line at the end of a code block should be deleted.  "
            "[whitespace/blank_line] [3]"
        )


class TestCpplint(CpplintTestBase):
    def GetNamespaceResults(self, lines):
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.RemoveMultiLineComments("foo.h", lines, error_collector)
        lines = cpplint.CleansedLines(lines)
        nesting_state = cpplint.NestingState()
        for i in range(lines.NumLines()):
            nesting_state.Update("foo.h", lines, i, error_collector)
            cpplint.CheckForNamespaceIndentation("foo.h", nesting_state, lines, i, error_collector)

        return error_collector.Results()

    def testForwardDeclarationNamespaceIndentation(self):
        lines = ["namespace Test {", "  class ForwardDeclaration;", "}  // namespace Test"]

        results = self.GetNamespaceResults(lines)
        assert results == "Do not indent within a namespace.  [whitespace/indent_namespace] [4]"

    def testNamespaceIndentationForClass(self):
        lines = [
            "namespace Test {",
            "void foo() { }",
            "  class Test {",
            "  };",
            "}  // namespace Test",
        ]

        results = self.GetNamespaceResults(lines)
        assert results == [
            "Do not indent within a namespace.  [whitespace/indent_namespace] [4]",
            "Do not indent within a namespace.  [whitespace/indent_namespace] [4]",
        ]

    def testNamespaceIndentationIndentedParameter(self):
        lines = [
            "namespace Test {",
            "void foo(SuperLongTypeName d = 418,",
            "   SuperLongTypeName e = 2.71) { }",
            "}  // namespace Test",
        ]

        results = self.GetNamespaceResults(lines)
        assert results == ""

    def testNamespaceIndentationMemberInitializerList(self):
        lines = [
            "namespace Opossum {",
            "",
            "Acme::Acme(const std::shared_ptr<const AbstractOperator> left,",
            "           const std::shared_ptr<const AbstractOperator> nigh)",
            "    : _left(left), _behind(nigh) {}",
            "",
            "}  // namespace Opossum",
        ]
        assert self.GetNamespaceResults(lines) == ""

        # Multiline member initializer List
        lines = [
            "namespace Rosenfield {",
            "class Crush : public Habitual {",
            " public:",
            "  Crush() : _a(1),",
            "            _b(2)",
            "       {}",
            "};",
            "}  // namespace Rosenfield",
        ]
        assert self.GetNamespaceResults(lines) == ""

        # Same line as constructor declaration
        lines = [
            "namespace Boucher {",
            "   X::X() : _s(2) {}",
            "   A::A() : _e(12) {",
        ]
        assert self.GetNamespaceResults(lines) == [
            "Do not indent within a namespace.  [whitespace/indent_namespace] [4]",
            "Do not indent within a namespace.  [whitespace/indent_namespace] [4]",
        ]

        # Definition on indented line
        lines = [
            "namespace Store {",
            "",
            "   Color::Color() : my_name_is('b')",
            "       this_is_true(true) {",
        ]
        assert (
            self.GetNamespaceResults(lines)
            == "Do not indent within a namespace.  [whitespace/indent_namespace] [4]"
        )

    def testNestingInNamespace(self):
        lines = [
            "namespace Test {",
            "struct OuterClass {",
            "  struct NoFalsePositivesHere;",
            "  struct NoFalsePositivesHere member_variable;",
            "};",
            "void foo() {",
            "  const int no_positives_eh = 418;",
            "}",
            "}  // namespace Test",
        ]

        results = self.GetNamespaceResults(lines)
        assert results == ""

    # Test get line width.
    def testGetLineWidth(self):
        assert cpplint.GetLineWidth("") == 0
        assert cpplint.GetLineWidth("x" * 10) == 10
        assert cpplint.GetLineWidth("都|道|府|県|支庁") == 16
        assert cpplint.GetLineWidth("都|道|府|県|支庁") == 16
        assert cpplint.GetLineWidth("d𝐱/dt" + "f : t ⨯ 𝐱 → ℝ" + "t ⨯ 𝐱 → ℝ") == 5 + 13 + 9

    def testGetTextInside(self):
        assert cpplint._GetTextInside("fun()", r"fun\(") == ""
        assert cpplint._GetTextInside("f(x, y)", r"f\(") == "x, y"
        assert cpplint._GetTextInside("printf(a(), b(c()))", r"printf\(") == "a(), b(c())"
        assert cpplint._GetTextInside("f[x, y{}]", r"f\[") == "x, y{}"
        assert None is cpplint._GetTextInside("f[a, b(}]", r"f\[")
        assert None is cpplint._GetTextInside("f[x, y]", r"f\(")
        assert cpplint._GetTextInside("f(x, g(y, h(z, (a + b))))", r"g\(") == "y, h(z, (a + b))"
        assert cpplint._GetTextInside("f(f(f(x)))", r"f\(") == "f(f(x))"
        # Supports multiple lines.
        assert (
            cpplint._GetTextInside("int loop(int x) {\n  return loop(x);\n}\n", r"\{")
            == "\n  return loop(x);\n"
        )
        # '^' matches the beginning of each line.
        assert (
            cpplint._GetTextInside(
                '#include "inl.h"  // skip #define\n'
                "#define A2(x, y) a_inl_(x, y, __LINE__)\n"
                '#define A(x) a_inl_(x, "", __LINE__)\n',
                r"^\s*#define\s*\w+\(",
            )
            == "x, y"
        )

    def testFindNextMultiLineCommentStart(self):
        assert cpplint.FindNextMultiLineCommentStart([""], 0) == 1

        lines = ["a", "b", "/* c"]
        assert cpplint.FindNextMultiLineCommentStart(lines, 0) == 2

        lines = ['char a[] = "/*";']  # not recognized as comment.
        assert cpplint.FindNextMultiLineCommentStart(lines, 0) == 1

    def testFindNextMultiLineCommentEnd(self):
        assert cpplint.FindNextMultiLineCommentEnd([""], 0) == 1
        lines = ["a", "b", " c */"]
        assert cpplint.FindNextMultiLineCommentEnd(lines, 0) == 2

    def testRemoveMultiLineCommentsFromRange(self):
        lines = ["a", "  /* comment ", " * still comment", " comment */   ", "b"]
        cpplint.RemoveMultiLineCommentsFromRange(lines, 1, 4)
        assert lines == ["a", "/**/", "/**/", "/**/", "b"]

    def testSpacesAtEndOfLine(self):
        self.TestLint(
            "// Hello there ",
            "Line ends in whitespace.  Consider deleting these extra spaces."
            "  [whitespace/end_of_line] [4]",
        )

    # Test line length check.
    def testLineLengthCheck(self):
        self.TestLint("// Hello", "")
        self.TestLint(
            "// x" + " x" * 40,
            "Lines should be <= 80 characters long  [whitespace/line_length] [2]",
        )
        self.TestLint(
            "// x" + " x" * 50,
            "Lines should be <= 80 characters long  [whitespace/line_length] [2]",
        )
        self.TestLint("// //some/path/to/f" + ("i" * 100) + "le", "")
        self.TestLint("//   //some/path/to/f" + ("i" * 100) + "le", "")
        self.TestLint(
            "//   //some/path/to/f" + ("i" * 50) + "le and some comments",
            "Lines should be <= 80 characters long  [whitespace/line_length] [2]",
        )
        self.TestLint("// http://g" + ("o" * 100) + "gle.com/", "")
        self.TestLint("//   https://g" + ("o" * 100) + "gle.com/", "")
        self.TestLint(
            "//   https://g" + ("o" * 60) + "gle.com/ and some comments",
            "Lines should be <= 80 characters long  [whitespace/line_length] [2]",
        )
        self.TestLint("// Read https://g" + ("o" * 60) + "gle.com/", "")
        self.TestLint("// $Id: g" + ("o" * 80) + "gle.cc#1 $", "")
        self.TestLint(
            "// $Id: g" + ("o" * 80) + "gle.cc#1",
            "Lines should be <= 80 characters long  [whitespace/line_length] [2]",
        )
        self.TestMultiLineLint(
            'static const char kCStr[] = "g' + ("o" * 50) + 'gle";\n',
            "Lines should be <= 80 characters long  [whitespace/line_length] [2]",
        )
        self.TestMultiLineLint(
            'static const char kRawStr[] = R"(g' + ("o" * 50) + 'gle)";\n', ""
        )  # no warning because raw string content is elided
        self.TestMultiLineLint(
            'static const char kMultiLineRawStr[] = R"(\ng' + ("o" * 80) + 'gle\n)";', ""
        )
        self.TestMultiLineLint(
            "static const char kL" + ("o" * 50) + 'ngIdentifier[] = R"()";\n',
            "Lines should be <= 80 characters long  [whitespace/line_length] [2]",
        )
        self.TestLint("  /// @copydoc " + ("o" * (cpplint._line_length * 2)), "")
        self.TestLint("  /// @copydetails " + ("o" * (cpplint._line_length * 2)), "")
        self.TestLint("  /// @copybrief " + ("o" * (cpplint._line_length * 2)), "")

    # Test error suppression annotations.
    def testErrorSuppression(self):
        # Two errors on same line:
        self.TestLint(
            "long a = (int64_t) 65;",
            [
                "Using C-style cast.  Use static_cast<int64_t>(...) instead"
                "  [readability/casting] [4]",
                "Use int16_t/int64_t/etc, rather than the C type long  [runtime/int] [4]",
            ],
        )
        # One category of error suppressed:
        self.TestLint(
            "long a = (int64_t) 65;  // NOLINT(runtime/int)",
            "Using C-style cast.  Use static_cast<int64_t>(...) instead  [readability/casting] [4]",
        )
        # Two categories of errors suppressed:
        self.TestLint("long a = (int64_t) 65;  // NOLINT(runtime/int,readability/casting)", "")

        # All categories suppressed: (two aliases)
        self.TestLint("long a = (int64_t) 65;  // NOLINT", "")
        self.TestLint("long a = (int64_t) 65;  // NOLINT(*)", "")

        # Linting a C file
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.c",
            "c",
            ["// Copyright 2014 Your Majesty.", "int64_t a = (int64_t) 65;", ""],
            error_collector,
        )
        assert error_collector.Results() == ""

        # Malformed NOLINT directive:
        self.TestLint(
            "long a = 65;  // NOLINT(foo)",
            [
                "Unknown NOLINT error category: foo  [readability/nolint] [5]",
                "Use int16_t/int64_t/etc, rather than the C type long  [runtime/int] [4]",
            ],
        )
        # Irrelevant NOLINT directive has no effect:
        self.TestLint(
            "long a = 65;  // NOLINT(readability/casting)",
            "Use int16_t/int64_t/etc, rather than the C type long  [runtime/int] [4]",
        )
        # NOLINTNEXTLINE silences warning for the next line instead of current line
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTNEXTLINE(whitespace/line_length)",
                "//  ./command" + (" -verbose" * 80),
                "",
            ],
            error_collector,
        )
        assert error_collector.Results() == ""
        # NOLINTNEXTLINE multiple categories silences warning for the next line instead of current
        # line
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTNEXTLINE(runtime/int,readability/casting)",
                "long a = (int64_t) 65;",
                "",
            ],
            error_collector,
        )
        assert error_collector.Results() == ""
        # LINT_C_FILE silences cast warnings for entire file.
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.h",
            "h",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINT(build/header_guard)",
                "int64_t a = (uint64_t) 65;",
                "//  LINT_C_FILE",
                "",
            ],
            error_collector,
        )
        assert error_collector.Results() == ""
        # Vim modes silence cast warnings for entire file.
        for modeline in [
            "vi:filetype=c",
            "vi:sw=8 filetype=c",
            "vi:sw=8 filetype=c ts=8",
            "vi: filetype=c",
            "vi: sw=8 filetype=c",
            "vi: sw=8 filetype=c ts=8",
            "vim:filetype=c",
            "vim:sw=8 filetype=c",
            "vim:sw=8 filetype=c ts=8",
            "vim: filetype=c",
            "vim: sw=8 filetype=c",
            "vim: sw=8 filetype=c ts=8",
            "vim: set filetype=c:",
            "vim: set sw=8 filetype=c:",
            "vim: set sw=8 filetype=c ts=8:",
            "vim: set filetype=c :",
            "vim: set sw=8 filetype=c :",
            "vim: set sw=8 filetype=c ts=8 :",
            "vim: se filetype=c:",
            "vim: se sw=8 filetype=c:",
            "vim: se sw=8 filetype=c ts=8:",
            "vim: se filetype=c :",
            "vim: se sw=8 filetype=c :",
            "vim: se sw=8 filetype=c ts=8 :",
        ]:
            error_collector = ErrorCollector(self.assertTrue)
            cpplint.ProcessFileData(
                "test.h",
                "h",
                [
                    "// Copyright 2014 Your Company.",
                    "// NOLINT(build/header_guard)",
                    "int64_t a = (uint64_t) 65;",
                    "/* Prevent warnings about the modeline",
                    modeline,
                    "*/",
                    "",
                ],
                error_collector,
            )
            assert error_collector.Results() == ""
        # LINT_KERNEL_FILE silences whitespace/tab warnings for entire file.
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.h",
            "h",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINT(build/header_guard)",
                "struct test {",
                "\tint member;",
                "};",
                "//  LINT_KERNEL_FILE",
                "",
            ],
            error_collector,
        )
        assert error_collector.Results() == ""
        # NOLINT, NOLINTNEXTLINE silences the readability/braces warning for "};".
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "#include <iostream>",
                "for (int i = 0; i != 100; ++i) {",
                "  std::cout << i << std::endl;",
                "};  // NOLINT",
                "for (int i = 0; i != 100; ++i) {",
                "  std::cout << i << std::endl;",
                "// NOLINTNEXTLINE",
                "};",
                "//  LINT_KERNEL_FILE",
                "",
            ],
            error_collector,
        )
        assert error_collector.Results() == ""
        # NOLINTBEGIN and silences all warnings after it
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTBEGIN",
                "long a = (int64_t) 65;long a = 65;",
                "//  ./command" + (" -verbose" * 80),
            ],
            error_collector,
        )
        assert error_collector.Results() == ""
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTBEGIN(*)",
                "long a = (int64_t) 65;long a = 65;",
                "//  ./command" + (" -verbose" * 80),
            ],
            error_collector,
        )
        assert error_collector.Results() == ""
        # NOLINTEND will show warnings after that point
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTBEGIN",
                "long a = (int64_t) 65;long a = 65;",
                "// NOLINTEND",
                "//  ./command" + (" -verbose" * 80),
                "",
            ],
            error_collector,
        )
        assert (
            error_collector.Results()
            == "Lines should be <= 80 characters long  [whitespace/line_length] [2]"
        )
        # NOLINTBEGIN(category) silences category warnings after it
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTBEGIN(readability/casting,runtime/int)",
                "long a = (int64_t) 65;",
                "long a = 65;",
                "//  ./command" + (" -verbose" * 80),
                "// NOLINTEND",
                "",
            ],
            error_collector,
        )
        assert (
            error_collector.Results()
            == "Lines should be <= 80 characters long  [whitespace/line_length] [2]"
        )
        # NOLINTEND(category) will generate an error that categories are not supported
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTBEGIN(readability/casting,runtime/int)",
                "long a = (int64_t) 65;",
                "long a = 65;",
                "// NOLINTEND(readability/casting)",
                "",
            ],
            error_collector,
        )
        assert (
            error_collector.Results()
            == "NOLINT categories not supported in block END: readability/casting  "
            "[readability/nolint] [5]"
        )
        # nested NOLINTBEGIN is not allowed
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTBEGIN(readability/casting,runtime/int)",
                "long a = (int64_t) 65;",
                "// NOLINTBEGIN(runtime/int)",
                "long a = 65;",
                "// NOLINTEND(*)",
                "",
            ],
            error_collector,
        )
        assert (
            error_collector.Results()
            == "NONLINT block already defined on line 2  [readability/nolint] [5]"
        )
        # error if NOLINGBEGIN is not ended
        error_collector = ErrorCollector(self.assertTrue)
        cpplint.ProcessFileData(
            "test.cc",
            "cc",
            [
                "// Copyright 2014 Your Company.",
                "// NOLINTBEGIN(readability/casting,runtime/int)",
                "long a = (int64_t) 65;",
                "long a = 65;",
                "",
            ],
            error_collector,
        )
        assert error_collector.Results() == "NONLINT block never ended  [readability/nolint] [5]"
        # error if unmatched NOLINTEND
        self.TestLint("// NOLINTEND", "Not in a NOLINT block  [readability/nolint] [5]")
        self.TestLint("// NOLINTEND(*)", "Not in a NOLINT block  [readability/nolint] [5]")

    # Test Variable Declarations.
    def testVariableDeclarations(self):
        self.TestLint(
            "long a = 65;",
            "Use int16_t/int64_t/etc, rather than the C type long  [runtime/int] [4]",
        )
        self.TestLint("long double b = 65.0;", "")
        self.TestLint(
            "long long aa = 6565;",
            "Use int16_t/int64_t/etc, rather than the C type long  [runtime/int] [4]",
        )

    # Test C-style cast cases.
    def testCStyleCast(self):
        self.TestLint(
            "int a = (int)1.0;",
            "Using C-style cast.  Use static_cast<int>(...) instead  [readability/casting] [4]",
        )
        self.TestLint(
            "int a = (int)-1.0;",
            "Using C-style cast.  Use static_cast<int>(...) instead  [readability/casting] [4]",
        )
        self.TestLint(
            "int *a = (int *)NULL;",
            "Using C-style cast.  Use reinterpret_cast<int *>(...) instead"
            "  [readability/casting] [4]",
        )

        self.TestLint(
            "uint16_t a = (uint16_t)1.0;",
            "Using C-style cast.  Use static_cast<uint16_t>(...) instead"
            "  [readability/casting] [4]",
        )
        self.TestLint(
            "int32_t a = (int32_t)1.0;",
            "Using C-style cast.  Use static_cast<int32_t>(...) instead  [readability/casting] [4]",
        )
        self.TestLint(
            "uint64_t a = (uint64_t)1.0;",
            "Using C-style cast.  Use static_cast<uint64_t>(...) instead"
            "  [readability/casting] [4]",
        )
        self.TestLint(
            "size_t a = (size_t)1.0;",
            "Using C-style cast.  Use static_cast<size_t>(...) instead  [readability/casting] [4]",
        )

        # These shouldn't be recognized casts.
        self.TestLint("u a = (u)NULL;", "")
        self.TestLint("uint a = (uint)NULL;", "")
        self.TestLint("typedef MockCallback<int(int)> CallbackType;", "")
        self.TestLint("scoped_ptr< MockCallback<int(int)> > callback_value;", "")
        self.TestLint("std::function<int(bool)>", "")
        self.TestLint("x = sizeof(int)", "")
        self.TestLint("x = alignof(int)", "")
        self.TestLint("alignas(int) char x[42]", "")
        self.TestLint("alignas(alignof(x)) char y[42]", "")
        self.TestLint("void F(int (func)(int));", "")
        self.TestLint("void F(int (func)(int*));", "")
        self.TestLint("void F(int (Class::member)(int));", "")
        self.TestLint("void F(int (Class::member)(int*));", "")
        self.TestLint("void F(int (Class::member)(int), int param);", "")
        self.TestLint("void F(int (Class::member)(int*), int param);", "")
        self.TestLint("X Class::operator++(int)", "")
        self.TestLint("X Class::operator--(int)", "")

        # These should not be recognized (lambda functions without arg names).
        self.TestLint("[](int/*unused*/) -> bool {", "")
        self.TestLint("[](int /*unused*/) -> bool {", "")
        self.TestLint("auto f = [](MyStruct* /*unused*/)->int {", "")
        self.TestLint("[](int) -> bool {", "")
        self.TestLint("auto f = [](MyStruct*)->int {", "")

        # Cast with brace initializers
        self.TestLint("int64_t{4096} * 1000 * 1000", "")
        self.TestLint("size_t{4096} * 1000 * 1000", "")
        self.TestLint("uint_fast16_t{4096} * 1000 * 1000", "")

        # Brace initializer with templated type
        self.TestMultiLineLint(
            """
        template <typename Type1,
                  typename Type2>
        void Function(int arg1,
                      int arg2) {
          variable &= ~Type1{0} - 1;
        }""",
            "",
        )
        self.TestMultiLineLint(
            """
        template <typename Type>
        class Class {
          void Function() {
            variable &= ~Type{0} - 1;
          }
        };""",
            "",
        )
        self.TestMultiLineLint(
            """
        template <typename Type>
        class Class {
          void Function() {
            variable &= ~Type{0} - 1;
          }
        };""",
            "",
        )
        self.TestMultiLineLint(
            """
        namespace {
        template <typename Type>
        class Class {
          void Function() {
            if (block) {
              variable &= ~Type{0} - 1;
            }
          }
        };
        }""",
            "",
        )

    # Test taking address of casts (runtime/casting)
    def testRuntimeCasting(self):
        error_msg = (
            "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.TestLint("int* x = &static_cast<int*>(foo);", error_msg)
        self.TestLint("int* x = &reinterpret_cast<int *>(foo);", error_msg)
        self.TestLint(
            "int* x = &(int*)foo;",
            [
                "Using C-style cast.  Use reinterpret_cast<int*>(...) "
                "instead  [readability/casting] [4]",
                error_msg,
            ],
        )
        self.TestLint("BudgetBuckets&(BudgetWinHistory::*BucketFn)(void) const;", "")
        self.TestLint("&(*func_ptr)(arg)", "")
        self.TestLint("Compute(arg, &(*func_ptr)(i, j));", "")

        # Alternative error message
        alt_error_msg = (
            "Are you taking an address of something dereferenced "
            "from a cast?  Wrapping the dereferenced expression in "
            "parentheses will make the binding more obvious"
            "  [readability/casting] [4]"
        )
        self.TestLint("int* x = &down_cast<Obj*>(obj)->member_;", alt_error_msg)
        self.TestLint("int* x = &down_cast<Obj*>(obj)[index];", alt_error_msg)
        self.TestLint("int* x = &(down_cast<Obj*>(obj)->member_);", "")
        self.TestLint("int* x = &(down_cast<Obj*>(obj)[index]);", "")
        self.TestLint("int* x = &down_cast<Obj*>(obj)\n->member_;", alt_error_msg)
        self.TestLint("int* x = &(down_cast<Obj*>(obj)\n->member_);", "")

        # It's OK to cast an address.
        self.TestLint("int* x = reinterpret_cast<int *>(&foo);", "")

        # Function pointers returning references should not be confused
        # with taking address of old-style casts.
        self.TestLint("auto x = implicit_cast<string &(*)(int)>(&foo);", "")

    def testRuntimeSelfinit(self):
        self.TestLint(
            "Foo::Foo(Bar r, Bel l) : r_(r_), l_(l_) { }",
            "You seem to be initializing a member variable with itself.  [runtime/init] [4]",
        )
        self.TestLint(
            "Foo::Foo(Bar r, Bel l) : r_(CHECK_NOTNULL(r_)) { }",
            "You seem to be initializing a member variable with itself.  [runtime/init] [4]",
        )
        self.TestLint("Foo::Foo(Bar r, Bel l) : r_(r), l_(l) { }", "")
        self.TestLint("Foo::Foo(Bar r) : r_(r), l_(r_), ll_(l_) { }", "")

    # Test for unnamed arguments in a method.
    def testCheckForUnnamedParams(self):
        self.TestLint("virtual void Func(int*) const;", "")
        self.TestLint("virtual void Func(int*);", "")
        self.TestLint("void Method(char*) {", "")
        self.TestLint("void Method(char*);", "")
        self.TestLint("static void operator delete[](void*) throw();", "")
        self.TestLint("int Method(int);", "")

        self.TestLint("virtual void Func(int* p);", "")
        self.TestLint("void operator delete(void* x) throw();", "")
        self.TestLint("void Method(char* x) {", "")
        self.TestLint("void Method(char* /*x*/) {", "")
        self.TestLint("void Method(char* x);", "")
        self.TestLint("typedef void (*Method)(int32_t x);", "")
        self.TestLint("static void operator delete[](void* x) throw();", "")
        self.TestLint("static void operator delete[](void* /*x*/) throw();", "")

        self.TestLint("X operator++(int);", "")
        self.TestLint("X operator++(int) {", "")
        self.TestLint("X operator--(int);", "")
        self.TestLint("X operator--(int /*unused*/) {", "")
        self.TestLint("MACRO(int);", "")
        self.TestLint("MACRO(func(int));", "")
        self.TestLint("MACRO(arg, func(int));", "")

        self.TestLint("void (*func)(void*);", "")
        self.TestLint("void Func((*func)(void*)) {}", "")
        self.TestLint("template <void Func(void*)> void func();", "")
        self.TestLint("virtual void f(int /*unused*/) {", "")