if sys.version_info < (3,):

return x

else:

# These are a global list, covering all categories seen ever.

_ERROR_CATEGORIES = cpplint._ERROR_CATEGORIES

_SEEN_ERROR_CATEGORIES = {}

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[category] = 1

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.

else:

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.

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):]

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

return self

self.mock_file = EnterableList(mock_file)

def open(self, # pylint: disable=C6409

unused_filename, unused_mode, unused_encoding, _):

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

# 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.

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

self.assertTrue(expected_message in self.PerformSingleLineLint(code))

def TestLintNotContains(self, code, expected_message):

self.assertFalse(expected_message in self.PerformSingleLineLint(code))

# Perform lint and compare the error message with "expected_message".

def TestLint(self, code, expected_message):

self.assertEqual(expected_message, self.PerformSingleLineLint(code))

def TestMultiLineLint(self, code, expected_message):

self.assertEqual(expected_message, self.PerformMultiLineLint(code))

def TestMultiLineLintRE(self, code, expected_message_re):

message = self.PerformMultiLineLint(code)

if not re.search(expected_message_re, message):

self.fail('Message was:\n' + message + 'Expected match to "' +

expected_message_re + '"')

def TestLanguageRulesCheck(self, file_name, code, expected_message):

self.assertEqual(expected_message,

self.PerformLanguageRulesCheck(file_name, code))

def TestIncludeWhatYouUse(self, code, expected_message):

self.assertEqual(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)

self.assertEqual(

start_errors,

error_collector.Results().count(

'Redundant blank line at the start of a code block '

'should be deleted. [whitespace/blank_line] [2]'))

self.assertEqual(

end_errors,

error_collector.Results().count(

'Redundant blank line at the end of a code block '

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)

self.assertEqual(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)

self.assertEqual(results, ['Do not indent within a namespace. '

' [whitespace/indent_namespace] [4]',

'Do not indent within a namespace. '

' [whitespace/indent_namespace] [4]'])

def testNamespaceIndentationNoError(self):

lines = ['namespace Test {',

'void foo() { }',

'} // namespace Test']

results = self.GetNamespaceResults(lines)

self.assertEqual(results, '')

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)

self.assertEqual(results, '')

# Test get line width.

def testGetLineWidth(self):

self.assertEqual(0, cpplint.GetLineWidth(''))

self.assertEqual(10, cpplint.GetLineWidth(str('x') * 10))

self.assertEqual(16, cpplint.GetLineWidth('\u90fd|\u9053|\u5e9c|\u770c|\u652f\u5e81'))

self.assertEqual(16, cpplint.GetLineWidth(u'都|道|府|県|支庁'))

self.assertEqual(5 + 13 + 9, cpplint.GetLineWidth(

u'd𝐱/dt' + u'f : t ⨯ 𝐱 → ℝ' + u't ⨯ 𝐱 → ℝ'))

def testGetTextInside(self):

self.assertEqual('', cpplint._GetTextInside('fun()', r'fun\('))

self.assertEqual('x, y', cpplint._GetTextInside('f(x, y)', r'f\('))

self.assertEqual('a(), b(c())', cpplint._GetTextInside(

'printf(a(), b(c()))', r'printf\('))

self.assertEqual('x, y{}', cpplint._GetTextInside('f[x, y{}]', r'f\['))

self.assertEqual(None, cpplint._GetTextInside('f[a, b(}]', r'f\['))

self.assertEqual(None, cpplint._GetTextInside('f[x, y]', r'f\('))

self.assertEqual('y, h(z, (a + b))', cpplint._GetTextInside(

'f(x, g(y, h(z, (a + b))))', r'g\('))

self.assertEqual('f(f(x))', cpplint._GetTextInside('f(f(f(x)))', r'f\('))

# Supports multiple lines.

self.assertEqual('\n return loop(x);\n',

cpplint._GetTextInside(

'int loop(int x) {\n return loop(x);\n}\n', r'\{'))

# '^' matches the beginning of each line.

self.assertEqual('x, y',

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+\('))

def testFindNextMultiLineCommentStart(self):

self.assertEqual(1, cpplint.FindNextMultiLineCommentStart([''], 0))

lines = ['a', 'b', '/* c']

self.assertEqual(2, cpplint.FindNextMultiLineCommentStart(lines, 0))

lines = ['char a[] = "/*";'] # not recognized as comment.

self.assertEqual(1, cpplint.FindNextMultiLineCommentStart(lines, 0))

def testFindNextMultiLineCommentEnd(self):

self.assertEqual(1, cpplint.FindNextMultiLineCommentEnd([''], 0))

lines = ['a', 'b', ' c */']

self.assertEqual(2, cpplint.FindNextMultiLineCommentEnd(lines, 0))

def testRemoveMultiLineCommentsFromRange(self):

lines = ['a', ' /* comment ', ' * still comment', ' comment */ ', 'b']

cpplint.RemoveMultiLineCommentsFromRange(lines, 1, 4)

self.assertEqual(['a', '/**/', '/**/', '/**/', 'b'], lines)

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"(\n'

'g' + ('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(*)', '')

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

self.assertEqual('', 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)

self.assertEqual('', 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)

self.assertEqual('', 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)

self.assertEqual('', 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)

self.assertEqual('', 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)

self.assertEqual('', 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)

self.assertEqual('', 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)

self.assertEqual('', 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)

self.assertEqual('Lines should be <= 80 characters long '

'[whitespace/line_length] [2]', error_collector.Results())

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

self.assertEqual('Lines should be <= 80 characters long '

'[whitespace/line_length] [2]',

error_collector.Results())

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

self.assertEqual('NOLINT categories not supported in block END: readability/casting '

'[readability/nolint] [5]',

error_collector.Results())

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

self.assertEqual('NONLINT block already defined on line 2 '

'[readability/nolint] [5]', error_collector.Results())

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

self.assertEqual('NONLINT block never ended [readability/nolint] [5]', error_collector.Results())

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

"""

}""",

'')

self.TestMultiLineLint(

"""

};""",

'')

self.TestMultiLineLint(

"""

};""",

'')

self.TestMultiLineLint(

"""

}""",

'')

# 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*/) {', '')

self.TestLint('void f(int /*unused*/) override {', '')

self.TestLint('void f(int /*unused*/) final {', '')

# Test deprecated casts such as int(d)

def testDeprecatedCast(self):

self.TestLint(

'int a = int(2.2);',

'Using deprecated casting style. '

'Use static_cast<int>(...) instead'

' [readability/casting] [4]')

self.TestLint(

'(char *) "foo"',

'Using C-style cast. '

'Use const_cast<char *>(...) instead'

' [readability/casting] [4]')

self.TestLint(

'(int*)foo',

'Using C-style cast. '

'Use reinterpret_cast<int*>(...) instead'

' [readability/casting] [4]')

# Checks for false positives...

self.TestLint('int a = int();', '') # constructor

self.TestLint('X::X() : a(int()) {}', '') # default constructor

self.TestLint('operator bool();', '') # Conversion operator

self.TestLint('new int64_t(123);', '') # "new" operator on basic type

self.TestLint('new int64_t(123);', '') # "new" operator on basic type

self.TestLint('new const int(42);', '') # "new" on const-qualified type

self.TestLint('using a = bool(int arg);', '') # C++11 alias-declaration

self.TestLint('x = bit_cast<double(*)[3]>(y);', '') # array of array

self.TestLint('void F(const char(&src)[N]);', '') # array of references

# Placement new

self.TestLint(

'new(field_ptr) int(field->default_value_enum()->number());',

'')

# C++11 function wrappers

self.TestLint('std::function<int(bool)>', '')

self.TestLint('std::function<const int(bool)>', '')

self.TestLint('std::function< int(bool) >', '')

self.TestLint('mfunction<int(bool)>', '')

error_collector = ErrorCollector(self.assertTrue)

cpplint.ProcessFileData(

'test.cc', 'cc',

['// Copyright 2014 Your Company. All Rights Reserved.',

'typedef std::function<',

' bool(int)> F;',

''],

error_collector)

self.assertEqual('', error_collector.Results())

# Return types for function pointers

self.TestLint('typedef bool(FunctionPointer)();', '')

self.TestLint('typedef bool(FunctionPointer)(int param);', '')

self.TestLint('typedef bool(MyClass::*MemberFunctionPointer)();', '')

self.TestLint('typedef bool(MyClass::* MemberFunctionPointer)();', '')

self.TestLint('typedef bool(MyClass::*MemberFunctionPointer)() const;', '')

self.TestLint('void Function(bool(FunctionPointerArg)());', '')

self.TestLint('void Function(bool(FunctionPointerArg)()) {}', '')

self.TestLint('typedef set<int64_t, bool(*)(int64_t, int64_t)> SortedIdSet', '')

self.TestLint(

'bool TraverseNode(T *Node, bool(VisitorBase:: *traverse) (T *t)) {}',

'')

# 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 testMockMethod(self):

self.TestLint(

'MOCK_METHOD0(method, int());',

'')

self.TestLint(

'MOCK_CONST_METHOD1(method, float(string));',

'')

self.TestLint(

'MOCK_CONST_METHOD2_T(method, double(float, float));',

'')

self.TestLint(

'MOCK_CONST_METHOD1(method, SomeType(int));',

'')

error_collector = ErrorCollector(self.assertTrue)

cpplint.ProcessFileData('mock.cc', 'cc',

['MOCK_METHOD1(method1,',

' bool(int));',

'MOCK_METHOD1(',

' method2,',

' bool(int));',

'MOCK_CONST_METHOD2(',

' method3, bool(int,',

' int));',

'MOCK_METHOD1(method4, int(bool));',

'const int kConstant = int(42);'], # true positive

error_collector)

self.assertEqual(

0,

error_collector.Results().count(

('Using deprecated casting style. '

'Use static_cast<bool>(...) instead '

'[readability/casting] [4]')))

self.assertEqual(

1,

error_collector.Results().count(

('Using deprecated casting style. '

'Use static_cast<int>(...) instead '

'[readability/casting] [4]')))

# Like gMock method definitions, MockCallback instantiations look very similar

# to bad casts.

def testMockCallback(self):

self.TestLint(

'MockCallback<bool(int)>',

'')

self.TestLint(

'MockCallback<int(float, char)>',

'')

# Test false errors that happened with some include file names