#!/usr/bin/env python3

#

# 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]",

]

# In a namespace, but not *directly*

lines = [

"namespace Lumi {",

"class Outie {",

" class Innie {",

]

assert self.GetNamespaceResults(lines) == ""

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 {",

"",

"protected 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; constructor on different line from list

lines = [

"namespace Rosenfield {",

"class Crush : public Habitual {",

" public:",

" explicit Crush() : _a(1),",

" _b(2)",

" {}",

"};",

"} // namespace Rosenfield",

]

assert self.GetNamespaceResults(lines) == ""

# Inline + multiline, ends on the same line as a list's end

lines = [

"namespace Humpety {",

"Dumpety::Dumpety(const int a)",

" : number(a),",

" looooooong_attr1(0),",

" looooooong_attr2(0),",

" looooooong_attr3(0),",

" looooooong_attr4(0) {}",

]

assert self.GetNamespaceResults(lines) == ""

# Uniform initialization

lines = [

"namespace Unifor {",

"class MIA {",

' private MIA() : cali({"nia"}),',

" parme({3}),",

' carne{"val", ipsmo}',

" gat(o) {}",

]

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]"

)

# categories for external tools like clang-tidy should be ignored

error_collector = ErrorCollector(self.assertTrue)

cpplint.ProcessFileData(

"test.cc",

"cc",

[

"// Copyright 2026 Space Dot",

"// NOLINTBEGIN(clang-analyzer-core.uninitialized.UndefReturn)",

"long c = 418;",

"// NOLINTEND(clang-analyzer-core.uninitialized.UndefReturn)",

"",

],

error_collector,

)

assert (

error_collector.Results()

== "Use int16_t/int64_t/etc, rather than the C type long [runtime/int] [4]"

)

# 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_);", "")