1# -*- coding: utf-8; -*- 2# 3# Copyright (C) 2011 Google Inc. All rights reserved. 4# Copyright (C) 2009 Torch Mobile Inc. 5# Copyright (C) 2009 Apple Inc. All rights reserved. 6# Copyright (C) 2010 Chris Jerdonek (cjerdonek@webkit.org) 7# 8# Redistribution and use in source and binary forms, with or without 9# modification, are permitted provided that the following conditions are 10# met: 11# 12# * Redistributions of source code must retain the above copyright 13# notice, this list of conditions and the following disclaimer. 14# * Redistributions in binary form must reproduce the above 15# copyright notice, this list of conditions and the following disclaimer 16# in the documentation and/or other materials provided with the 17# distribution. 18# * Neither the name of Google Inc. nor the names of its 19# contributors may be used to endorse or promote products derived from 20# this software without specific prior written permission. 21# 22# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 23# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 24# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 25# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 26# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 27# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 28# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 32# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 34"""Unit test for cpp_style.py.""" 35 36# FIXME: Add a good test that tests UpdateIncludeState. 37 38import os 39import random 40import re 41import unittest 42 43import cpp as cpp_style 44from cpp import CppChecker 45from ..filter import FilterConfiguration 46from webkitpy.common.system.filesystem import FileSystem 47 48# This class works as an error collector and replaces cpp_style.Error 49# function for the unit tests. We also verify each category we see 50# is in STYLE_CATEGORIES, to help keep that list up to date. 51class ErrorCollector: 52 _all_style_categories = CppChecker.categories 53 # This is a list including all categories seen in any unit test. 54 _seen_style_categories = {} 55 56 def __init__(self, assert_fn, filter=None, lines_to_check=None): 57 """assert_fn: a function to call when we notice a problem. 58 filter: filters the errors that we are concerned about.""" 59 self._assert_fn = assert_fn 60 self._errors = [] 61 self._lines_to_check = lines_to_check 62 if not filter: 63 filter = FilterConfiguration() 64 self._filter = filter 65 66 def __call__(self, line_number, category, confidence, message): 67 self._assert_fn(category in self._all_style_categories, 68 'Message "%s" has category "%s",' 69 ' which is not in STYLE_CATEGORIES' % (message, category)) 70 71 if self._lines_to_check and not line_number in self._lines_to_check: 72 return False 73 74 if self._filter.should_check(category, ""): 75 self._seen_style_categories[category] = 1 76 self._errors.append('%s [%s] [%d]' % (message, category, confidence)) 77 return True 78 79 def results(self): 80 if len(self._errors) < 2: 81 return ''.join(self._errors) # Most tests expect to have a string. 82 else: 83 return self._errors # Let's give a list if there is more than one. 84 85 def result_list(self): 86 return self._errors 87 88 def verify_all_categories_are_seen(self): 89 """Fails if there's a category in _all_style_categories - _seen_style_categories. 90 91 This should only be called after all tests are run, so 92 _seen_style_categories has had a chance to fully populate. Since 93 this isn't called from within the normal unittest framework, we 94 can't use the normal unittest assert macros. Instead we just exit 95 when we see an error. Good thing this test is always run last! 96 """ 97 for category in self._all_style_categories: 98 if category not in self._seen_style_categories: 99 import sys 100 sys.exit('FATAL ERROR: There are no tests for category "%s"' % category) 101 102 103class CppFunctionsTest(unittest.TestCase): 104 105 """Supports testing functions that do not need CppStyleTestBase.""" 106 107 def test_convert_to_lower_with_underscores(self): 108 self.assertEqual(cpp_style._convert_to_lower_with_underscores('ABC'), 'abc') 109 self.assertEqual(cpp_style._convert_to_lower_with_underscores('aB'), 'a_b') 110 self.assertEqual(cpp_style._convert_to_lower_with_underscores('isAName'), 'is_a_name') 111 self.assertEqual(cpp_style._convert_to_lower_with_underscores('AnotherTest'), 'another_test') 112 self.assertEqual(cpp_style._convert_to_lower_with_underscores('PassRefPtr<MyClass>'), 'pass_ref_ptr<my_class>') 113 self.assertEqual(cpp_style._convert_to_lower_with_underscores('_ABC'), '_abc') 114 115 def test_create_acronym(self): 116 self.assertEqual(cpp_style._create_acronym('ABC'), 'ABC') 117 self.assertEqual(cpp_style._create_acronym('IsAName'), 'IAN') 118 self.assertEqual(cpp_style._create_acronym('PassRefPtr<MyClass>'), 'PRP<MC>') 119 120 def test_is_c_or_objective_c(self): 121 clean_lines = cpp_style.CleansedLines(['']) 122 clean_objc_lines = cpp_style.CleansedLines(['#import "header.h"']) 123 self.assertTrue(cpp_style._FileState(clean_lines, 'c').is_c_or_objective_c()) 124 self.assertTrue(cpp_style._FileState(clean_lines, 'm').is_c_or_objective_c()) 125 self.assertFalse(cpp_style._FileState(clean_lines, 'cpp').is_c_or_objective_c()) 126 self.assertFalse(cpp_style._FileState(clean_lines, 'cc').is_c_or_objective_c()) 127 self.assertFalse(cpp_style._FileState(clean_lines, 'h').is_c_or_objective_c()) 128 self.assertTrue(cpp_style._FileState(clean_objc_lines, 'h').is_c_or_objective_c()) 129 130 def test_parameter(self): 131 # Test type. 132 parameter = cpp_style.Parameter('ExceptionCode', 13, 1) 133 self.assertEqual(parameter.type, 'ExceptionCode') 134 self.assertEqual(parameter.name, '') 135 self.assertEqual(parameter.row, 1) 136 137 # Test type and name. 138 parameter = cpp_style.Parameter('PassRefPtr<MyClass> parent', 19, 1) 139 self.assertEqual(parameter.type, 'PassRefPtr<MyClass>') 140 self.assertEqual(parameter.name, 'parent') 141 self.assertEqual(parameter.row, 1) 142 143 # Test type, no name, with default value. 144 parameter = cpp_style.Parameter('MyClass = 0', 7, 0) 145 self.assertEqual(parameter.type, 'MyClass') 146 self.assertEqual(parameter.name, '') 147 self.assertEqual(parameter.row, 0) 148 149 # Test type, name, and default value. 150 parameter = cpp_style.Parameter('MyClass a = 0', 7, 0) 151 self.assertEqual(parameter.type, 'MyClass') 152 self.assertEqual(parameter.name, 'a') 153 self.assertEqual(parameter.row, 0) 154 155 def test_single_line_view(self): 156 start_position = cpp_style.Position(row=1, column=1) 157 end_position = cpp_style.Position(row=3, column=1) 158 single_line_view = cpp_style.SingleLineView(['0', 'abcde', 'fgh', 'i'], start_position, end_position) 159 self.assertEqual(single_line_view.single_line, 'bcde fgh i') 160 self.assertEqual(single_line_view.convert_column_to_row(0), 1) 161 self.assertEqual(single_line_view.convert_column_to_row(4), 1) 162 self.assertEqual(single_line_view.convert_column_to_row(5), 2) 163 self.assertEqual(single_line_view.convert_column_to_row(8), 2) 164 self.assertEqual(single_line_view.convert_column_to_row(9), 3) 165 self.assertEqual(single_line_view.convert_column_to_row(100), 3) 166 167 start_position = cpp_style.Position(row=0, column=3) 168 end_position = cpp_style.Position(row=0, column=4) 169 single_line_view = cpp_style.SingleLineView(['abcdef'], start_position, end_position) 170 self.assertEqual(single_line_view.single_line, 'd') 171 172 def test_create_skeleton_parameters(self): 173 self.assertEqual(cpp_style.create_skeleton_parameters(''), '') 174 self.assertEqual(cpp_style.create_skeleton_parameters(' '), ' ') 175 self.assertEqual(cpp_style.create_skeleton_parameters('long'), 'long,') 176 self.assertEqual(cpp_style.create_skeleton_parameters('const unsigned long int'), ' int,') 177 self.assertEqual(cpp_style.create_skeleton_parameters('long int*'), ' int ,') 178 self.assertEqual(cpp_style.create_skeleton_parameters('PassRefPtr<Foo> a'), 'PassRefPtr a,') 179 self.assertEqual(cpp_style.create_skeleton_parameters( 180 'ComplexTemplate<NestedTemplate1<MyClass1, MyClass2>, NestedTemplate1<MyClass1, MyClass2> > param, int second'), 181 'ComplexTemplate param, int second,') 182 self.assertEqual(cpp_style.create_skeleton_parameters('int = 0, Namespace::Type& a'), 'int , Type a,') 183 # Create skeleton parameters is a bit too aggressive with function variables, but 184 # it allows for parsing other parameters and declarations like this are rare. 185 self.assertEqual(cpp_style.create_skeleton_parameters('void (*fn)(int a, int b), Namespace::Type& a'), 186 'void , Type a,') 187 188 # This doesn't look like functions declarations but the simplifications help to eliminate false positives. 189 self.assertEqual(cpp_style.create_skeleton_parameters('b{d}'), 'b ,') 190 191 def test_find_parameter_name_index(self): 192 self.assertEqual(cpp_style.find_parameter_name_index(' int a '), 5) 193 self.assertEqual(cpp_style.find_parameter_name_index(' PassRefPtr '), 16) 194 self.assertEqual(cpp_style.find_parameter_name_index('double'), 6) 195 196 def test_parameter_list(self): 197 elided_lines = ['int blah(PassRefPtr<MyClass> paramName,', 198 'const Other1Class& foo,', 199 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),', 200 'int* myCount = 0);'] 201 start_position = cpp_style.Position(row=0, column=8) 202 end_position = cpp_style.Position(row=3, column=16) 203 204 expected_parameters = ({'type': 'PassRefPtr<MyClass>', 'name': 'paramName', 'row': 0}, 205 {'type': 'const Other1Class&', 'name': 'foo', 'row': 1}, 206 {'type': 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const *', 'name': 'param', 'row': 2}, 207 {'type': 'int*', 'name': 'myCount', 'row': 3}) 208 index = 0 209 for parameter in cpp_style.parameter_list(elided_lines, start_position, end_position): 210 expected_parameter = expected_parameters[index] 211 self.assertEqual(parameter.type, expected_parameter['type']) 212 self.assertEqual(parameter.name, expected_parameter['name']) 213 self.assertEqual(parameter.row, expected_parameter['row']) 214 index += 1 215 self.assertEqual(index, len(expected_parameters)) 216 217 def test_check_parameter_against_text(self): 218 error_collector = ErrorCollector(self.assertTrue) 219 parameter = cpp_style.Parameter('FooF ooF', 4, 1) 220 self.assertFalse(cpp_style._check_parameter_name_against_text(parameter, 'FooF', error_collector)) 221 self.assertEqual(error_collector.results(), 222 'The parameter name "ooF" adds no information, so it should be removed. [readability/parameter_name] [5]') 223 224class CppStyleTestBase(unittest.TestCase): 225 """Provides some useful helper functions for cpp_style tests. 226 227 Attributes: 228 min_confidence: An integer that is the current minimum confidence 229 level for the tests. 230 231 """ 232 233 # FIXME: Refactor the unit tests so the confidence level is passed 234 # explicitly, just like it is in the real code. 235 min_confidence = 1; 236 237 # Helper function to avoid needing to explicitly pass confidence 238 # in all the unit test calls to cpp_style.process_file_data(). 239 def process_file_data(self, filename, file_extension, lines, error, fs=None): 240 """Call cpp_style.process_file_data() with the min_confidence.""" 241 return cpp_style.process_file_data(filename, file_extension, lines, 242 error, self.min_confidence, fs) 243 244 def perform_lint(self, code, filename, basic_error_rules, fs=None, lines_to_check=None): 245 error_collector = ErrorCollector(self.assertTrue, FilterConfiguration(basic_error_rules), lines_to_check) 246 lines = code.split('\n') 247 extension = filename.split('.')[1] 248 self.process_file_data(filename, extension, lines, error_collector, fs) 249 return error_collector.results() 250 251 # Perform lint on single line of input and return the error message. 252 def perform_single_line_lint(self, code, filename): 253 basic_error_rules = ('-build/header_guard', 254 '-legal/copyright', 255 '-readability/fn_size', 256 '-readability/parameter_name', 257 '-readability/pass_ptr', 258 '-whitespace/ending_newline') 259 return self.perform_lint(code, filename, basic_error_rules) 260 261 # Perform lint over multiple lines and return the error message. 262 def perform_multi_line_lint(self, code, file_extension): 263 basic_error_rules = ('-build/header_guard', 264 '-legal/copyright', 265 '-readability/parameter_name', 266 '-whitespace/ending_newline') 267 return self.perform_lint(code, 'test.' + file_extension, basic_error_rules) 268 269 # Only keep some errors related to includes, namespaces and rtti. 270 def perform_language_rules_check(self, filename, code, lines_to_check=None): 271 basic_error_rules = ('-', 272 '+build/include', 273 '+build/include_order', 274 '+build/namespaces', 275 '+runtime/rtti') 276 return self.perform_lint(code, filename, basic_error_rules, lines_to_check=lines_to_check) 277 278 # Only keep function length errors. 279 def perform_function_lengths_check(self, code): 280 basic_error_rules = ('-', 281 '+readability/fn_size') 282 return self.perform_lint(code, 'test.cpp', basic_error_rules) 283 284 # Only keep pass ptr errors. 285 def perform_pass_ptr_check(self, code): 286 basic_error_rules = ('-', 287 '+readability/pass_ptr') 288 return self.perform_lint(code, 'test.cpp', basic_error_rules) 289 290 # Only keep leaky pattern errors. 291 def perform_leaky_pattern_check(self, code): 292 basic_error_rules = ('-', 293 '+runtime/leaky_pattern') 294 return self.perform_lint(code, 'test.cpp', basic_error_rules) 295 296 # Only include what you use errors. 297 def perform_include_what_you_use(self, code, filename='foo.h', fs=None): 298 basic_error_rules = ('-', 299 '+build/include_what_you_use') 300 return self.perform_lint(code, filename, basic_error_rules, fs) 301 302 def perform_avoid_static_cast_of_objects(self, code, filename='foo.cpp', fs=None): 303 basic_error_rules = ('-', 304 '+runtime/casting') 305 return self.perform_lint(code, filename, basic_error_rules, fs) 306 307 # Perform lint and compare the error message with "expected_message". 308 def assert_lint(self, code, expected_message, file_name='foo.cpp'): 309 self.assertEqual(expected_message, self.perform_single_line_lint(code, file_name)) 310 311 def assert_lint_one_of_many_errors_re(self, code, expected_message_re, file_name='foo.cpp'): 312 messages = self.perform_single_line_lint(code, file_name) 313 for message in messages: 314 if re.search(expected_message_re, message): 315 return 316 317 self.assertEqual(expected_message_re, messages) 318 319 def assert_multi_line_lint(self, code, expected_message, file_name='foo.h'): 320 file_extension = file_name[file_name.rfind('.') + 1:] 321 self.assertEqual(expected_message, self.perform_multi_line_lint(code, file_extension)) 322 323 def assert_multi_line_lint_re(self, code, expected_message_re, file_name='foo.h'): 324 file_extension = file_name[file_name.rfind('.') + 1:] 325 message = self.perform_multi_line_lint(code, file_extension) 326 if not re.search(expected_message_re, message): 327 self.fail('Message was:\n' + message + 'Expected match to "' + expected_message_re + '"') 328 329 def assert_language_rules_check(self, file_name, code, expected_message, lines_to_check=None): 330 self.assertEqual(expected_message, 331 self.perform_language_rules_check(file_name, code, lines_to_check)) 332 333 def assert_include_what_you_use(self, code, expected_message): 334 self.assertEqual(expected_message, 335 self.perform_include_what_you_use(code)) 336 337 def assert_blank_lines_check(self, lines, start_errors, end_errors): 338 error_collector = ErrorCollector(self.assertTrue) 339 self.process_file_data('foo.cpp', 'cpp', lines, error_collector) 340 self.assertEqual( 341 start_errors, 342 error_collector.results().count( 343 'Blank line at the start of a code block. Is this needed?' 344 ' [whitespace/blank_line] [2]')) 345 self.assertEqual( 346 end_errors, 347 error_collector.results().count( 348 'Blank line at the end of a code block. Is this needed?' 349 ' [whitespace/blank_line] [3]')) 350 351 def assert_positions_equal(self, position, tuple_position): 352 """Checks if the two positions are equal. 353 354 position: a cpp_style.Position object. 355 tuple_position: a tuple (row, column) to compare against.""" 356 self.assertEqual(position, cpp_style.Position(tuple_position[0], tuple_position[1]), 357 'position %s, tuple_position %s' % (position, tuple_position)) 358 359 360class FunctionDetectionTest(CppStyleTestBase): 361 def perform_function_detection(self, lines, function_information, detection_line=0): 362 clean_lines = cpp_style.CleansedLines(lines) 363 function_state = cpp_style._FunctionState(5) 364 error_collector = ErrorCollector(self.assertTrue) 365 cpp_style.detect_functions(clean_lines, detection_line, function_state, error_collector) 366 if not function_information: 367 self.assertEqual(function_state.in_a_function, False) 368 return 369 self.assertEqual(function_state.in_a_function, True) 370 self.assertEqual(function_state.current_function, function_information['name'] + '()') 371 self.assertEqual(function_state.modifiers_and_return_type(), function_information['modifiers_and_return_type']) 372 self.assertEqual(function_state.is_pure, function_information['is_pure']) 373 self.assertEqual(function_state.is_declaration, function_information['is_declaration']) 374 self.assert_positions_equal(function_state.function_name_start_position, function_information['function_name_start_position']) 375 self.assert_positions_equal(function_state.parameter_start_position, function_information['parameter_start_position']) 376 self.assert_positions_equal(function_state.parameter_end_position, function_information['parameter_end_position']) 377 self.assert_positions_equal(function_state.body_start_position, function_information['body_start_position']) 378 self.assert_positions_equal(function_state.end_position, function_information['end_position']) 379 expected_parameters = function_information.get('parameter_list') 380 if expected_parameters: 381 actual_parameters = function_state.parameter_list() 382 self.assertEqual(len(actual_parameters), len(expected_parameters)) 383 for index in range(len(expected_parameters)): 384 actual_parameter = actual_parameters[index] 385 expected_parameter = expected_parameters[index] 386 self.assertEqual(actual_parameter.type, expected_parameter['type']) 387 self.assertEqual(actual_parameter.name, expected_parameter['name']) 388 self.assertEqual(actual_parameter.row, expected_parameter['row']) 389 390 def test_basic_function_detection(self): 391 self.perform_function_detection( 392 ['void theTestFunctionName(int) {', 393 '}'], 394 {'name': 'theTestFunctionName', 395 'modifiers_and_return_type': 'void', 396 'function_name_start_position': (0, 5), 397 'parameter_start_position': (0, 24), 398 'parameter_end_position': (0, 29), 399 'body_start_position': (0, 30), 400 'end_position': (1, 1), 401 'is_pure': False, 402 'is_declaration': False}) 403 404 def test_function_declaration_detection(self): 405 self.perform_function_detection( 406 ['void aFunctionName(int);'], 407 {'name': 'aFunctionName', 408 'modifiers_and_return_type': 'void', 409 'function_name_start_position': (0, 5), 410 'parameter_start_position': (0, 18), 411 'parameter_end_position': (0, 23), 412 'body_start_position': (0, 23), 413 'end_position': (0, 24), 414 'is_pure': False, 415 'is_declaration': True}) 416 417 self.perform_function_detection( 418 ['CheckedInt<T> operator /(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'], 419 {'name': 'operator /', 420 'modifiers_and_return_type': 'CheckedInt<T>', 421 'function_name_start_position': (0, 14), 422 'parameter_start_position': (0, 24), 423 'parameter_end_position': (0, 76), 424 'body_start_position': (0, 76), 425 'end_position': (0, 77), 426 'is_pure': False, 427 'is_declaration': True}) 428 429 self.perform_function_detection( 430 ['CheckedInt<T> operator -(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'], 431 {'name': 'operator -', 432 'modifiers_and_return_type': 'CheckedInt<T>', 433 'function_name_start_position': (0, 14), 434 'parameter_start_position': (0, 24), 435 'parameter_end_position': (0, 76), 436 'body_start_position': (0, 76), 437 'end_position': (0, 77), 438 'is_pure': False, 439 'is_declaration': True}) 440 441 self.perform_function_detection( 442 ['CheckedInt<T> operator !=(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'], 443 {'name': 'operator !=', 444 'modifiers_and_return_type': 'CheckedInt<T>', 445 'function_name_start_position': (0, 14), 446 'parameter_start_position': (0, 25), 447 'parameter_end_position': (0, 77), 448 'body_start_position': (0, 77), 449 'end_position': (0, 78), 450 'is_pure': False, 451 'is_declaration': True}) 452 453 self.perform_function_detection( 454 ['CheckedInt<T> operator +(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'], 455 {'name': 'operator +', 456 'modifiers_and_return_type': 'CheckedInt<T>', 457 'function_name_start_position': (0, 14), 458 'parameter_start_position': (0, 24), 459 'parameter_end_position': (0, 76), 460 'body_start_position': (0, 76), 461 'end_position': (0, 77), 462 'is_pure': False, 463 'is_declaration': True}) 464 465 def test_pure_function_detection(self): 466 self.perform_function_detection( 467 ['virtual void theTestFunctionName(int = 0);'], 468 {'name': 'theTestFunctionName', 469 'modifiers_and_return_type': 'virtual void', 470 'function_name_start_position': (0, 13), 471 'parameter_start_position': (0, 32), 472 'parameter_end_position': (0, 41), 473 'body_start_position': (0, 41), 474 'end_position': (0, 42), 475 'is_pure': False, 476 'is_declaration': True}) 477 478 self.perform_function_detection( 479 ['virtual void theTestFunctionName(int) = 0;'], 480 {'name': 'theTestFunctionName', 481 'modifiers_and_return_type': 'virtual void', 482 'function_name_start_position': (0, 13), 483 'parameter_start_position': (0, 32), 484 'parameter_end_position': (0, 37), 485 'body_start_position': (0, 41), 486 'end_position': (0, 42), 487 'is_pure': True, 488 'is_declaration': True}) 489 490 # Hopefully, no one writes code like this but it is a tricky case. 491 self.perform_function_detection( 492 ['virtual void theTestFunctionName(int)', 493 ' = ', 494 ' 0 ;'], 495 {'name': 'theTestFunctionName', 496 'modifiers_and_return_type': 'virtual void', 497 'function_name_start_position': (0, 13), 498 'parameter_start_position': (0, 32), 499 'parameter_end_position': (0, 37), 500 'body_start_position': (2, 3), 501 'end_position': (2, 4), 502 'is_pure': True, 503 'is_declaration': True}) 504 505 def test_ignore_macros(self): 506 self.perform_function_detection(['void aFunctionName(int); \\'], None) 507 508 def test_non_functions(self): 509 # This case exposed an error because the open brace was in quotes. 510 self.perform_function_detection( 511 ['asm(', 512 ' "stmdb sp!, {r1-r3}" "\n"', 513 ');'], 514 # This isn't a function but it looks like one to our simple 515 # algorithm and that is ok. 516 {'name': 'asm', 517 'modifiers_and_return_type': '', 518 'function_name_start_position': (0, 0), 519 'parameter_start_position': (0, 3), 520 'parameter_end_position': (2, 1), 521 'body_start_position': (2, 1), 522 'end_position': (2, 2), 523 'is_pure': False, 524 'is_declaration': True}) 525 526 # Simple test case with something that is not a function. 527 self.perform_function_detection(['class Stuff;'], None) 528 529 def test_parameter_list(self): 530 # A function with no arguments. 531 function_state = self.perform_function_detection( 532 ['void functionName();'], 533 {'name': 'functionName', 534 'modifiers_and_return_type': 'void', 535 'function_name_start_position': (0, 5), 536 'parameter_start_position': (0, 17), 537 'parameter_end_position': (0, 19), 538 'body_start_position': (0, 19), 539 'end_position': (0, 20), 540 'is_pure': False, 541 'is_declaration': True, 542 'parameter_list': ()}) 543 544 # A function with one argument. 545 function_state = self.perform_function_detection( 546 ['void functionName(int);'], 547 {'name': 'functionName', 548 'modifiers_and_return_type': 'void', 549 'function_name_start_position': (0, 5), 550 'parameter_start_position': (0, 17), 551 'parameter_end_position': (0, 22), 552 'body_start_position': (0, 22), 553 'end_position': (0, 23), 554 'is_pure': False, 555 'is_declaration': True, 556 'parameter_list': 557 ({'type': 'int', 'name': '', 'row': 0},)}) 558 559 # A function with unsigned and short arguments 560 function_state = self.perform_function_detection( 561 ['void functionName(unsigned a, short b, long c, long long short unsigned int);'], 562 {'name': 'functionName', 563 'modifiers_and_return_type': 'void', 564 'function_name_start_position': (0, 5), 565 'parameter_start_position': (0, 17), 566 'parameter_end_position': (0, 76), 567 'body_start_position': (0, 76), 568 'end_position': (0, 77), 569 'is_pure': False, 570 'is_declaration': True, 571 'parameter_list': 572 ({'type': 'unsigned', 'name': 'a', 'row': 0}, 573 {'type': 'short', 'name': 'b', 'row': 0}, 574 {'type': 'long', 'name': 'c', 'row': 0}, 575 {'type': 'long long short unsigned int', 'name': '', 'row': 0})}) 576 577 # Some parameter type with modifiers and no parameter names. 578 function_state = self.perform_function_detection( 579 ['virtual void determineARIADropEffects(Vector<String>*&, const unsigned long int*&, const MediaPlayer::Preload, Other<Other2, Other3<P1, P2> >, int);'], 580 {'name': 'determineARIADropEffects', 581 'modifiers_and_return_type': 'virtual void', 582 'parameter_start_position': (0, 37), 583 'function_name_start_position': (0, 13), 584 'parameter_end_position': (0, 147), 585 'body_start_position': (0, 147), 586 'end_position': (0, 148), 587 'is_pure': False, 588 'is_declaration': True, 589 'parameter_list': 590 ({'type': 'Vector<String>*&', 'name': '', 'row': 0}, 591 {'type': 'const unsigned long int*&', 'name': '', 'row': 0}, 592 {'type': 'const MediaPlayer::Preload', 'name': '', 'row': 0}, 593 {'type': 'Other<Other2, Other3<P1, P2> >', 'name': '', 'row': 0}, 594 {'type': 'int', 'name': '', 'row': 0})}) 595 596 # Try parsing a function with a very complex definition. 597 function_state = self.perform_function_detection( 598 ['#define MyMacro(a) a', 599 'virtual', 600 'AnotherTemplate<Class1, Class2> aFunctionName(PassRefPtr<MyClass> paramName,', 601 'const Other1Class& foo,', 602 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),', 603 'int* myCount = 0);'], 604 {'name': 'aFunctionName', 605 'modifiers_and_return_type': 'virtual AnotherTemplate<Class1, Class2>', 606 'function_name_start_position': (2, 32), 607 'parameter_start_position': (2, 45), 608 'parameter_end_position': (5, 17), 609 'body_start_position': (5, 17), 610 'end_position': (5, 18), 611 'is_pure': False, 612 'is_declaration': True, 613 'parameter_list': 614 ({'type': 'PassRefPtr<MyClass>', 'name': 'paramName', 'row': 2}, 615 {'type': 'const Other1Class&', 'name': 'foo', 'row': 3}, 616 {'type': 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const *', 'name': 'param', 'row': 4}, 617 {'type': 'int*', 'name': 'myCount', 'row': 5})}, 618 detection_line=2) 619 620 621class CppStyleTest(CppStyleTestBase): 622 623 def test_asm_lines_ignored(self): 624 self.assert_lint( 625 '__asm mov [registration], eax', 626 '') 627 628 # Test get line width. 629 def test_get_line_width(self): 630 self.assertEqual(0, cpp_style.get_line_width('')) 631 self.assertEqual(10, cpp_style.get_line_width(u'x' * 10)) 632 self.assertEqual(16, cpp_style.get_line_width(u'都|道|府|県|支庁')) 633 634 def test_find_next_multi_line_comment_start(self): 635 self.assertEqual(1, cpp_style.find_next_multi_line_comment_start([''], 0)) 636 637 lines = ['a', 'b', '/* c'] 638 self.assertEqual(2, cpp_style.find_next_multi_line_comment_start(lines, 0)) 639 640 lines = ['char a[] = "/*";'] # not recognized as comment. 641 self.assertEqual(1, cpp_style.find_next_multi_line_comment_start(lines, 0)) 642 643 def test_find_next_multi_line_comment_end(self): 644 self.assertEqual(1, cpp_style.find_next_multi_line_comment_end([''], 0)) 645 lines = ['a', 'b', ' c */'] 646 self.assertEqual(2, cpp_style.find_next_multi_line_comment_end(lines, 0)) 647 648 def test_remove_multi_line_comments_from_range(self): 649 lines = ['a', ' /* comment ', ' * still comment', ' comment */ ', 'b'] 650 cpp_style.remove_multi_line_comments_from_range(lines, 1, 4) 651 self.assertEqual(['a', '// dummy', '// dummy', '// dummy', 'b'], lines) 652 653 def test_position(self): 654 position = cpp_style.Position(3, 4) 655 self.assert_positions_equal(position, (3, 4)) 656 self.assertEqual(position.row, 3) 657 self.assertTrue(position > cpp_style.Position(position.row - 1, position.column + 1)) 658 self.assertTrue(position > cpp_style.Position(position.row, position.column - 1)) 659 self.assertTrue(position < cpp_style.Position(position.row, position.column + 1)) 660 self.assertTrue(position < cpp_style.Position(position.row + 1, position.column - 1)) 661 self.assertEqual(position.__str__(), '(3, 4)') 662 663 def test_rfind_in_lines(self): 664 not_found_position = cpp_style.Position(10, 11) 665 start_position = cpp_style.Position(2, 2) 666 lines = ['ab', 'ace', 'test'] 667 self.assertEqual(not_found_position, cpp_style._rfind_in_lines('st', lines, start_position, not_found_position)) 668 self.assertTrue(cpp_style.Position(1, 1) == cpp_style._rfind_in_lines('a', lines, start_position, not_found_position)) 669 self.assertEqual(cpp_style.Position(2, 2), cpp_style._rfind_in_lines('(te|a)', lines, start_position, not_found_position)) 670 671 def test_close_expression(self): 672 self.assertEqual(cpp_style.Position(1, -1), cpp_style.close_expression([')('], cpp_style.Position(0, 1))) 673 self.assertEqual(cpp_style.Position(1, -1), cpp_style.close_expression([') ()'], cpp_style.Position(0, 1))) 674 self.assertEqual(cpp_style.Position(0, 4), cpp_style.close_expression([')[)]'], cpp_style.Position(0, 1))) 675 self.assertEqual(cpp_style.Position(0, 5), cpp_style.close_expression(['}{}{}'], cpp_style.Position(0, 3))) 676 self.assertEqual(cpp_style.Position(1, 1), cpp_style.close_expression(['}{}{', '}'], cpp_style.Position(0, 3))) 677 self.assertEqual(cpp_style.Position(2, -1), cpp_style.close_expression(['][][', ' '], cpp_style.Position(0, 3))) 678 679 def test_spaces_at_end_of_line(self): 680 self.assert_lint( 681 '// Hello there ', 682 'Line ends in whitespace. Consider deleting these extra spaces.' 683 ' [whitespace/end_of_line] [4]') 684 685 # Test C-style cast cases. 686 def test_cstyle_cast(self): 687 self.assert_lint( 688 'int a = (int)1.0;', 689 'Using C-style cast. Use static_cast<int>(...) instead' 690 ' [readability/casting] [4]') 691 self.assert_lint( 692 'int *a = (int *)DEFINED_VALUE;', 693 'Using C-style cast. Use reinterpret_cast<int *>(...) instead' 694 ' [readability/casting] [4]', 'foo.c') 695 self.assert_lint( 696 'uint16 a = (uint16)1.0;', 697 'Using C-style cast. Use static_cast<uint16>(...) instead' 698 ' [readability/casting] [4]') 699 self.assert_lint( 700 'int32 a = (int32)1.0;', 701 'Using C-style cast. Use static_cast<int32>(...) instead' 702 ' [readability/casting] [4]') 703 self.assert_lint( 704 'uint64 a = (uint64)1.0;', 705 'Using C-style cast. Use static_cast<uint64>(...) instead' 706 ' [readability/casting] [4]') 707 708 # Test taking address of casts (runtime/casting) 709 def test_runtime_casting(self): 710 self.assert_lint( 711 'int* x = &static_cast<int*>(foo);', 712 'Are you taking an address of a cast? ' 713 'This is dangerous: could be a temp var. ' 714 'Take the address before doing the cast, rather than after' 715 ' [runtime/casting] [4]') 716 717 self.assert_lint( 718 'int* x = &dynamic_cast<int *>(foo);', 719 ['Are you taking an address of a cast? ' 720 'This is dangerous: could be a temp var. ' 721 'Take the address before doing the cast, rather than after' 722 ' [runtime/casting] [4]', 723 'Do not use dynamic_cast<>. If you need to cast within a class ' 724 'hierarchy, use static_cast<> to upcast. Google doesn\'t support ' 725 'RTTI. [runtime/rtti] [5]']) 726 727 self.assert_lint( 728 'int* x = &reinterpret_cast<int *>(foo);', 729 'Are you taking an address of a cast? ' 730 'This is dangerous: could be a temp var. ' 731 'Take the address before doing the cast, rather than after' 732 ' [runtime/casting] [4]') 733 734 # It's OK to cast an address. 735 self.assert_lint( 736 'int* x = reinterpret_cast<int *>(&foo);', 737 '') 738 739 def test_runtime_selfinit(self): 740 self.assert_lint( 741 'Foo::Foo(Bar r, Bel l) : r_(r_), l_(l_) { }', 742 'You seem to be initializing a member variable with itself.' 743 ' [runtime/init] [4]') 744 self.assert_lint( 745 'Foo::Foo(Bar r, Bel l) : r_(r), l_(l) { }', 746 '') 747 self.assert_lint( 748 'Foo::Foo(Bar r) : r_(r), l_(r_), ll_(l_) { }', 749 '') 750 751 def test_runtime_rtti(self): 752 statement = 'int* x = dynamic_cast<int*>(&foo);' 753 error_message = ( 754 'Do not use dynamic_cast<>. If you need to cast within a class ' 755 'hierarchy, use static_cast<> to upcast. Google doesn\'t support ' 756 'RTTI. [runtime/rtti] [5]') 757 # dynamic_cast is disallowed in most files. 758 self.assert_language_rules_check('foo.cpp', statement, error_message) 759 self.assert_language_rules_check('foo.h', statement, error_message) 760 761 # Tests for static_cast readability. 762 def test_static_cast_on_objects_with_toFoo(self): 763 mock_header_contents = ['inline Foo* toFoo(Bar* bar)'] 764 fs = FileSystem() 765 orig_read_text_file_fn = fs.read_text_file 766 767 def mock_read_text_file_fn(path): 768 return mock_header_contents 769 770 try: 771 fs.read_text_file = mock_read_text_file_fn 772 message = self.perform_avoid_static_cast_of_objects( 773 'Foo* x = static_cast<Foo*>(bar);', 774 filename='casting.cpp', 775 fs=fs) 776 self.assertEqual(message, 'static_cast of class objects is not allowed. Use toFoo defined in Foo.h.' 777 ' [runtime/casting] [4]') 778 finally: 779 fs.read_text_file = orig_read_text_file_fn 780 781 def test_static_cast_on_objects_without_toFoo(self): 782 mock_header_contents = ['inline FooBar* toFooBar(Bar* bar)'] 783 fs = FileSystem() 784 orig_read_text_file_fn = fs.read_text_file 785 786 def mock_read_text_file_fn(path): 787 return mock_header_contents 788 789 try: 790 fs.read_text_file = mock_read_text_file_fn 791 message = self.perform_avoid_static_cast_of_objects( 792 'Foo* x = static_cast<Foo*>(bar);', 793 filename='casting.cpp', 794 fs=fs) 795 self.assertEqual(message, 'static_cast of class objects is not allowed. Add toFoo in Foo.h and use it instead.' 796 ' [runtime/casting] [4]') 797 finally: 798 fs.read_text_file = orig_read_text_file_fn 799 800 # We cannot test this functionality because of difference of 801 # function definitions. Anyway, we may never enable this. 802 # 803 # # Test for unnamed arguments in a method. 804 # def test_check_for_unnamed_params(self): 805 # message = ('All parameters should be named in a function' 806 # ' [readability/function] [3]') 807 # self.assert_lint('virtual void A(int*) const;', message) 808 # self.assert_lint('virtual void B(void (*fn)(int*));', message) 809 # self.assert_lint('virtual void C(int*);', message) 810 # self.assert_lint('void *(*f)(void *) = x;', message) 811 # self.assert_lint('void Method(char*) {', message) 812 # self.assert_lint('void Method(char*);', message) 813 # self.assert_lint('void Method(char* /*x*/);', message) 814 # self.assert_lint('typedef void (*Method)(int32);', message) 815 # self.assert_lint('static void operator delete[](void*) throw();', message) 816 # 817 # self.assert_lint('virtual void D(int* p);', '') 818 # self.assert_lint('void operator delete(void* x) throw();', '') 819 # self.assert_lint('void Method(char* x)\n{', '') 820 # self.assert_lint('void Method(char* /*x*/)\n{', '') 821 # self.assert_lint('void Method(char* x);', '') 822 # self.assert_lint('typedef void (*Method)(int32 x);', '') 823 # self.assert_lint('static void operator delete[](void* x) throw();', '') 824 # self.assert_lint('static void operator delete[](void* /*x*/) throw();', '') 825 # 826 # # This one should technically warn, but doesn't because the function 827 # # pointer is confusing. 828 # self.assert_lint('virtual void E(void (*fn)(int* p));', '') 829 830 # Test deprecated casts such as int(d) 831 def test_deprecated_cast(self): 832 self.assert_lint( 833 'int a = int(2.2);', 834 'Using deprecated casting style. ' 835 'Use static_cast<int>(...) instead' 836 ' [readability/casting] [4]') 837 # Checks for false positives... 838 self.assert_lint( 839 'int a = int(); // Constructor, o.k.', 840 '') 841 self.assert_lint( 842 'X::X() : a(int()) { } // default Constructor, o.k.', 843 '') 844 self.assert_lint( 845 'operator bool(); // Conversion operator, o.k.', 846 '') 847 848 # The second parameter to a gMock method definition is a function signature 849 # that often looks like a bad cast but should not picked up by lint. 850 def test_mock_method(self): 851 self.assert_lint( 852 'MOCK_METHOD0(method, int());', 853 '') 854 self.assert_lint( 855 'MOCK_CONST_METHOD1(method, float(string));', 856 '') 857 self.assert_lint( 858 'MOCK_CONST_METHOD2_T(method, double(float, float));', 859 '') 860 861 # Test sizeof(type) cases. 862 def test_sizeof_type(self): 863 self.assert_lint( 864 'sizeof(int);', 865 'Using sizeof(type). Use sizeof(varname) instead if possible' 866 ' [runtime/sizeof] [1]') 867 self.assert_lint( 868 'sizeof(int *);', 869 'Using sizeof(type). Use sizeof(varname) instead if possible' 870 ' [runtime/sizeof] [1]') 871 872 # Test typedef cases. There was a bug that cpp_style misidentified 873 # typedef for pointer to function as C-style cast and produced 874 # false-positive error messages. 875 def test_typedef_for_pointer_to_function(self): 876 self.assert_lint( 877 'typedef void (*Func)(int x);', 878 '') 879 self.assert_lint( 880 'typedef void (*Func)(int *x);', 881 '') 882 self.assert_lint( 883 'typedef void Func(int x);', 884 '') 885 self.assert_lint( 886 'typedef void Func(int *x);', 887 '') 888 889 def test_include_what_you_use_no_implementation_files(self): 890 code = 'std::vector<int> foo;' 891 self.assertEqual('Add #include <vector> for vector<>' 892 ' [build/include_what_you_use] [4]', 893 self.perform_include_what_you_use(code, 'foo.h')) 894 self.assertEqual('', 895 self.perform_include_what_you_use(code, 'foo.cpp')) 896 897 def test_include_what_you_use(self): 898 self.assert_include_what_you_use( 899 '''#include <vector> 900 std::vector<int> foo; 901 ''', 902 '') 903 self.assert_include_what_you_use( 904 '''#include <map> 905 std::pair<int,int> foo; 906 ''', 907 '') 908 self.assert_include_what_you_use( 909 '''#include <multimap> 910 std::pair<int,int> foo; 911 ''', 912 '') 913 self.assert_include_what_you_use( 914 '''#include <hash_map> 915 std::pair<int,int> foo; 916 ''', 917 '') 918 self.assert_include_what_you_use( 919 '''#include <utility> 920 std::pair<int,int> foo; 921 ''', 922 '') 923 self.assert_include_what_you_use( 924 '''#include <vector> 925 DECLARE_string(foobar); 926 ''', 927 '') 928 self.assert_include_what_you_use( 929 '''#include <vector> 930 DEFINE_string(foobar, "", ""); 931 ''', 932 '') 933 self.assert_include_what_you_use( 934 '''#include <vector> 935 std::pair<int,int> foo; 936 ''', 937 'Add #include <utility> for pair<>' 938 ' [build/include_what_you_use] [4]') 939 self.assert_include_what_you_use( 940 '''#include "base/foobar.h" 941 std::vector<int> foo; 942 ''', 943 'Add #include <vector> for vector<>' 944 ' [build/include_what_you_use] [4]') 945 self.assert_include_what_you_use( 946 '''#include <vector> 947 std::set<int> foo; 948 ''', 949 'Add #include <set> for set<>' 950 ' [build/include_what_you_use] [4]') 951 self.assert_include_what_you_use( 952 '''#include "base/foobar.h" 953 hash_map<int, int> foobar; 954 ''', 955 'Add #include <hash_map> for hash_map<>' 956 ' [build/include_what_you_use] [4]') 957 self.assert_include_what_you_use( 958 '''#include "base/foobar.h" 959 bool foobar = std::less<int>(0,1); 960 ''', 961 'Add #include <functional> for less<>' 962 ' [build/include_what_you_use] [4]') 963 self.assert_include_what_you_use( 964 '''#include "base/foobar.h" 965 bool foobar = min<int>(0,1); 966 ''', 967 'Add #include <algorithm> for min [build/include_what_you_use] [4]') 968 self.assert_include_what_you_use( 969 'void a(const string &foobar);', 970 'Add #include <string> for string [build/include_what_you_use] [4]') 971 self.assert_include_what_you_use( 972 '''#include "base/foobar.h" 973 bool foobar = swap(0,1); 974 ''', 975 'Add #include <algorithm> for swap [build/include_what_you_use] [4]') 976 self.assert_include_what_you_use( 977 '''#include "base/foobar.h" 978 bool foobar = transform(a.begin(), a.end(), b.start(), Foo); 979 ''', 980 'Add #include <algorithm> for transform ' 981 '[build/include_what_you_use] [4]') 982 self.assert_include_what_you_use( 983 '''#include "base/foobar.h" 984 bool foobar = min_element(a.begin(), a.end()); 985 ''', 986 'Add #include <algorithm> for min_element ' 987 '[build/include_what_you_use] [4]') 988 self.assert_include_what_you_use( 989 '''foo->swap(0,1); 990 foo.swap(0,1); 991 ''', 992 '') 993 self.assert_include_what_you_use( 994 '''#include <string> 995 void a(const std::multimap<int,string> &foobar); 996 ''', 997 'Add #include <map> for multimap<>' 998 ' [build/include_what_you_use] [4]') 999 self.assert_include_what_you_use( 1000 '''#include <queue> 1001 void a(const std::priority_queue<int> &foobar); 1002 ''', 1003 '') 1004 self.assert_include_what_you_use( 1005 '''#include "base/basictypes.h" 1006 #include "base/port.h" 1007 #include <assert.h> 1008 #include <string> 1009 #include <vector> 1010 vector<string> hajoa;''', '') 1011 self.assert_include_what_you_use( 1012 '''#include <string> 1013 int i = numeric_limits<int>::max() 1014 ''', 1015 'Add #include <limits> for numeric_limits<>' 1016 ' [build/include_what_you_use] [4]') 1017 self.assert_include_what_you_use( 1018 '''#include <limits> 1019 int i = numeric_limits<int>::max() 1020 ''', 1021 '') 1022 1023 # Test the UpdateIncludeState code path. 1024 mock_header_contents = ['#include "blah/foo.h"', '#include "blah/bar.h"'] 1025 fs = FileSystem() 1026 orig_read_text_file_fn = fs.read_text_file 1027 1028 def mock_read_text_file_fn(path): 1029 return mock_header_contents 1030 1031 try: 1032 fs.read_text_file = mock_read_text_file_fn 1033 message = self.perform_include_what_you_use( 1034 '#include "config.h"\n' 1035 '#include "blah/a.h"\n', 1036 filename='blah/a.cpp', 1037 fs=fs) 1038 self.assertEqual(message, '') 1039 1040 mock_header_contents = ['#include <set>'] 1041 message = self.perform_include_what_you_use( 1042 '''#include "config.h" 1043 #include "blah/a.h" 1044 1045 std::set<int> foo;''', 1046 filename='blah/a.cpp', 1047 fs=fs) 1048 self.assertEqual(message, '') 1049 1050 # If there's just a .cpp and the header can't be found then it's ok. 1051 message = self.perform_include_what_you_use( 1052 '''#include "config.h" 1053 #include "blah/a.h" 1054 1055 std::set<int> foo;''', 1056 filename='blah/a.cpp') 1057 self.assertEqual(message, '') 1058 1059 # Make sure we find the headers with relative paths. 1060 mock_header_contents = [''] 1061 message = self.perform_include_what_you_use( 1062 '''#include "config.h" 1063 #include "%s%sa.h" 1064 1065 std::set<int> foo;''' % (os.path.basename(os.getcwd()), os.path.sep), 1066 filename='a.cpp', 1067 fs=fs) 1068 self.assertEqual(message, 'Add #include <set> for set<> ' 1069 '[build/include_what_you_use] [4]') 1070 finally: 1071 fs.read_text_file = orig_read_text_file_fn 1072 1073 def test_files_belong_to_same_module(self): 1074 f = cpp_style.files_belong_to_same_module 1075 self.assertEqual((True, ''), f('a.cpp', 'a.h')) 1076 self.assertEqual((True, ''), f('base/google.cpp', 'base/google.h')) 1077 self.assertEqual((True, ''), f('base/google_test.cpp', 'base/google.h')) 1078 self.assertEqual((True, ''), 1079 f('base/google_unittest.cpp', 'base/google.h')) 1080 self.assertEqual((True, ''), 1081 f('base/internal/google_unittest.cpp', 1082 'base/public/google.h')) 1083 self.assertEqual((True, 'xxx/yyy/'), 1084 f('xxx/yyy/base/internal/google_unittest.cpp', 1085 'base/public/google.h')) 1086 self.assertEqual((True, 'xxx/yyy/'), 1087 f('xxx/yyy/base/google_unittest.cpp', 1088 'base/public/google.h')) 1089 self.assertEqual((True, ''), 1090 f('base/google_unittest.cpp', 'base/google-inl.h')) 1091 self.assertEqual((True, '/home/build/google3/'), 1092 f('/home/build/google3/base/google.cpp', 'base/google.h')) 1093 1094 self.assertEqual((False, ''), 1095 f('/home/build/google3/base/google.cpp', 'basu/google.h')) 1096 self.assertEqual((False, ''), f('a.cpp', 'b.h')) 1097 1098 def test_cleanse_line(self): 1099 self.assertEqual('int foo = 0; ', 1100 cpp_style.cleanse_comments('int foo = 0; // danger!')) 1101 self.assertEqual('int o = 0;', 1102 cpp_style.cleanse_comments('int /* foo */ o = 0;')) 1103 self.assertEqual('foo(int a, int b);', 1104 cpp_style.cleanse_comments('foo(int a /* abc */, int b);')) 1105 self.assertEqual('f(a, b);', 1106 cpp_style.cleanse_comments('f(a, /* name */ b);')) 1107 self.assertEqual('f(a, b);', 1108 cpp_style.cleanse_comments('f(a /* name */, b);')) 1109 self.assertEqual('f(a, b);', 1110 cpp_style.cleanse_comments('f(a, /* name */b);')) 1111 1112 def test_multi_line_comments(self): 1113 # missing explicit is bad 1114 self.assert_multi_line_lint( 1115 r'''int a = 0; 1116 /* multi-liner 1117 class Foo { 1118 Foo(int f); // should cause a lint warning in code 1119 } 1120 */ ''', 1121 '') 1122 self.assert_multi_line_lint( 1123 '''\ 1124 /* int a = 0; multi-liner 1125 static const int b = 0;''', 1126 ['Could not find end of multi-line comment' 1127 ' [readability/multiline_comment] [5]', 1128 'Complex multi-line /*...*/-style comment found. ' 1129 'Lint may give bogus warnings. Consider replacing these with ' 1130 '//-style comments, with #if 0...#endif, or with more clearly ' 1131 'structured multi-line comments. [readability/multiline_comment] [5]']) 1132 self.assert_multi_line_lint(r''' /* multi-line comment''', 1133 ['Could not find end of multi-line comment' 1134 ' [readability/multiline_comment] [5]', 1135 'Complex multi-line /*...*/-style comment found. ' 1136 'Lint may give bogus warnings. Consider replacing these with ' 1137 '//-style comments, with #if 0...#endif, or with more clearly ' 1138 'structured multi-line comments. [readability/multiline_comment] [5]']) 1139 self.assert_multi_line_lint(r''' // /* comment, but not multi-line''', '') 1140 1141 def test_multiline_strings(self): 1142 multiline_string_error_message = ( 1143 'Multi-line string ("...") found. This lint script doesn\'t ' 1144 'do well with such strings, and may give bogus warnings. They\'re ' 1145 'ugly and unnecessary, and you should use concatenation instead".' 1146 ' [readability/multiline_string] [5]') 1147 1148 file_path = 'mydir/foo.cpp' 1149 1150 error_collector = ErrorCollector(self.assertTrue) 1151 self.process_file_data(file_path, 'cpp', 1152 ['const char* str = "This is a\\', 1153 ' multiline string.";'], 1154 error_collector) 1155 self.assertEqual( 1156 2, # One per line. 1157 error_collector.result_list().count(multiline_string_error_message)) 1158 1159 # Test non-explicit single-argument constructors 1160 def test_explicit_single_argument_constructors(self): 1161 # missing explicit is bad 1162 self.assert_multi_line_lint( 1163 '''\ 1164 class Foo { 1165 Foo(int f); 1166 };''', 1167 'Single-argument constructors should be marked explicit.' 1168 ' [runtime/explicit] [5]') 1169 # missing explicit is bad, even with whitespace 1170 self.assert_multi_line_lint( 1171 '''\ 1172 class Foo { 1173 Foo (int f); 1174 };''', 1175 ['Extra space before ( in function call [whitespace/parens] [4]', 1176 'Single-argument constructors should be marked explicit.' 1177 ' [runtime/explicit] [5]']) 1178 # missing explicit, with distracting comment, is still bad 1179 self.assert_multi_line_lint( 1180 '''\ 1181 class Foo { 1182 Foo(int f); // simpler than Foo(blargh, blarg) 1183 };''', 1184 'Single-argument constructors should be marked explicit.' 1185 ' [runtime/explicit] [5]') 1186 # missing explicit, with qualified classname 1187 self.assert_multi_line_lint( 1188 '''\ 1189 class Qualifier::AnotherOne::Foo { 1190 Foo(int f); 1191 };''', 1192 'Single-argument constructors should be marked explicit.' 1193 ' [runtime/explicit] [5]') 1194 # structs are caught as well. 1195 self.assert_multi_line_lint( 1196 '''\ 1197 struct Foo { 1198 Foo(int f); 1199 };''', 1200 'Single-argument constructors should be marked explicit.' 1201 ' [runtime/explicit] [5]') 1202 # Templatized classes are caught as well. 1203 self.assert_multi_line_lint( 1204 '''\ 1205 template<typename T> class Foo { 1206 Foo(int f); 1207 };''', 1208 'Single-argument constructors should be marked explicit.' 1209 ' [runtime/explicit] [5]') 1210 # proper style is okay 1211 self.assert_multi_line_lint( 1212 '''\ 1213 class Foo { 1214 explicit Foo(int f); 1215 };''', 1216 '') 1217 # two argument constructor is okay 1218 self.assert_multi_line_lint( 1219 '''\ 1220 class Foo { 1221 Foo(int f, int b); 1222 };''', 1223 '') 1224 # two argument constructor, across two lines, is okay 1225 self.assert_multi_line_lint( 1226 '''\ 1227 class Foo { 1228 Foo(int f, 1229 int b); 1230 };''', 1231 '') 1232 # non-constructor (but similar name), is okay 1233 self.assert_multi_line_lint( 1234 '''\ 1235 class Foo { 1236 aFoo(int f); 1237 };''', 1238 '') 1239 # constructor with void argument is okay 1240 self.assert_multi_line_lint( 1241 '''\ 1242 class Foo { 1243 Foo(void); 1244 };''', 1245 '') 1246 # single argument method is okay 1247 self.assert_multi_line_lint( 1248 '''\ 1249 class Foo { 1250 Bar(int b); 1251 };''', 1252 '') 1253 # comments should be ignored 1254 self.assert_multi_line_lint( 1255 '''\ 1256 class Foo { 1257 // Foo(int f); 1258 };''', 1259 '') 1260 # single argument function following class definition is okay 1261 # (okay, it's not actually valid, but we don't want a false positive) 1262 self.assert_multi_line_lint( 1263 '''\ 1264 class Foo { 1265 Foo(int f, int b); 1266 }; 1267 Foo(int f);''', 1268 '') 1269 # single argument function is okay 1270 self.assert_multi_line_lint( 1271 '''static Foo(int f);''', 1272 '') 1273 # single argument copy constructor is okay. 1274 self.assert_multi_line_lint( 1275 '''\ 1276 class Foo { 1277 Foo(const Foo&); 1278 };''', 1279 '') 1280 self.assert_multi_line_lint( 1281 '''\ 1282 class Foo { 1283 Foo(Foo&); 1284 };''', 1285 '') 1286 1287 def test_slash_star_comment_on_single_line(self): 1288 self.assert_multi_line_lint( 1289 '''/* static */ Foo(int f);''', 1290 '') 1291 self.assert_multi_line_lint( 1292 '''/*/ static */ Foo(int f);''', 1293 '') 1294 self.assert_multi_line_lint( 1295 '''/*/ static Foo(int f);''', 1296 'Could not find end of multi-line comment' 1297 ' [readability/multiline_comment] [5]') 1298 self.assert_multi_line_lint( 1299 ''' /*/ static Foo(int f);''', 1300 'Could not find end of multi-line comment' 1301 ' [readability/multiline_comment] [5]') 1302 1303 # Test suspicious usage of "if" like this: 1304 # if (a == b) { 1305 # DoSomething(); 1306 # } if (a == c) { // Should be "else if". 1307 # DoSomething(); // This gets called twice if a == b && a == c. 1308 # } 1309 def test_suspicious_usage_of_if(self): 1310 self.assert_lint( 1311 ' if (a == b) {', 1312 '') 1313 self.assert_lint( 1314 ' } if (a == b) {', 1315 'Did you mean "else if"? If not, start a new line for "if".' 1316 ' [readability/braces] [4]') 1317 1318 # Test suspicious usage of memset. Specifically, a 0 1319 # as the final argument is almost certainly an error. 1320 def test_suspicious_usage_of_memset(self): 1321 # Normal use is okay. 1322 self.assert_lint( 1323 ' memset(buf, 0, sizeof(buf))', 1324 '') 1325 1326 # A 0 as the final argument is almost certainly an error. 1327 self.assert_lint( 1328 ' memset(buf, sizeof(buf), 0)', 1329 'Did you mean "memset(buf, 0, sizeof(buf))"?' 1330 ' [runtime/memset] [4]') 1331 self.assert_lint( 1332 ' memset(buf, xsize * ysize, 0)', 1333 'Did you mean "memset(buf, 0, xsize * ysize)"?' 1334 ' [runtime/memset] [4]') 1335 1336 # There is legitimate test code that uses this form. 1337 # This is okay since the second argument is a literal. 1338 self.assert_lint( 1339 " memset(buf, 'y', 0)", 1340 '') 1341 self.assert_lint( 1342 ' memset(buf, 4, 0)', 1343 '') 1344 self.assert_lint( 1345 ' memset(buf, -1, 0)', 1346 '') 1347 self.assert_lint( 1348 ' memset(buf, 0xF1, 0)', 1349 '') 1350 self.assert_lint( 1351 ' memset(buf, 0xcd, 0)', 1352 '') 1353 1354 def test_check_posix_threading(self): 1355 self.assert_lint('sctime_r()', '') 1356 self.assert_lint('strtok_r()', '') 1357 self.assert_lint(' strtok_r(foo, ba, r)', '') 1358 self.assert_lint('brand()', '') 1359 self.assert_lint('_rand()', '') 1360 self.assert_lint('.rand()', '') 1361 self.assert_lint('>rand()', '') 1362 self.assert_lint('rand()', 1363 'Consider using rand_r(...) instead of rand(...)' 1364 ' for improved thread safety.' 1365 ' [runtime/threadsafe_fn] [2]') 1366 self.assert_lint('strtok()', 1367 'Consider using strtok_r(...) ' 1368 'instead of strtok(...)' 1369 ' for improved thread safety.' 1370 ' [runtime/threadsafe_fn] [2]') 1371 1372 # Test potential format string bugs like printf(foo). 1373 def test_format_strings(self): 1374 self.assert_lint('printf("foo")', '') 1375 self.assert_lint('printf("foo: %s", foo)', '') 1376 self.assert_lint('DocidForPrintf(docid)', '') # Should not trigger. 1377 self.assert_lint( 1378 'printf(foo)', 1379 'Potential format string bug. Do printf("%s", foo) instead.' 1380 ' [runtime/printf] [4]') 1381 self.assert_lint( 1382 'printf(foo.c_str())', 1383 'Potential format string bug. ' 1384 'Do printf("%s", foo.c_str()) instead.' 1385 ' [runtime/printf] [4]') 1386 self.assert_lint( 1387 'printf(foo->c_str())', 1388 'Potential format string bug. ' 1389 'Do printf("%s", foo->c_str()) instead.' 1390 ' [runtime/printf] [4]') 1391 self.assert_lint( 1392 'StringPrintf(foo)', 1393 'Potential format string bug. Do StringPrintf("%s", foo) instead.' 1394 '' 1395 ' [runtime/printf] [4]') 1396 1397 # Variable-length arrays are not permitted. 1398 def test_variable_length_array_detection(self): 1399 errmsg = ('Do not use variable-length arrays. Use an appropriately named ' 1400 "('k' followed by CamelCase) compile-time constant for the size." 1401 ' [runtime/arrays] [1]') 1402 1403 self.assert_lint('int a[any_old_variable];', errmsg) 1404 self.assert_lint('int doublesize[some_var * 2];', errmsg) 1405 self.assert_lint('int a[afunction()];', errmsg) 1406 self.assert_lint('int a[function(kMaxFooBars)];', errmsg) 1407 self.assert_lint('bool aList[items_->size()];', errmsg) 1408 self.assert_lint('namespace::Type buffer[len+1];', errmsg) 1409 1410 self.assert_lint('int a[64];', '') 1411 self.assert_lint('int a[0xFF];', '') 1412 self.assert_lint('int first[256], second[256];', '') 1413 self.assert_lint('int arrayName[kCompileTimeConstant];', '') 1414 self.assert_lint('char buf[somenamespace::kBufSize];', '') 1415 self.assert_lint('int arrayName[ALL_CAPS];', '') 1416 self.assert_lint('AClass array1[foo::bar::ALL_CAPS];', '') 1417 self.assert_lint('int a[kMaxStrLen + 1];', '') 1418 self.assert_lint('int a[sizeof(foo)];', '') 1419 self.assert_lint('int a[sizeof(*foo)];', '') 1420 self.assert_lint('int a[sizeof foo];', '') 1421 self.assert_lint('int a[sizeof(struct Foo)];', '') 1422 self.assert_lint('int a[128 - sizeof(const bar)];', '') 1423 self.assert_lint('int a[(sizeof(foo) * 4)];', '') 1424 self.assert_lint('int a[(arraysize(fixed_size_array)/2) << 1];', 'Missing spaces around / [whitespace/operators] [3]') 1425 self.assert_lint('delete a[some_var];', '') 1426 self.assert_lint('return a[some_var];', '') 1427 1428 # Brace usage 1429 def test_braces(self): 1430 # Braces shouldn't be followed by a ; unless they're defining a struct 1431 # or initializing an array 1432 self.assert_lint('int a[3] = { 1, 2, 3 };', '') 1433 self.assert_lint( 1434 '''\ 1435 const int foo[] = 1436 {1, 2, 3 };''', 1437 '') 1438 # For single line, unmatched '}' with a ';' is ignored (not enough context) 1439 self.assert_multi_line_lint( 1440 '''\ 1441 int a[3] = { 1, 1442 2, 1443 3 };''', 1444 '') 1445 self.assert_multi_line_lint( 1446 '''\ 1447 int a[2][3] = { { 1, 2 }, 1448 { 3, 4 } };''', 1449 '') 1450 self.assert_multi_line_lint( 1451 '''\ 1452 int a[2][3] = 1453 { { 1, 2 }, 1454 { 3, 4 } };''', 1455 '') 1456 1457 # CHECK/EXPECT_TRUE/EXPECT_FALSE replacements 1458 def test_check_check(self): 1459 self.assert_lint('CHECK(x == 42)', 1460 'Consider using CHECK_EQ instead of CHECK(a == b)' 1461 ' [readability/check] [2]') 1462 self.assert_lint('CHECK(x != 42)', 1463 'Consider using CHECK_NE instead of CHECK(a != b)' 1464 ' [readability/check] [2]') 1465 self.assert_lint('CHECK(x >= 42)', 1466 'Consider using CHECK_GE instead of CHECK(a >= b)' 1467 ' [readability/check] [2]') 1468 self.assert_lint('CHECK(x > 42)', 1469 'Consider using CHECK_GT instead of CHECK(a > b)' 1470 ' [readability/check] [2]') 1471 self.assert_lint('CHECK(x <= 42)', 1472 'Consider using CHECK_LE instead of CHECK(a <= b)' 1473 ' [readability/check] [2]') 1474 self.assert_lint('CHECK(x < 42)', 1475 'Consider using CHECK_LT instead of CHECK(a < b)' 1476 ' [readability/check] [2]') 1477 1478 self.assert_lint('DCHECK(x == 42)', 1479 'Consider using DCHECK_EQ instead of DCHECK(a == b)' 1480 ' [readability/check] [2]') 1481 self.assert_lint('DCHECK(x != 42)', 1482 'Consider using DCHECK_NE instead of DCHECK(a != b)' 1483 ' [readability/check] [2]') 1484 self.assert_lint('DCHECK(x >= 42)', 1485 'Consider using DCHECK_GE instead of DCHECK(a >= b)' 1486 ' [readability/check] [2]') 1487 self.assert_lint('DCHECK(x > 42)', 1488 'Consider using DCHECK_GT instead of DCHECK(a > b)' 1489 ' [readability/check] [2]') 1490 self.assert_lint('DCHECK(x <= 42)', 1491 'Consider using DCHECK_LE instead of DCHECK(a <= b)' 1492 ' [readability/check] [2]') 1493 self.assert_lint('DCHECK(x < 42)', 1494 'Consider using DCHECK_LT instead of DCHECK(a < b)' 1495 ' [readability/check] [2]') 1496 1497 self.assert_lint( 1498 'EXPECT_TRUE("42" == x)', 1499 'Consider using EXPECT_EQ instead of EXPECT_TRUE(a == b)' 1500 ' [readability/check] [2]') 1501 self.assert_lint( 1502 'EXPECT_TRUE("42" != x)', 1503 'Consider using EXPECT_NE instead of EXPECT_TRUE(a != b)' 1504 ' [readability/check] [2]') 1505 self.assert_lint( 1506 'EXPECT_TRUE(+42 >= x)', 1507 'Consider using EXPECT_GE instead of EXPECT_TRUE(a >= b)' 1508 ' [readability/check] [2]') 1509 self.assert_lint( 1510 'EXPECT_TRUE_M(-42 > x)', 1511 'Consider using EXPECT_GT_M instead of EXPECT_TRUE_M(a > b)' 1512 ' [readability/check] [2]') 1513 self.assert_lint( 1514 'EXPECT_TRUE_M(42U <= x)', 1515 'Consider using EXPECT_LE_M instead of EXPECT_TRUE_M(a <= b)' 1516 ' [readability/check] [2]') 1517 self.assert_lint( 1518 'EXPECT_TRUE_M(42L < x)', 1519 'Consider using EXPECT_LT_M instead of EXPECT_TRUE_M(a < b)' 1520 ' [readability/check] [2]') 1521 1522 self.assert_lint( 1523 'EXPECT_FALSE(x == 42)', 1524 'Consider using EXPECT_NE instead of EXPECT_FALSE(a == b)' 1525 ' [readability/check] [2]') 1526 self.assert_lint( 1527 'EXPECT_FALSE(x != 42)', 1528 'Consider using EXPECT_EQ instead of EXPECT_FALSE(a != b)' 1529 ' [readability/check] [2]') 1530 self.assert_lint( 1531 'EXPECT_FALSE(x >= 42)', 1532 'Consider using EXPECT_LT instead of EXPECT_FALSE(a >= b)' 1533 ' [readability/check] [2]') 1534 self.assert_lint( 1535 'ASSERT_FALSE(x > 42)', 1536 'Consider using ASSERT_LE instead of ASSERT_FALSE(a > b)' 1537 ' [readability/check] [2]') 1538 self.assert_lint( 1539 'ASSERT_FALSE(x <= 42)', 1540 'Consider using ASSERT_GT instead of ASSERT_FALSE(a <= b)' 1541 ' [readability/check] [2]') 1542 self.assert_lint( 1543 'ASSERT_FALSE_M(x < 42)', 1544 'Consider using ASSERT_GE_M instead of ASSERT_FALSE_M(a < b)' 1545 ' [readability/check] [2]') 1546 1547 self.assert_lint('CHECK(some_iterator == obj.end())', '') 1548 self.assert_lint('EXPECT_TRUE(some_iterator == obj.end())', '') 1549 self.assert_lint('EXPECT_FALSE(some_iterator == obj.end())', '') 1550 1551 self.assert_lint('CHECK(CreateTestFile(dir, (1 << 20)));', '') 1552 self.assert_lint('CHECK(CreateTestFile(dir, (1 >> 20)));', '') 1553 1554 self.assert_lint('CHECK(x<42)', 1555 ['Missing spaces around <' 1556 ' [whitespace/operators] [3]', 1557 'Consider using CHECK_LT instead of CHECK(a < b)' 1558 ' [readability/check] [2]']) 1559 self.assert_lint('CHECK(x>42)', 1560 'Consider using CHECK_GT instead of CHECK(a > b)' 1561 ' [readability/check] [2]') 1562 1563 self.assert_lint( 1564 ' EXPECT_TRUE(42 < x) // Random comment.', 1565 'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)' 1566 ' [readability/check] [2]') 1567 self.assert_lint( 1568 'EXPECT_TRUE( 42 < x )', 1569 ['Extra space after ( in function call' 1570 ' [whitespace/parens] [4]', 1571 'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)' 1572 ' [readability/check] [2]']) 1573 self.assert_lint( 1574 'CHECK("foo" == "foo")', 1575 'Consider using CHECK_EQ instead of CHECK(a == b)' 1576 ' [readability/check] [2]') 1577 1578 self.assert_lint('CHECK_EQ("foo", "foo")', '') 1579 1580 def test_brace_at_begin_of_line(self): 1581 self.assert_lint('{', 1582 'This { should be at the end of the previous line' 1583 ' [whitespace/braces] [4]') 1584 self.assert_multi_line_lint( 1585 '#endif\n' 1586 '{\n' 1587 '}\n', 1588 '') 1589 self.assert_multi_line_lint( 1590 'if (condition) {', 1591 '') 1592 self.assert_multi_line_lint( 1593 ' MACRO1(macroArg) {', 1594 '') 1595 self.assert_multi_line_lint( 1596 'ACCESSOR_GETTER(MessageEventPorts) {', 1597 'Place brace on its own line for function definitions. [whitespace/braces] [4]') 1598 self.assert_multi_line_lint( 1599 'int foo() {', 1600 'Place brace on its own line for function definitions. [whitespace/braces] [4]') 1601 self.assert_multi_line_lint( 1602 'int foo() const {', 1603 'Place brace on its own line for function definitions. [whitespace/braces] [4]') 1604 self.assert_multi_line_lint( 1605 'int foo() const OVERRIDE {', 1606 'Place brace on its own line for function definitions. [whitespace/braces] [4]') 1607 self.assert_multi_line_lint( 1608 'int foo() OVERRIDE {', 1609 'Place brace on its own line for function definitions. [whitespace/braces] [4]') 1610 self.assert_multi_line_lint( 1611 'int foo() const\n' 1612 '{\n' 1613 '}\n', 1614 '') 1615 self.assert_multi_line_lint( 1616 'int foo() OVERRIDE\n' 1617 '{\n' 1618 '}\n', 1619 '') 1620 self.assert_multi_line_lint( 1621 'if (condition\n' 1622 ' && condition2\n' 1623 ' && condition3) {\n' 1624 '}\n', 1625 '') 1626 1627 def test_mismatching_spaces_in_parens(self): 1628 self.assert_lint('if (foo ) {', 'Extra space before ) in if' 1629 ' [whitespace/parens] [5]') 1630 self.assert_lint('switch ( foo) {', 'Extra space after ( in switch' 1631 ' [whitespace/parens] [5]') 1632 self.assert_lint('for (foo; ba; bar ) {', 'Extra space before ) in for' 1633 ' [whitespace/parens] [5]') 1634 self.assert_lint('for ((foo); (ba); (bar) ) {', 'Extra space before ) in for' 1635 ' [whitespace/parens] [5]') 1636 self.assert_lint('for (; foo; bar) {', '') 1637 self.assert_lint('for (; (foo); (bar)) {', '') 1638 self.assert_lint('for ( ; foo; bar) {', '') 1639 self.assert_lint('for ( ; (foo); (bar)) {', '') 1640 self.assert_lint('for ( ; foo; bar ) {', 'Extra space before ) in for' 1641 ' [whitespace/parens] [5]') 1642 self.assert_lint('for ( ; (foo); (bar) ) {', 'Extra space before ) in for' 1643 ' [whitespace/parens] [5]') 1644 self.assert_lint('for (foo; bar; ) {', '') 1645 self.assert_lint('for ((foo); (bar); ) {', '') 1646 self.assert_lint('foreach (foo, foos ) {', 'Extra space before ) in foreach' 1647 ' [whitespace/parens] [5]') 1648 self.assert_lint('foreach ( foo, foos) {', 'Extra space after ( in foreach' 1649 ' [whitespace/parens] [5]') 1650 self.assert_lint('while ( foo) {', 'Extra space after ( in while' 1651 ' [whitespace/parens] [5]') 1652 1653 def test_spacing_for_fncall(self): 1654 self.assert_lint('if (foo) {', '') 1655 self.assert_lint('for (foo;bar;baz) {', '') 1656 self.assert_lint('foreach (foo, foos) {', '') 1657 self.assert_lint('while (foo) {', '') 1658 self.assert_lint('switch (foo) {', '') 1659 self.assert_lint('new (RenderArena()) RenderInline(document())', '') 1660 self.assert_lint('foo( bar)', 'Extra space after ( in function call' 1661 ' [whitespace/parens] [4]') 1662 self.assert_lint('foobar( \\', '') 1663 self.assert_lint('foobar( \\', '') 1664 self.assert_lint('( a + b)', 'Extra space after (' 1665 ' [whitespace/parens] [2]') 1666 self.assert_lint('((a+b))', '') 1667 self.assert_lint('foo (foo)', 'Extra space before ( in function call' 1668 ' [whitespace/parens] [4]') 1669 self.assert_lint('#elif (foo(bar))', '') 1670 self.assert_lint('#elif (foo(bar) && foo(baz))', '') 1671 self.assert_lint('typedef foo (*foo)(foo)', '') 1672 self.assert_lint('typedef foo (*foo12bar_)(foo)', '') 1673 self.assert_lint('typedef foo (Foo::*bar)(foo)', '') 1674 self.assert_lint('foo (Foo::*bar)(', 1675 'Extra space before ( in function call' 1676 ' [whitespace/parens] [4]') 1677 self.assert_lint('typedef foo (Foo::*bar)(', '') 1678 self.assert_lint('(foo)(bar)', '') 1679 self.assert_lint('Foo (*foo)(bar)', '') 1680 self.assert_lint('Foo (*foo)(Bar bar,', '') 1681 self.assert_lint('char (*p)[sizeof(foo)] = &foo', '') 1682 self.assert_lint('char (&ref)[sizeof(foo)] = &foo', '') 1683 self.assert_lint('const char32 (*table[])[6];', '') 1684 1685 def test_spacing_before_braces(self): 1686 self.assert_lint('if (foo){', 'Missing space before {' 1687 ' [whitespace/braces] [5]') 1688 self.assert_lint('for{', 'Missing space before {' 1689 ' [whitespace/braces] [5]') 1690 self.assert_lint('for {', '') 1691 self.assert_lint('EXPECT_DEBUG_DEATH({', '') 1692 1693 def test_spacing_between_braces(self): 1694 self.assert_lint(' { }', '') 1695 self.assert_lint(' {}', 'Missing space inside { }. [whitespace/braces] [5]') 1696 self.assert_lint(' { }', 'Too many spaces inside { }. [whitespace/braces] [5]') 1697 1698 def test_spacing_around_else(self): 1699 self.assert_lint('}else {', 'Missing space before else' 1700 ' [whitespace/braces] [5]') 1701 self.assert_lint('} else{', 'Missing space before {' 1702 ' [whitespace/braces] [5]') 1703 self.assert_lint('} else {', '') 1704 self.assert_lint('} else if', '') 1705 1706 def test_spacing_for_binary_ops(self): 1707 self.assert_lint('if (foo<=bar) {', 'Missing spaces around <=' 1708 ' [whitespace/operators] [3]') 1709 self.assert_lint('if (foo<bar) {', 'Missing spaces around <' 1710 ' [whitespace/operators] [3]') 1711 self.assert_lint('if (foo<bar->baz) {', 'Missing spaces around <' 1712 ' [whitespace/operators] [3]') 1713 self.assert_lint('if (foo<bar->bar) {', 'Missing spaces around <' 1714 ' [whitespace/operators] [3]') 1715 self.assert_lint('typedef hash_map<Foo, Bar', 'Missing spaces around <' 1716 ' [whitespace/operators] [3]') 1717 self.assert_lint('typedef hash_map<FoooooType, BaaaaarType,', '') 1718 self.assert_lint('a<Foo> t+=b;', 'Missing spaces around +=' 1719 ' [whitespace/operators] [3]') 1720 self.assert_lint('a<Foo> t-=b;', 'Missing spaces around -=' 1721 ' [whitespace/operators] [3]') 1722 self.assert_lint('a<Foo*> t*=b;', 'Missing spaces around *=' 1723 ' [whitespace/operators] [3]') 1724 self.assert_lint('a<Foo*> t/=b;', 'Missing spaces around /=' 1725 ' [whitespace/operators] [3]') 1726 self.assert_lint('a<Foo*> t|=b;', 'Missing spaces around |=' 1727 ' [whitespace/operators] [3]') 1728 self.assert_lint('a<Foo*> t&=b;', 'Missing spaces around &=' 1729 ' [whitespace/operators] [3]') 1730 self.assert_lint('a<Foo*> t<<=b;', 'Missing spaces around <<=' 1731 ' [whitespace/operators] [3]') 1732 self.assert_lint('a<Foo*> t>>=b;', 'Missing spaces around >>=' 1733 ' [whitespace/operators] [3]') 1734 self.assert_lint('a<Foo*> t>>=&b|c;', 'Missing spaces around >>=' 1735 ' [whitespace/operators] [3]') 1736 self.assert_lint('a<Foo*> t<<=*b/c;', 'Missing spaces around <<=' 1737 ' [whitespace/operators] [3]') 1738 self.assert_lint('a<Foo> t -= b;', '') 1739 self.assert_lint('a<Foo> t += b;', '') 1740 self.assert_lint('a<Foo*> t *= b;', '') 1741 self.assert_lint('a<Foo*> t /= b;', '') 1742 self.assert_lint('a<Foo*> t |= b;', '') 1743 self.assert_lint('a<Foo*> t &= b;', '') 1744 self.assert_lint('a<Foo*> t <<= b;', '') 1745 self.assert_lint('a<Foo*> t >>= b;', '') 1746 self.assert_lint('a<Foo*> t >>= &b|c;', 'Missing spaces around |' 1747 ' [whitespace/operators] [3]') 1748 self.assert_lint('a<Foo*> t <<= *b/c;', 'Missing spaces around /' 1749 ' [whitespace/operators] [3]') 1750 self.assert_lint('a<Foo*> t <<= b/c; //Test', [ 1751 'Should have a space between // and comment ' 1752 '[whitespace/comments] [4]', 'Missing' 1753 ' spaces around / [whitespace/operators] [3]']) 1754 self.assert_lint('a<Foo*> t <<= b||c; //Test', ['One space before end' 1755 ' of line comments [whitespace/comments] [5]', 1756 'Should have a space between // and comment ' 1757 '[whitespace/comments] [4]', 1758 'Missing spaces around || [whitespace/operators] [3]']) 1759 self.assert_lint('a<Foo*> t <<= b&&c; // Test', 'Missing spaces around' 1760 ' && [whitespace/operators] [3]') 1761 self.assert_lint('a<Foo*> t <<= b&&&c; // Test', 'Missing spaces around' 1762 ' && [whitespace/operators] [3]') 1763 self.assert_lint('a<Foo*> t <<= b&&*c; // Test', 'Missing spaces around' 1764 ' && [whitespace/operators] [3]') 1765 self.assert_lint('a<Foo*> t <<= b && *c; // Test', '') 1766 self.assert_lint('a<Foo*> t <<= b && &c; // Test', '') 1767 self.assert_lint('a<Foo*> t <<= b || &c; /*Test', 'Complex multi-line ' 1768 '/*...*/-style comment found. Lint may give bogus ' 1769 'warnings. Consider replacing these with //-style' 1770 ' comments, with #if 0...#endif, or with more clearly' 1771 ' structured multi-line comments. [readability/multiline_comment] [5]') 1772 self.assert_lint('a<Foo&> t <<= &b | &c;', '') 1773 self.assert_lint('a<Foo*> t <<= &b & &c; // Test', '') 1774 self.assert_lint('a<Foo*> t <<= *b / &c; // Test', '') 1775 self.assert_lint('if (a=b == 1)', 'Missing spaces around = [whitespace/operators] [4]') 1776 self.assert_lint('a = 1<<20', 'Missing spaces around << [whitespace/operators] [3]') 1777 self.assert_lint('if (a = b == 1)', '') 1778 self.assert_lint('a = 1 << 20', '') 1779 self.assert_multi_line_lint('#include <sys/io.h>\n', '') 1780 self.assert_multi_line_lint('#import <foo/bar.h>\n', '') 1781 1782 def test_operator_methods(self): 1783 self.assert_lint('String operator+(const String&, const String&);', '') 1784 self.assert_lint('String operator/(const String&, const String&);', '') 1785 self.assert_lint('bool operator==(const String&, const String&);', '') 1786 self.assert_lint('String& operator-=(const String&, const String&);', '') 1787 self.assert_lint('String& operator+=(const String&, const String&);', '') 1788 self.assert_lint('String& operator*=(const String&, const String&);', '') 1789 self.assert_lint('String& operator%=(const String&, const String&);', '') 1790 self.assert_lint('String& operator&=(const String&, const String&);', '') 1791 self.assert_lint('String& operator<<=(const String&, const String&);', '') 1792 self.assert_lint('String& operator>>=(const String&, const String&);', '') 1793 self.assert_lint('String& operator|=(const String&, const String&);', '') 1794 self.assert_lint('String& operator^=(const String&, const String&);', '') 1795 1796 def test_spacing_before_last_semicolon(self): 1797 self.assert_lint('call_function() ;', 1798 'Extra space before last semicolon. If this should be an ' 1799 'empty statement, use { } instead.' 1800 ' [whitespace/semicolon] [5]') 1801 self.assert_lint('while (true) ;', 1802 'Extra space before last semicolon. If this should be an ' 1803 'empty statement, use { } instead.' 1804 ' [whitespace/semicolon] [5]') 1805 self.assert_lint('default:;', 1806 'Semicolon defining empty statement. Use { } instead.' 1807 ' [whitespace/semicolon] [5]') 1808 self.assert_lint(' ;', 1809 'Line contains only semicolon. If this should be an empty ' 1810 'statement, use { } instead.' 1811 ' [whitespace/semicolon] [5]') 1812 self.assert_lint('for (int i = 0; ;', '') 1813 1814 # Static or global STL strings. 1815 def test_static_or_global_stlstrings(self): 1816 self.assert_lint('string foo;', 1817 'For a static/global string constant, use a C style ' 1818 'string instead: "char foo[]".' 1819 ' [runtime/string] [4]') 1820 self.assert_lint('string kFoo = "hello"; // English', 1821 'For a static/global string constant, use a C style ' 1822 'string instead: "char kFoo[]".' 1823 ' [runtime/string] [4]') 1824 self.assert_lint('static string foo;', 1825 'For a static/global string constant, use a C style ' 1826 'string instead: "static char foo[]".' 1827 ' [runtime/string] [4]') 1828 self.assert_lint('static const string foo;', 1829 'For a static/global string constant, use a C style ' 1830 'string instead: "static const char foo[]".' 1831 ' [runtime/string] [4]') 1832 self.assert_lint('string Foo::bar;', 1833 'For a static/global string constant, use a C style ' 1834 'string instead: "char Foo::bar[]".' 1835 ' [runtime/string] [4]') 1836 # Rare case. 1837 self.assert_lint('string foo("foobar");', 1838 'For a static/global string constant, use a C style ' 1839 'string instead: "char foo[]".' 1840 ' [runtime/string] [4]') 1841 # Should not catch local or member variables. 1842 self.assert_lint(' string foo', '') 1843 # Should not catch functions. 1844 self.assert_lint('string EmptyString() { return ""; }', '') 1845 self.assert_lint('string EmptyString () { return ""; }', '') 1846 self.assert_lint('string VeryLongNameFunctionSometimesEndsWith(\n' 1847 ' VeryLongNameType veryLongNameVariable) { }', '') 1848 self.assert_lint('template<>\n' 1849 'string FunctionTemplateSpecialization<SomeType>(\n' 1850 ' int x) { return ""; }', '') 1851 self.assert_lint('template<>\n' 1852 'string FunctionTemplateSpecialization<vector<A::B>* >(\n' 1853 ' int x) { return ""; }', '') 1854 1855 # should not catch methods of template classes. 1856 self.assert_lint('string Class<Type>::Method() const\n' 1857 '{\n' 1858 ' return "";\n' 1859 '}\n', '') 1860 self.assert_lint('string Class<Type>::Method(\n' 1861 ' int arg) const\n' 1862 '{\n' 1863 ' return "";\n' 1864 '}\n', '') 1865 1866 def test_no_spaces_in_function_calls(self): 1867 self.assert_lint('TellStory(1, 3);', 1868 '') 1869 self.assert_lint('TellStory(1, 3 );', 1870 'Extra space before )' 1871 ' [whitespace/parens] [2]') 1872 self.assert_lint('TellStory(1 /* wolf */, 3 /* pigs */);', 1873 '') 1874 self.assert_multi_line_lint('#endif\n );', 1875 '') 1876 1877 def test_one_spaces_between_code_and_comments(self): 1878 self.assert_lint('} // namespace foo', 1879 '') 1880 self.assert_lint('}// namespace foo', 1881 'One space before end of line comments' 1882 ' [whitespace/comments] [5]') 1883 self.assert_lint('printf("foo"); // Outside quotes.', 1884 '') 1885 self.assert_lint('int i = 0; // Having one space is fine.','') 1886 self.assert_lint('int i = 0; // Having two spaces is bad.', 1887 'One space before end of line comments' 1888 ' [whitespace/comments] [5]') 1889 self.assert_lint('int i = 0; // Having three spaces is bad.', 1890 'One space before end of line comments' 1891 ' [whitespace/comments] [5]') 1892 self.assert_lint('// Top level comment', '') 1893 self.assert_lint(' // Line starts with four spaces.', '') 1894 self.assert_lint('foo();\n' 1895 '{ // A scope is opening.', '') 1896 self.assert_lint(' foo();\n' 1897 ' { // An indented scope is opening.', '') 1898 self.assert_lint('if (foo) { // not a pure scope', 1899 '') 1900 self.assert_lint('printf("// In quotes.")', '') 1901 self.assert_lint('printf("\\"%s // In quotes.")', '') 1902 self.assert_lint('printf("%s", "// In quotes.")', '') 1903 1904 def test_one_spaces_after_punctuation_in_comments(self): 1905 self.assert_lint('int a; // This is a sentence.', 1906 '') 1907 self.assert_lint('int a; // This is a sentence. ', 1908 'Line ends in whitespace. Consider deleting these extra spaces. [whitespace/end_of_line] [4]') 1909 self.assert_lint('int a; // This is a sentence. This is a another sentence.', 1910 '') 1911 self.assert_lint('int a; // This is a sentence. This is a another sentence.', 1912 'Should have only a single space after a punctuation in a comment. [whitespace/comments] [5]') 1913 self.assert_lint('int a; // This is a sentence! This is a another sentence.', 1914 'Should have only a single space after a punctuation in a comment. [whitespace/comments] [5]') 1915 self.assert_lint('int a; // Why did I write this? This is a another sentence.', 1916 'Should have only a single space after a punctuation in a comment. [whitespace/comments] [5]') 1917 self.assert_lint('int a; // Elementary, my dear.', 1918 'Should have only a single space after a punctuation in a comment. [whitespace/comments] [5]') 1919 self.assert_lint('int a; // The following should be clear: Is it?', 1920 'Should have only a single space after a punctuation in a comment. [whitespace/comments] [5]') 1921 self.assert_lint('int a; // Look at the follow semicolon; I hope this gives an error.', 1922 'Should have only a single space after a punctuation in a comment. [whitespace/comments] [5]') 1923 1924 def test_space_after_comment_marker(self): 1925 self.assert_lint('//', '') 1926 self.assert_lint('//x', 'Should have a space between // and comment' 1927 ' [whitespace/comments] [4]') 1928 self.assert_lint('// x', '') 1929 self.assert_lint('//----', '') 1930 self.assert_lint('//====', '') 1931 self.assert_lint('//////', '') 1932 self.assert_lint('////// x', '') 1933 self.assert_lint('/// x', '') 1934 self.assert_lint('////x', 'Should have a space between // and comment' 1935 ' [whitespace/comments] [4]') 1936 1937 def test_newline_at_eof(self): 1938 def do_test(self, data, is_missing_eof): 1939 error_collector = ErrorCollector(self.assertTrue) 1940 self.process_file_data('foo.cpp', 'cpp', data.split('\n'), 1941 error_collector) 1942 # The warning appears only once. 1943 self.assertEqual( 1944 int(is_missing_eof), 1945 error_collector.results().count( 1946 'Could not find a newline character at the end of the file.' 1947 ' [whitespace/ending_newline] [5]')) 1948 1949 do_test(self, '// Newline\n// at EOF\n', False) 1950 do_test(self, '// No newline\n// at EOF', True) 1951 1952 def test_invalid_utf8(self): 1953 def do_test(self, raw_bytes, has_invalid_utf8): 1954 error_collector = ErrorCollector(self.assertTrue) 1955 self.process_file_data('foo.cpp', 'cpp', 1956 unicode(raw_bytes, 'utf8', 'replace').split('\n'), 1957 error_collector) 1958 # The warning appears only once. 1959 self.assertEqual( 1960 int(has_invalid_utf8), 1961 error_collector.results().count( 1962 'Line contains invalid UTF-8' 1963 ' (or Unicode replacement character).' 1964 ' [readability/utf8] [5]')) 1965 1966 do_test(self, 'Hello world\n', False) 1967 do_test(self, '\xe9\x8e\xbd\n', False) 1968 do_test(self, '\xe9x\x8e\xbd\n', True) 1969 # This is the encoding of the replacement character itself (which 1970 # you can see by evaluating codecs.getencoder('utf8')(u'\ufffd')). 1971 do_test(self, '\xef\xbf\xbd\n', True) 1972 1973 def test_is_blank_line(self): 1974 self.assertTrue(cpp_style.is_blank_line('')) 1975 self.assertTrue(cpp_style.is_blank_line(' ')) 1976 self.assertTrue(cpp_style.is_blank_line(' \t\r\n')) 1977 self.assertTrue(not cpp_style.is_blank_line('int a;')) 1978 self.assertTrue(not cpp_style.is_blank_line('{')) 1979 1980 def test_blank_lines_check(self): 1981 self.assert_blank_lines_check(['{\n', '\n', '\n', '}\n'], 1, 1) 1982 self.assert_blank_lines_check([' if (foo) {\n', '\n', ' }\n'], 1, 1) 1983 self.assert_blank_lines_check( 1984 ['\n', '// {\n', '\n', '\n', '// Comment\n', '{\n', '}\n'], 0, 0) 1985 self.assert_blank_lines_check(['\n', 'run("{");\n', '\n'], 0, 0) 1986 self.assert_blank_lines_check(['\n', ' if (foo) { return 0; }\n', '\n'], 0, 0) 1987 1988 def test_allow_blank_line_before_closing_namespace(self): 1989 error_collector = ErrorCollector(self.assertTrue) 1990 self.process_file_data('foo.cpp', 'cpp', 1991 ['namespace {', '', '} // namespace'], 1992 error_collector) 1993 self.assertEqual(0, error_collector.results().count( 1994 'Blank line at the end of a code block. Is this needed?' 1995 ' [whitespace/blank_line] [3]')) 1996 1997 def test_allow_blank_line_before_if_else_chain(self): 1998 error_collector = ErrorCollector(self.assertTrue) 1999 self.process_file_data('foo.cpp', 'cpp', 2000 ['if (hoge) {', 2001 '', # No warning 2002 '} else if (piyo) {', 2003 '', # No warning 2004 '} else if (piyopiyo) {', 2005 ' hoge = true;', # No warning 2006 '} else {', 2007 '', # Warning on this line 2008 '}'], 2009 error_collector) 2010 self.assertEqual(1, error_collector.results().count( 2011 'Blank line at the end of a code block. Is this needed?' 2012 ' [whitespace/blank_line] [3]')) 2013 2014 def test_else_on_same_line_as_closing_braces(self): 2015 error_collector = ErrorCollector(self.assertTrue) 2016 self.process_file_data('foo.cpp', 'cpp', 2017 ['if (hoge) {', 2018 '', 2019 '}', 2020 ' else {' # Warning on this line 2021 '', 2022 '}'], 2023 error_collector) 2024 self.assertEqual(1, error_collector.results().count( 2025 'An else should appear on the same line as the preceding }' 2026 ' [whitespace/newline] [4]')) 2027 2028 def test_else_clause_not_on_same_line_as_else(self): 2029 self.assert_lint(' else DoSomethingElse();', 2030 'Else clause should never be on same line as else ' 2031 '(use 2 lines) [whitespace/newline] [4]') 2032 self.assert_lint(' else ifDoSomethingElse();', 2033 'Else clause should never be on same line as else ' 2034 '(use 2 lines) [whitespace/newline] [4]') 2035 self.assert_lint(' else if (blah) {', '') 2036 self.assert_lint(' variable_ends_in_else = true;', '') 2037 2038 def test_comma(self): 2039 self.assert_lint('a = f(1,2);', 2040 'Missing space after , [whitespace/comma] [3]') 2041 self.assert_lint('int tmp=a,a=b,b=tmp;', 2042 ['Missing spaces around = [whitespace/operators] [4]', 2043 'Missing space after , [whitespace/comma] [3]']) 2044 self.assert_lint('f(a, /* name */ b);', '') 2045 self.assert_lint('f(a, /* name */b);', '') 2046 2047 def test_declaration(self): 2048 self.assert_lint('int a;', '') 2049 self.assert_lint('int a;', 'Extra space between int and a [whitespace/declaration] [3]') 2050 self.assert_lint('int* a;', 'Extra space between int* and a [whitespace/declaration] [3]') 2051 self.assert_lint('else if { }', '') 2052 self.assert_lint('else if { }', 'Extra space between else and if [whitespace/declaration] [3]') 2053 2054 def test_pointer_reference_marker_location(self): 2055 self.assert_lint('int* b;', '', 'foo.cpp') 2056 self.assert_lint('int *b;', 2057 'Declaration has space between type name and * in int *b [whitespace/declaration] [3]', 2058 'foo.cpp') 2059 self.assert_lint('return *b;', '', 'foo.cpp') 2060 self.assert_lint('delete *b;', '', 'foo.cpp') 2061 self.assert_lint('int *b;', '', 'foo.c') 2062 self.assert_lint('int* b;', 2063 'Declaration has space between * and variable name in int* b [whitespace/declaration] [3]', 2064 'foo.c') 2065 self.assert_lint('int& b;', '', 'foo.cpp') 2066 self.assert_lint('int &b;', 2067 'Declaration has space between type name and & in int &b [whitespace/declaration] [3]', 2068 'foo.cpp') 2069 self.assert_lint('return &b;', '', 'foo.cpp') 2070 2071 def test_indent(self): 2072 self.assert_lint('static int noindent;', '') 2073 self.assert_lint(' int fourSpaceIndent;', '') 2074 self.assert_lint(' int oneSpaceIndent;', 2075 'Weird number of spaces at line-start. ' 2076 'Are you using a 4-space indent? [whitespace/indent] [3]') 2077 self.assert_lint(' int threeSpaceIndent;', 2078 'Weird number of spaces at line-start. ' 2079 'Are you using a 4-space indent? [whitespace/indent] [3]') 2080 self.assert_lint(' char* oneSpaceIndent = "public:";', 2081 'Weird number of spaces at line-start. ' 2082 'Are you using a 4-space indent? [whitespace/indent] [3]') 2083 self.assert_lint(' public:', 2084 'Weird number of spaces at line-start. ' 2085 'Are you using a 4-space indent? [whitespace/indent] [3]') 2086 self.assert_lint(' public:', 2087 'Weird number of spaces at line-start. ' 2088 'Are you using a 4-space indent? [whitespace/indent] [3]') 2089 self.assert_lint(' public:', 2090 'Weird number of spaces at line-start. ' 2091 'Are you using a 4-space indent? [whitespace/indent] [3]') 2092 self.assert_multi_line_lint( 2093 'class Foo {\n' 2094 'public:\n' 2095 ' enum Bar {\n' 2096 ' Alpha,\n' 2097 ' Beta,\n' 2098 '#if ENABLED_BETZ\n' 2099 ' Charlie,\n' 2100 '#endif\n' 2101 ' };\n' 2102 '};', 2103 '') 2104 self.assert_multi_line_lint( 2105 'if (true) {\n' 2106 ' myFunction(reallyLongParam1, reallyLongParam2,\n' 2107 ' reallyLongParam3);\n' 2108 '}\n', 2109 'Weird number of spaces at line-start. Are you using a 4-space indent? [whitespace/indent] [3]') 2110 2111 self.assert_multi_line_lint( 2112 'if (true) {\n' 2113 ' myFunction(reallyLongParam1, reallyLongParam2,\n' 2114 ' reallyLongParam3);\n' 2115 '}\n', 2116 'When wrapping a line, only indent 4 spaces. [whitespace/indent] [3]') 2117 2118 2119 def test_not_alabel(self): 2120 self.assert_lint('MyVeryLongNamespace::MyVeryLongClassName::', '') 2121 2122 def test_tab(self): 2123 self.assert_lint('\tint a;', 2124 'Tab found; better to use spaces [whitespace/tab] [1]') 2125 self.assert_lint('int a = 5;\t// set a to 5', 2126 'Tab found; better to use spaces [whitespace/tab] [1]') 2127 2128 def test_unnamed_namespaces_in_headers(self): 2129 self.assert_language_rules_check( 2130 'foo.h', 'namespace {', 2131 'Do not use unnamed namespaces in header files. See' 2132 ' http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces' 2133 ' for more information. [build/namespaces] [4]') 2134 # namespace registration macros are OK. 2135 self.assert_language_rules_check('foo.h', 'namespace { \\', '') 2136 # named namespaces are OK. 2137 self.assert_language_rules_check('foo.h', 'namespace foo {', '') 2138 self.assert_language_rules_check('foo.h', 'namespace foonamespace {', '') 2139 self.assert_language_rules_check('foo.cpp', 'namespace {', '') 2140 self.assert_language_rules_check('foo.cpp', 'namespace foo {', '') 2141 2142 def test_build_class(self): 2143 # Test that the linter can parse to the end of class definitions, 2144 # and that it will report when it can't. 2145 # Use multi-line linter because it performs the ClassState check. 2146 self.assert_multi_line_lint( 2147 'class Foo {', 2148 'Failed to find complete declaration of class Foo' 2149 ' [build/class] [5]') 2150 # Don't warn on forward declarations of various types. 2151 self.assert_multi_line_lint( 2152 'class Foo;', 2153 '') 2154 self.assert_multi_line_lint( 2155 '''\ 2156 struct Foo* 2157 foo = NewFoo();''', 2158 '') 2159 # Here is an example where the linter gets confused, even though 2160 # the code doesn't violate the style guide. 2161 self.assert_multi_line_lint( 2162 'class Foo\n' 2163 '#ifdef DERIVE_FROM_GOO\n' 2164 ' : public Goo {\n' 2165 '#else\n' 2166 ' : public Hoo {\n' 2167 '#endif\n' 2168 '};', 2169 'Failed to find complete declaration of class Foo' 2170 ' [build/class] [5]') 2171 2172 def test_build_end_comment(self): 2173 # The crosstool compiler we currently use will fail to compile the 2174 # code in this test, so we might consider removing the lint check. 2175 self.assert_lint('#endif Not a comment', 2176 'Uncommented text after #endif is non-standard.' 2177 ' Use a comment.' 2178 ' [build/endif_comment] [5]') 2179 2180 def test_build_forward_decl(self): 2181 # The crosstool compiler we currently use will fail to compile the 2182 # code in this test, so we might consider removing the lint check. 2183 self.assert_lint('class Foo::Goo;', 2184 'Inner-style forward declarations are invalid.' 2185 ' Remove this line.' 2186 ' [build/forward_decl] [5]') 2187 2188 def test_build_header_guard(self): 2189 file_path = 'mydir/Foo.h' 2190 2191 # We can't rely on our internal stuff to get a sane path on the open source 2192 # side of things, so just parse out the suggested header guard. This 2193 # doesn't allow us to test the suggested header guard, but it does let us 2194 # test all the other header tests. 2195 error_collector = ErrorCollector(self.assertTrue) 2196 self.process_file_data(file_path, 'h', [], error_collector) 2197 expected_guard = '' 2198 matcher = re.compile( 2199 'No \#ifndef header guard found\, suggested CPP variable is\: ([A-Za-z_0-9]+) ') 2200 for error in error_collector.result_list(): 2201 matches = matcher.match(error) 2202 if matches: 2203 expected_guard = matches.group(1) 2204 break 2205 2206 # Make sure we extracted something for our header guard. 2207 self.assertNotEqual(expected_guard, '') 2208 2209 # Wrong guard 2210 error_collector = ErrorCollector(self.assertTrue) 2211 self.process_file_data(file_path, 'h', 2212 ['#ifndef FOO_H', '#define FOO_H'], error_collector) 2213 self.assertEqual( 2214 1, 2215 error_collector.result_list().count( 2216 '#ifndef header guard has wrong style, please use: %s' 2217 ' [build/header_guard] [5]' % expected_guard), 2218 error_collector.result_list()) 2219 2220 # No define 2221 error_collector = ErrorCollector(self.assertTrue) 2222 self.process_file_data(file_path, 'h', 2223 ['#ifndef %s' % expected_guard], error_collector) 2224 self.assertEqual( 2225 1, 2226 error_collector.result_list().count( 2227 'No #ifndef header guard found, suggested CPP variable is: %s' 2228 ' [build/header_guard] [5]' % expected_guard), 2229 error_collector.result_list()) 2230 2231 # Mismatched define 2232 error_collector = ErrorCollector(self.assertTrue) 2233 self.process_file_data(file_path, 'h', 2234 ['#ifndef %s' % expected_guard, 2235 '#define FOO_H'], 2236 error_collector) 2237 self.assertEqual( 2238 1, 2239 error_collector.result_list().count( 2240 'No #ifndef header guard found, suggested CPP variable is: %s' 2241 ' [build/header_guard] [5]' % expected_guard), 2242 error_collector.result_list()) 2243 2244 # No header guard errors 2245 error_collector = ErrorCollector(self.assertTrue) 2246 self.process_file_data(file_path, 'h', 2247 ['#ifndef %s' % expected_guard, 2248 '#define %s' % expected_guard, 2249 '#endif // %s' % expected_guard], 2250 error_collector) 2251 for line in error_collector.result_list(): 2252 if line.find('build/header_guard') != -1: 2253 self.fail('Unexpected error: %s' % line) 2254 2255 # Completely incorrect header guard 2256 error_collector = ErrorCollector(self.assertTrue) 2257 self.process_file_data(file_path, 'h', 2258 ['#ifndef FOO', 2259 '#define FOO', 2260 '#endif // FOO'], 2261 error_collector) 2262 self.assertEqual( 2263 1, 2264 error_collector.result_list().count( 2265 '#ifndef header guard has wrong style, please use: %s' 2266 ' [build/header_guard] [5]' % expected_guard), 2267 error_collector.result_list()) 2268 2269 # Special case for flymake 2270 error_collector = ErrorCollector(self.assertTrue) 2271 self.process_file_data('mydir/Foo_flymake.h', 'h', 2272 ['#ifndef %s' % expected_guard, 2273 '#define %s' % expected_guard, 2274 '#endif // %s' % expected_guard], 2275 error_collector) 2276 for line in error_collector.result_list(): 2277 if line.find('build/header_guard') != -1: 2278 self.fail('Unexpected error: %s' % line) 2279 2280 error_collector = ErrorCollector(self.assertTrue) 2281 self.process_file_data('mydir/Foo_flymake.h', 'h', [], error_collector) 2282 self.assertEqual( 2283 1, 2284 error_collector.result_list().count( 2285 'No #ifndef header guard found, suggested CPP variable is: %s' 2286 ' [build/header_guard] [5]' % expected_guard), 2287 error_collector.result_list()) 2288 2289 # Verify that we don't blindly suggest the WTF prefix for all headers. 2290 self.assertFalse(expected_guard.startswith('WTF_')) 2291 2292 # Allow the WTF_ prefix for files in that directory. 2293 header_guard_filter = FilterConfiguration(('-', '+build/header_guard')) 2294 error_collector = ErrorCollector(self.assertTrue, header_guard_filter) 2295 self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h', 2296 ['#ifndef WTF_TestName_h', '#define WTF_TestName_h'], 2297 error_collector) 2298 self.assertEqual(0, len(error_collector.result_list()), 2299 error_collector.result_list()) 2300 2301 # Also allow the non WTF_ prefix for files in that directory. 2302 error_collector = ErrorCollector(self.assertTrue, header_guard_filter) 2303 self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h', 2304 ['#ifndef TestName_h', '#define TestName_h'], 2305 error_collector) 2306 self.assertEqual(0, len(error_collector.result_list()), 2307 error_collector.result_list()) 2308 2309 # Verify that we suggest the WTF prefix version. 2310 error_collector = ErrorCollector(self.assertTrue, header_guard_filter) 2311 self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h', 2312 ['#ifndef BAD_TestName_h', '#define BAD_TestName_h'], 2313 error_collector) 2314 self.assertEqual( 2315 1, 2316 error_collector.result_list().count( 2317 '#ifndef header guard has wrong style, please use: WTF_TestName_h' 2318 ' [build/header_guard] [5]'), 2319 error_collector.result_list()) 2320 2321 # Verify that the Chromium-style header guard is allowed as well. 2322 error_collector = ErrorCollector(self.assertTrue, header_guard_filter) 2323 self.process_file_data('Source/foo/testname.h', 'h', 2324 ['#ifndef BLINK_FOO_TESTNAME_H_', 2325 '#define BLINK_FOO_TESTNAME_H_'], 2326 error_collector) 2327 self.assertEqual(0, len(error_collector.result_list()), 2328 error_collector.result_list()) 2329 2330 def test_build_printf_format(self): 2331 self.assert_lint( 2332 r'printf("\%%d", value);', 2333 '%, [, (, and { are undefined character escapes. Unescape them.' 2334 ' [build/printf_format] [3]') 2335 2336 self.assert_lint( 2337 r'snprintf(buffer, sizeof(buffer), "\[%d", value);', 2338 '%, [, (, and { are undefined character escapes. Unescape them.' 2339 ' [build/printf_format] [3]') 2340 2341 self.assert_lint( 2342 r'fprintf(file, "\(%d", value);', 2343 '%, [, (, and { are undefined character escapes. Unescape them.' 2344 ' [build/printf_format] [3]') 2345 2346 self.assert_lint( 2347 r'vsnprintf(buffer, sizeof(buffer), "\\\{%d", ap);', 2348 '%, [, (, and { are undefined character escapes. Unescape them.' 2349 ' [build/printf_format] [3]') 2350 2351 # Don't warn if double-slash precedes the symbol 2352 self.assert_lint(r'printf("\\%%%d", value);', 2353 '') 2354 2355 def test_runtime_printf_format(self): 2356 self.assert_lint( 2357 r'fprintf(file, "%q", value);', 2358 '%q in format strings is deprecated. Use %ll instead.' 2359 ' [runtime/printf_format] [3]') 2360 2361 self.assert_lint( 2362 r'aprintf(file, "The number is %12q", value);', 2363 '%q in format strings is deprecated. Use %ll instead.' 2364 ' [runtime/printf_format] [3]') 2365 2366 self.assert_lint( 2367 r'printf(file, "The number is" "%-12q", value);', 2368 '%q in format strings is deprecated. Use %ll instead.' 2369 ' [runtime/printf_format] [3]') 2370 2371 self.assert_lint( 2372 r'printf(file, "The number is" "%+12q", value);', 2373 '%q in format strings is deprecated. Use %ll instead.' 2374 ' [runtime/printf_format] [3]') 2375 2376 self.assert_lint( 2377 r'printf(file, "The number is" "% 12q", value);', 2378 '%q in format strings is deprecated. Use %ll instead.' 2379 ' [runtime/printf_format] [3]') 2380 2381 self.assert_lint( 2382 r'snprintf(file, "Never mix %d and %1$d parmaeters!", value);', 2383 '%N$ formats are unconventional. Try rewriting to avoid them.' 2384 ' [runtime/printf_format] [2]') 2385 2386 def assert_lintLogCodeOnError(self, code, expected_message): 2387 # Special assert_lint which logs the input code on error. 2388 result = self.perform_single_line_lint(code, 'foo.cpp') 2389 if result != expected_message: 2390 self.fail('For code: "%s"\nGot: "%s"\nExpected: "%s"' 2391 % (code, result, expected_message)) 2392 2393 def test_build_storage_class(self): 2394 qualifiers = [None, 'const', 'volatile'] 2395 signs = [None, 'signed', 'unsigned'] 2396 types = ['void', 'char', 'int', 'float', 'double', 2397 'schar', 'int8', 'uint8', 'int16', 'uint16', 2398 'int32', 'uint32', 'int64', 'uint64'] 2399 storage_classes = ['auto', 'extern', 'register', 'static', 'typedef'] 2400 2401 build_storage_class_error_message = ( 2402 'Storage class (static, extern, typedef, etc) should be first.' 2403 ' [build/storage_class] [5]') 2404 2405 # Some explicit cases. Legal in C++, deprecated in C99. 2406 self.assert_lint('const int static foo = 5;', 2407 build_storage_class_error_message) 2408 2409 self.assert_lint('char static foo;', 2410 build_storage_class_error_message) 2411 2412 self.assert_lint('double const static foo = 2.0;', 2413 build_storage_class_error_message) 2414 2415 self.assert_lint('uint64 typedef unsignedLongLong;', 2416 build_storage_class_error_message) 2417 2418 self.assert_lint('int register foo = 0;', 2419 build_storage_class_error_message) 2420 2421 # Since there are a very large number of possibilities, randomly 2422 # construct declarations. 2423 # Make sure that the declaration is logged if there's an error. 2424 # Seed generator with an integer for absolute reproducibility. 2425 random.seed(25) 2426 for unused_i in range(10): 2427 # Build up random list of non-storage-class declaration specs. 2428 other_decl_specs = [random.choice(qualifiers), random.choice(signs), 2429 random.choice(types)] 2430 # remove None 2431 other_decl_specs = filter(lambda x: x is not None, other_decl_specs) 2432 2433 # shuffle 2434 random.shuffle(other_decl_specs) 2435 2436 # insert storage class after the first 2437 storage_class = random.choice(storage_classes) 2438 insertion_point = random.randint(1, len(other_decl_specs)) 2439 decl_specs = (other_decl_specs[0:insertion_point] 2440 + [storage_class] 2441 + other_decl_specs[insertion_point:]) 2442 2443 self.assert_lintLogCodeOnError( 2444 ' '.join(decl_specs) + ';', 2445 build_storage_class_error_message) 2446 2447 # but no error if storage class is first 2448 self.assert_lintLogCodeOnError( 2449 storage_class + ' ' + ' '.join(other_decl_specs), 2450 '') 2451 2452 def test_legal_copyright(self): 2453 legal_copyright_message = ( 2454 'No copyright message found. ' 2455 'You should have a line: "Copyright [year] <Copyright Owner>"' 2456 ' [legal/copyright] [5]') 2457 2458 copyright_line = '// Copyright 2008 Google Inc. All Rights Reserved.' 2459 2460 file_path = 'mydir/googleclient/foo.cpp' 2461 2462 # There should be a copyright message in the first 10 lines 2463 error_collector = ErrorCollector(self.assertTrue) 2464 self.process_file_data(file_path, 'cpp', [], error_collector) 2465 self.assertEqual( 2466 1, 2467 error_collector.result_list().count(legal_copyright_message)) 2468 2469 error_collector = ErrorCollector(self.assertTrue) 2470 self.process_file_data( 2471 file_path, 'cpp', 2472 ['' for unused_i in range(10)] + [copyright_line], 2473 error_collector) 2474 self.assertEqual( 2475 1, 2476 error_collector.result_list().count(legal_copyright_message)) 2477 2478 # Test that warning isn't issued if Copyright line appears early enough. 2479 error_collector = ErrorCollector(self.assertTrue) 2480 self.process_file_data(file_path, 'cpp', [copyright_line], error_collector) 2481 for message in error_collector.result_list(): 2482 if message.find('legal/copyright') != -1: 2483 self.fail('Unexpected error: %s' % message) 2484 2485 error_collector = ErrorCollector(self.assertTrue) 2486 self.process_file_data( 2487 file_path, 'cpp', 2488 ['' for unused_i in range(9)] + [copyright_line], 2489 error_collector) 2490 for message in error_collector.result_list(): 2491 if message.find('legal/copyright') != -1: 2492 self.fail('Unexpected error: %s' % message) 2493 2494 def test_invalid_increment(self): 2495 self.assert_lint('*count++;', 2496 'Changing pointer instead of value (or unused value of ' 2497 'operator*). [runtime/invalid_increment] [5]') 2498 2499 # Integral bitfields must be declared with either signed or unsigned keyword. 2500 def test_plain_integral_bitfields(self): 2501 errmsg = ('Please declare integral type bitfields with either signed or unsigned. [runtime/bitfields] [5]') 2502 2503 self.assert_lint('int a : 30;', errmsg) 2504 self.assert_lint('mutable short a : 14;', errmsg) 2505 self.assert_lint('const char a : 6;', errmsg) 2506 self.assert_lint('long int a : 30;', errmsg) 2507 self.assert_lint('int a = 1 ? 0 : 30;', '') 2508 2509 # A mixture of unsigned and bool bitfields in a class will generate a warning. 2510 def test_mixing_unsigned_bool_bitfields(self): 2511 def errmsg(bool_bitfields, unsigned_bitfields, name): 2512 bool_list = ', '.join(bool_bitfields) 2513 unsigned_list = ', '.join(unsigned_bitfields) 2514 return ('The class %s contains mixed unsigned and bool bitfields, ' 2515 'which will pack into separate words on the MSVC compiler.\n' 2516 'Bool bitfields are [%s].\nUnsigned bitfields are [%s].\n' 2517 'Consider converting bool bitfields to unsigned. [runtime/bitfields] [5]' 2518 % (name, bool_list, unsigned_list)) 2519 2520 def build_test_case(bitfields, name, will_warn, extra_warnings=[]): 2521 bool_bitfields = [] 2522 unsigned_bitfields = [] 2523 test_string = 'class %s {\n' % (name,) 2524 line = 2 2525 for bitfield in bitfields: 2526 test_string += ' %s %s : %d;\n' % bitfield 2527 if bitfield[0] == 'bool': 2528 bool_bitfields.append('%d: %s' % (line, bitfield[1])) 2529 elif bitfield[0].startswith('unsigned'): 2530 unsigned_bitfields.append('%d: %s' % (line, bitfield[1])) 2531 line += 1 2532 test_string += '}\n' 2533 error = '' 2534 if will_warn: 2535 error = errmsg(bool_bitfields, unsigned_bitfields, name) 2536 if extra_warnings and error: 2537 error = extra_warnings + [error] 2538 self.assert_multi_line_lint(test_string, error) 2539 2540 build_test_case([('bool', 'm_boolMember', 4), ('unsigned', 'm_unsignedMember', 3)], 2541 'MyClass', True) 2542 build_test_case([('bool', 'm_boolMember', 4), ('bool', 'm_anotherBool', 3)], 2543 'MyClass', False) 2544 build_test_case([('unsigned', 'm_unsignedMember', 4), ('unsigned', 'm_anotherUnsigned', 3)], 2545 'MyClass', False) 2546 2547 build_test_case([('bool', 'm_boolMember', 4), ('bool', 'm_anotherbool', 3), 2548 ('bool', 'm_moreBool', 1), ('bool', 'm_lastBool', 1), 2549 ('unsigned int', 'm_tokenUnsigned', 4)], 2550 'MyClass', True, ['Omit int when using unsigned [runtime/unsigned] [1]']) 2551 2552 self.assert_multi_line_lint('class NoProblemsHere {\n' 2553 ' bool m_boolMember;\n' 2554 ' unsigned m_unsignedMember;\n' 2555 ' unsigned m_bitField1 : 1;\n' 2556 ' unsigned m_bitField4 : 4;\n' 2557 '}\n', '') 2558 2559 # Bitfields which are not declared unsigned or bool will generate a warning. 2560 def test_unsigned_bool_bitfields(self): 2561 def errmsg(member, name, bit_type): 2562 return ('Member %s of class %s defined as a bitfield of type %s. ' 2563 'Please declare all bitfields as unsigned. [runtime/bitfields] [4]' 2564 % (member, name, bit_type)) 2565 2566 def warning_bitfield_test(member, name, bit_type, bits): 2567 self.assert_multi_line_lint('class %s {\n%s %s: %d;\n}\n' 2568 % (name, bit_type, member, bits), 2569 errmsg(member, name, bit_type)) 2570 2571 def safe_bitfield_test(member, name, bit_type, bits): 2572 self.assert_multi_line_lint('class %s {\n%s %s: %d;\n}\n' 2573 % (name, bit_type, member, bits), 2574 '') 2575 2576 warning_bitfield_test('a', 'A', 'int32_t', 25) 2577 warning_bitfield_test('m_someField', 'SomeClass', 'signed', 4) 2578 warning_bitfield_test('m_someField', 'SomeClass', 'SomeEnum', 2) 2579 2580 safe_bitfield_test('a', 'A', 'unsigned', 22) 2581 safe_bitfield_test('m_someField', 'SomeClass', 'bool', 1) 2582 safe_bitfield_test('m_someField', 'SomeClass', 'unsigned', 2) 2583 2584 # Declarations in 'Expected' or 'SameSizeAs' classes are OK. 2585 warning_bitfield_test('m_bitfields', 'SomeClass', 'int32_t', 32) 2586 safe_bitfield_test('m_bitfields', 'ExpectedSomeClass', 'int32_t', 32) 2587 safe_bitfield_test('m_bitfields', 'SameSizeAsSomeClass', 'int32_t', 32) 2588 2589class CleansedLinesTest(unittest.TestCase): 2590 def test_init(self): 2591 lines = ['Line 1', 2592 'Line 2', 2593 'Line 3 // Comment test', 2594 'Line 4 "foo"'] 2595 2596 clean_lines = cpp_style.CleansedLines(lines) 2597 self.assertEqual(lines, clean_lines.raw_lines) 2598 self.assertEqual(4, clean_lines.num_lines()) 2599 2600 self.assertEqual(['Line 1', 2601 'Line 2', 2602 'Line 3 ', 2603 'Line 4 "foo"'], 2604 clean_lines.lines) 2605 2606 self.assertEqual(['Line 1', 2607 'Line 2', 2608 'Line 3 ', 2609 'Line 4 ""'], 2610 clean_lines.elided) 2611 2612 def test_init_empty(self): 2613 clean_lines = cpp_style.CleansedLines([]) 2614 self.assertEqual([], clean_lines.raw_lines) 2615 self.assertEqual(0, clean_lines.num_lines()) 2616 2617 def test_collapse_strings(self): 2618 collapse = cpp_style.CleansedLines.collapse_strings 2619 self.assertEqual('""', collapse('""')) # "" (empty) 2620 self.assertEqual('"""', collapse('"""')) # """ (bad) 2621 self.assertEqual('""', collapse('"xyz"')) # "xyz" (string) 2622 self.assertEqual('""', collapse('"\\\""')) # "\"" (string) 2623 self.assertEqual('""', collapse('"\'"')) # "'" (string) 2624 self.assertEqual('"\"', collapse('"\"')) # "\" (bad) 2625 self.assertEqual('""', collapse('"\\\\"')) # "\\" (string) 2626 self.assertEqual('"', collapse('"\\\\\\"')) # "\\\" (bad) 2627 self.assertEqual('""', collapse('"\\\\\\\\"')) # "\\\\" (string) 2628 2629 self.assertEqual('\'\'', collapse('\'\'')) # '' (empty) 2630 self.assertEqual('\'\'', collapse('\'a\'')) # 'a' (char) 2631 self.assertEqual('\'\'', collapse('\'\\\'\'')) # '\'' (char) 2632 self.assertEqual('\'', collapse('\'\\\'')) # '\' (bad) 2633 self.assertEqual('', collapse('\\012')) # '\012' (char) 2634 self.assertEqual('', collapse('\\xfF0')) # '\xfF0' (char) 2635 self.assertEqual('', collapse('\\n')) # '\n' (char) 2636 self.assertEqual('\#', collapse('\\#')) # '\#' (bad) 2637 2638 self.assertEqual('StringReplace(body, "", "");', 2639 collapse('StringReplace(body, "\\\\", "\\\\\\\\");')) 2640 self.assertEqual('\'\' ""', 2641 collapse('\'"\' "foo"')) 2642 2643 2644class OrderOfIncludesTest(CppStyleTestBase): 2645 def setUp(self): 2646 self.include_state = cpp_style._IncludeState() 2647 2648 # Cheat os.path.abspath called in FileInfo class. 2649 self.os_path_abspath_orig = os.path.abspath 2650 os.path.abspath = lambda value: value 2651 2652 def tearDown(self): 2653 os.path.abspath = self.os_path_abspath_orig 2654 2655 def test_try_drop_common_suffixes(self): 2656 self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo-inl.h')) 2657 self.assertEqual('foo/bar/foo', 2658 cpp_style._drop_common_suffixes('foo/bar/foo_inl.h')) 2659 self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo.cpp')) 2660 self.assertEqual('foo/foo_unusualinternal', 2661 cpp_style._drop_common_suffixes('foo/foo_unusualinternal.h')) 2662 self.assertEqual('', 2663 cpp_style._drop_common_suffixes('_test.cpp')) 2664 self.assertEqual('test', 2665 cpp_style._drop_common_suffixes('test.cpp')) 2666 2667 2668class OrderOfIncludesTest(CppStyleTestBase): 2669 def setUp(self): 2670 self.include_state = cpp_style._IncludeState() 2671 2672 # Cheat os.path.abspath called in FileInfo class. 2673 self.os_path_abspath_orig = os.path.abspath 2674 self.os_path_isfile_orig = os.path.isfile 2675 os.path.abspath = lambda value: value 2676 2677 def tearDown(self): 2678 os.path.abspath = self.os_path_abspath_orig 2679 os.path.isfile = self.os_path_isfile_orig 2680 2681 def test_check_next_include_order__no_config(self): 2682 self.assertEqual('Header file should not contain WebCore config.h.', 2683 self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, True, True)) 2684 2685 def test_check_next_include_order__no_self(self): 2686 self.assertEqual('Header file should not contain itself.', 2687 self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, True, True)) 2688 # Test actual code to make sure that header types are correctly assigned. 2689 self.assert_language_rules_check('Foo.h', 2690 '#include "Foo.h"\n', 2691 'Header file should not contain itself. Should be: alphabetically sorted.' 2692 ' [build/include_order] [4]') 2693 self.assert_language_rules_check('FooBar.h', 2694 '#include "Foo.h"\n', 2695 '') 2696 2697 def test_check_next_include_order__likely_then_config(self): 2698 self.assertEqual('Found header this file implements before WebCore config.h.', 2699 self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, False, True)) 2700 self.assertEqual('Found WebCore config.h after a header this file implements.', 2701 self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False, True)) 2702 2703 def test_check_next_include_order__other_then_config(self): 2704 self.assertEqual('Found other header before WebCore config.h.', 2705 self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False, True)) 2706 self.assertEqual('Found WebCore config.h after other header.', 2707 self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False, True)) 2708 2709 def test_check_next_include_order__config_then_other_then_likely(self): 2710 self.assertEqual('', self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False, True)) 2711 self.assertEqual('Found other header before a header this file implements.', 2712 self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False, True)) 2713 self.assertEqual('Found header this file implements after other header.', 2714 self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, False, True)) 2715 2716 def test_check_alphabetical_include_order(self): 2717 self.assert_language_rules_check('foo.h', 2718 '#include "a.h"\n' 2719 '#include "c.h"\n' 2720 '#include "b.h"\n', 2721 'Alphabetical sorting problem. [build/include_order] [4]') 2722 2723 self.assert_language_rules_check('foo.h', 2724 '#include "a.h"\n' 2725 '#include "b.h"\n' 2726 '#include "c.h"\n', 2727 '') 2728 2729 self.assert_language_rules_check('foo.h', 2730 '#include <assert.h>\n' 2731 '#include "bar.h"\n', 2732 'Alphabetical sorting problem. [build/include_order] [4]') 2733 2734 self.assert_language_rules_check('foo.h', 2735 '#include "bar.h"\n' 2736 '#include <assert.h>\n', 2737 '') 2738 2739 def test_check_alphabetical_include_order_errors_reported_for_both_lines(self): 2740 # If one of the two lines of out of order headers are filtered, the error should be 2741 # reported on the other line. 2742 self.assert_language_rules_check('foo.h', 2743 '#include "a.h"\n' 2744 '#include "c.h"\n' 2745 '#include "b.h"\n', 2746 'Alphabetical sorting problem. [build/include_order] [4]', 2747 lines_to_check=[2]) 2748 2749 self.assert_language_rules_check('foo.h', 2750 '#include "a.h"\n' 2751 '#include "c.h"\n' 2752 '#include "b.h"\n', 2753 'Alphabetical sorting problem. [build/include_order] [4]', 2754 lines_to_check=[3]) 2755 2756 # If no lines are filtered, the error should be reported only once. 2757 self.assert_language_rules_check('foo.h', 2758 '#include "a.h"\n' 2759 '#include "c.h"\n' 2760 '#include "b.h"\n', 2761 'Alphabetical sorting problem. [build/include_order] [4]') 2762 2763 def test_check_line_break_after_own_header(self): 2764 self.assert_language_rules_check('foo.cpp', 2765 '#include "config.h"\n' 2766 '#include "foo.h"\n' 2767 '#include "bar.h"\n', 2768 'You should add a blank line after implementation file\'s own header. [build/include_order] [4]') 2769 2770 self.assert_language_rules_check('foo.cpp', 2771 '#include "config.h"\n' 2772 '#include "foo.h"\n' 2773 '\n' 2774 '#include "bar.h"\n', 2775 '') 2776 2777 def test_check_preprocessor_in_include_section(self): 2778 self.assert_language_rules_check('foo.cpp', 2779 '#include "config.h"\n' 2780 '#include "foo.h"\n' 2781 '\n' 2782 '#ifdef BAZ\n' 2783 '#include "baz.h"\n' 2784 '#else\n' 2785 '#include "foobar.h"\n' 2786 '#endif"\n' 2787 '#include "bar.h"\n', # No flag because previous is in preprocessor section 2788 '') 2789 2790 self.assert_language_rules_check('foo.cpp', 2791 '#include "config.h"\n' 2792 '#include "foo.h"\n' 2793 '\n' 2794 '#ifdef BAZ\n' 2795 '#include "baz.h"\n' 2796 '#endif"\n' 2797 '#include "bar.h"\n' 2798 '#include "a.h"\n', # Should still flag this. 2799 'Alphabetical sorting problem. [build/include_order] [4]') 2800 2801 self.assert_language_rules_check('foo.cpp', 2802 '#include "config.h"\n' 2803 '#include "foo.h"\n' 2804 '\n' 2805 '#ifdef BAZ\n' 2806 '#include "baz.h"\n' 2807 '#include "bar.h"\n' #Should still flag this 2808 '#endif"\n', 2809 'Alphabetical sorting problem. [build/include_order] [4]') 2810 2811 self.assert_language_rules_check('foo.cpp', 2812 '#include "config.h"\n' 2813 '#include "foo.h"\n' 2814 '\n' 2815 '#ifdef BAZ\n' 2816 '#include "baz.h"\n' 2817 '#endif"\n' 2818 '#ifdef FOOBAR\n' 2819 '#include "foobar.h"\n' 2820 '#endif"\n' 2821 '#include "bar.h"\n' 2822 '#include "a.h"\n', # Should still flag this. 2823 'Alphabetical sorting problem. [build/include_order] [4]') 2824 2825 # Check that after an already included error, the sorting rules still work. 2826 self.assert_language_rules_check('foo.cpp', 2827 '#include "config.h"\n' 2828 '#include "foo.h"\n' 2829 '\n' 2830 '#include "foo.h"\n' 2831 '#include "g.h"\n', 2832 '"foo.h" already included at foo.cpp:2 [build/include] [4]') 2833 2834 def test_primary_header(self): 2835 # File with non-existing primary header should not produce errors. 2836 self.assert_language_rules_check('foo.cpp', 2837 '#include "config.h"\n' 2838 '\n' 2839 '#include "bar.h"\n', 2840 '') 2841 # Pretend that header files exist. 2842 os.path.isfile = lambda filename: True 2843 # Missing include for existing primary header -> error. 2844 self.assert_language_rules_check('foo.cpp', 2845 '#include "config.h"\n' 2846 '\n' 2847 '#include "bar.h"\n', 2848 'Found other header before a header this file implements. ' 2849 'Should be: config.h, primary header, blank line, and then ' 2850 'alphabetically sorted. [build/include_order] [4]') 2851 # Having include for existing primary header -> no error. 2852 self.assert_language_rules_check('foo.cpp', 2853 '#include "config.h"\n' 2854 '#include "foo.h"\n' 2855 '\n' 2856 '#include "bar.h"\n', 2857 '') 2858 2859 os.path.isfile = self.os_path_isfile_orig 2860 2861 def test_public_primary_header(self): 2862 # System header is not considered a primary header. 2863 self.assert_language_rules_check('foo.cpp', 2864 '#include "config.h"\n' 2865 '#include <other/foo.h>\n' 2866 '\n' 2867 '#include "a.h"\n', 2868 'Alphabetical sorting problem. [build/include_order] [4]') 2869 2870 # ...except that it starts with public/. 2871 self.assert_language_rules_check('foo.cpp', 2872 '#include "config.h"\n' 2873 '#include <public/foo.h>\n' 2874 '\n' 2875 '#include "a.h"\n', 2876 '') 2877 2878 # Even if it starts with public/ its base part must match with the source file name. 2879 self.assert_language_rules_check('foo.cpp', 2880 '#include "config.h"\n' 2881 '#include <public/foop.h>\n' 2882 '\n' 2883 '#include "a.h"\n', 2884 'Alphabetical sorting problem. [build/include_order] [4]') 2885 2886 def test_check_wtf_includes(self): 2887 self.assert_language_rules_check('foo.cpp', 2888 '#include "config.h"\n' 2889 '#include "foo.h"\n' 2890 '\n' 2891 '#include <wtf/Assertions.h>\n', 2892 'wtf includes should be "wtf/file.h" instead of <wtf/file.h>.' 2893 ' [build/include] [4]') 2894 self.assert_language_rules_check('foo.cpp', 2895 '#include "config.h"\n' 2896 '#include "foo.h"\n' 2897 '\n' 2898 '#include "wtf/Assertions.h"\n', 2899 '') 2900 2901 def test_check_cc_includes(self): 2902 self.assert_language_rules_check('bar/chromium/foo.cpp', 2903 '#include "config.h"\n' 2904 '#include "foo.h"\n' 2905 '\n' 2906 '#include "cc/CCProxy.h"\n', 2907 'cc includes should be "CCFoo.h" instead of "cc/CCFoo.h".' 2908 ' [build/include] [4]') 2909 2910 def test_classify_include(self): 2911 classify_include = cpp_style._classify_include 2912 include_state = cpp_style._IncludeState() 2913 self.assertEqual(cpp_style._CONFIG_HEADER, 2914 classify_include('foo/foo.cpp', 2915 'config.h', 2916 False, include_state)) 2917 self.assertEqual(cpp_style._PRIMARY_HEADER, 2918 classify_include('foo/internal/foo.cpp', 2919 'foo/public/foo.h', 2920 False, include_state)) 2921 self.assertEqual(cpp_style._PRIMARY_HEADER, 2922 classify_include('foo/internal/foo.cpp', 2923 'foo/other/public/foo.h', 2924 False, include_state)) 2925 self.assertEqual(cpp_style._OTHER_HEADER, 2926 classify_include('foo/internal/foo.cpp', 2927 'foo/other/public/foop.h', 2928 False, include_state)) 2929 self.assertEqual(cpp_style._OTHER_HEADER, 2930 classify_include('foo/foo.cpp', 2931 'string', 2932 True, include_state)) 2933 self.assertEqual(cpp_style._PRIMARY_HEADER, 2934 classify_include('fooCustom.cpp', 2935 'foo.h', 2936 False, include_state)) 2937 self.assertEqual(cpp_style._PRIMARY_HEADER, 2938 classify_include('PrefixFooCustom.cpp', 2939 'Foo.h', 2940 False, include_state)) 2941 self.assertEqual(cpp_style._MOC_HEADER, 2942 classify_include('foo.cpp', 2943 'foo.moc', 2944 False, include_state)) 2945 self.assertEqual(cpp_style._MOC_HEADER, 2946 classify_include('foo.cpp', 2947 'moc_foo.cpp', 2948 False, include_state)) 2949 # <public/foo.h> must be considered as primary even if is_system is True. 2950 self.assertEqual(cpp_style._PRIMARY_HEADER, 2951 classify_include('foo/foo.cpp', 2952 'public/foo.h', 2953 True, include_state)) 2954 self.assertEqual(cpp_style._OTHER_HEADER, 2955 classify_include('foo.cpp', 2956 'foo.h', 2957 True, include_state)) 2958 self.assertEqual(cpp_style._OTHER_HEADER, 2959 classify_include('foo.cpp', 2960 'public/foop.h', 2961 True, include_state)) 2962 # Qt private APIs use _p.h suffix. 2963 self.assertEqual(cpp_style._PRIMARY_HEADER, 2964 classify_include('foo.cpp', 2965 'foo_p.h', 2966 False, include_state)) 2967 # Tricky example where both includes might be classified as primary. 2968 self.assert_language_rules_check('ScrollbarThemeWince.cpp', 2969 '#include "config.h"\n' 2970 '#include "ScrollbarThemeWince.h"\n' 2971 '\n' 2972 '#include "Scrollbar.h"\n', 2973 '') 2974 self.assert_language_rules_check('ScrollbarThemeWince.cpp', 2975 '#include "config.h"\n' 2976 '#include "Scrollbar.h"\n' 2977 '\n' 2978 '#include "ScrollbarThemeWince.h"\n', 2979 'Found header this file implements after a header this file implements.' 2980 ' Should be: config.h, primary header, blank line, and then alphabetically sorted.' 2981 ' [build/include_order] [4]') 2982 self.assert_language_rules_check('ResourceHandleWin.cpp', 2983 '#include "config.h"\n' 2984 '#include "ResourceHandle.h"\n' 2985 '\n' 2986 '#include "ResourceHandleWin.h"\n', 2987 '') 2988 2989 def test_try_drop_common_suffixes(self): 2990 self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo-inl.h')) 2991 self.assertEqual('foo/bar/foo', 2992 cpp_style._drop_common_suffixes('foo/bar/foo_inl.h')) 2993 self.assertEqual('foo/foo', cpp_style._drop_common_suffixes('foo/foo.cpp')) 2994 self.assertEqual('foo/foo_unusualinternal', 2995 cpp_style._drop_common_suffixes('foo/foo_unusualinternal.h')) 2996 self.assertEqual('', 2997 cpp_style._drop_common_suffixes('_test.cpp')) 2998 self.assertEqual('test', 2999 cpp_style._drop_common_suffixes('test.cpp')) 3000 self.assertEqual('test', 3001 cpp_style._drop_common_suffixes('test.cpp')) 3002 3003class CheckForFunctionLengthsTest(CppStyleTestBase): 3004 def setUp(self): 3005 # Reducing these thresholds for the tests speeds up tests significantly. 3006 self.old_normal_trigger = cpp_style._FunctionState._NORMAL_TRIGGER 3007 self.old_test_trigger = cpp_style._FunctionState._TEST_TRIGGER 3008 3009 cpp_style._FunctionState._NORMAL_TRIGGER = 10 3010 cpp_style._FunctionState._TEST_TRIGGER = 25 3011 3012 def tearDown(self): 3013 cpp_style._FunctionState._NORMAL_TRIGGER = self.old_normal_trigger 3014 cpp_style._FunctionState._TEST_TRIGGER = self.old_test_trigger 3015 3016 # FIXME: Eliminate the need for this function. 3017 def set_min_confidence(self, min_confidence): 3018 """Set new test confidence and return old test confidence.""" 3019 old_min_confidence = self.min_confidence 3020 self.min_confidence = min_confidence 3021 return old_min_confidence 3022 3023 def assert_function_lengths_check(self, code, expected_message): 3024 """Check warnings for long function bodies are as expected. 3025 3026 Args: 3027 code: C++ source code expected to generate a warning message. 3028 expected_message: Message expected to be generated by the C++ code. 3029 """ 3030 self.assertEqual(expected_message, 3031 self.perform_function_lengths_check(code)) 3032 3033 def trigger_lines(self, error_level): 3034 """Return number of lines needed to trigger a function length warning. 3035 3036 Args: 3037 error_level: --v setting for cpp_style. 3038 3039 Returns: 3040 Number of lines needed to trigger a function length warning. 3041 """ 3042 return cpp_style._FunctionState._NORMAL_TRIGGER * 2 ** error_level 3043 3044 def trigger_test_lines(self, error_level): 3045 """Return number of lines needed to trigger a test function length warning. 3046 3047 Args: 3048 error_level: --v setting for cpp_style. 3049 3050 Returns: 3051 Number of lines needed to trigger a test function length warning. 3052 """ 3053 return cpp_style._FunctionState._TEST_TRIGGER * 2 ** error_level 3054 3055 def assert_function_length_check_definition(self, lines, error_level): 3056 """Generate long function definition and check warnings are as expected. 3057 3058 Args: 3059 lines: Number of lines to generate. 3060 error_level: --v setting for cpp_style. 3061 """ 3062 trigger_level = self.trigger_lines(self.min_confidence) 3063 self.assert_function_lengths_check( 3064 'void test(int x)' + self.function_body(lines), 3065 ('Small and focused functions are preferred: ' 3066 'test() has %d non-comment lines ' 3067 '(error triggered by exceeding %d lines).' 3068 ' [readability/fn_size] [%d]' 3069 % (lines, trigger_level, error_level))) 3070 3071 def assert_function_length_check_definition_ok(self, lines): 3072 """Generate shorter function definition and check no warning is produced. 3073 3074 Args: 3075 lines: Number of lines to generate. 3076 """ 3077 self.assert_function_lengths_check( 3078 'void test(int x)' + self.function_body(lines), 3079 '') 3080 3081 def assert_function_length_check_at_error_level(self, error_level): 3082 """Generate and check function at the trigger level for --v setting. 3083 3084 Args: 3085 error_level: --v setting for cpp_style. 3086 """ 3087 self.assert_function_length_check_definition(self.trigger_lines(error_level), 3088 error_level) 3089 3090 def assert_function_length_check_below_error_level(self, error_level): 3091 """Generate and check function just below the trigger level for --v setting. 3092 3093 Args: 3094 error_level: --v setting for cpp_style. 3095 """ 3096 self.assert_function_length_check_definition(self.trigger_lines(error_level) - 1, 3097 error_level - 1) 3098 3099 def assert_function_length_check_above_error_level(self, error_level): 3100 """Generate and check function just above the trigger level for --v setting. 3101 3102 Args: 3103 error_level: --v setting for cpp_style. 3104 """ 3105 self.assert_function_length_check_definition(self.trigger_lines(error_level) + 1, 3106 error_level) 3107 3108 def function_body(self, number_of_lines): 3109 return ' {\n' + ' this_is_just_a_test();\n' * number_of_lines + '}' 3110 3111 def function_body_with_blank_lines(self, number_of_lines): 3112 return ' {\n' + ' this_is_just_a_test();\n\n' * number_of_lines + '}' 3113 3114 def function_body_with_no_lints(self, number_of_lines): 3115 return ' {\n' + ' this_is_just_a_test(); // NOLINT\n' * number_of_lines + '}' 3116 3117 # Test line length checks. 3118 def test_function_length_check_declaration(self): 3119 self.assert_function_lengths_check( 3120 'void test();', # Not a function definition 3121 '') 3122 3123 def test_function_length_check_declaration_with_block_following(self): 3124 self.assert_function_lengths_check( 3125 ('void test();\n' 3126 + self.function_body(66)), # Not a function definition 3127 '') 3128 3129 def test_function_length_check_class_definition(self): 3130 self.assert_function_lengths_check( # Not a function definition 3131 'class Test' + self.function_body(66) + ';', 3132 '') 3133 3134 def test_function_length_check_trivial(self): 3135 self.assert_function_lengths_check( 3136 'void test() {}', # Not counted 3137 '') 3138 3139 def test_function_length_check_empty(self): 3140 self.assert_function_lengths_check( 3141 'void test() {\n}', 3142 '') 3143 3144 def test_function_length_check_definition_below_severity0(self): 3145 old_min_confidence = self.set_min_confidence(0) 3146 self.assert_function_length_check_definition_ok(self.trigger_lines(0) - 1) 3147 self.set_min_confidence(old_min_confidence) 3148 3149 def test_function_length_check_definition_at_severity0(self): 3150 old_min_confidence = self.set_min_confidence(0) 3151 self.assert_function_length_check_definition_ok(self.trigger_lines(0)) 3152 self.set_min_confidence(old_min_confidence) 3153 3154 def test_function_length_check_definition_above_severity0(self): 3155 old_min_confidence = self.set_min_confidence(0) 3156 self.assert_function_length_check_above_error_level(0) 3157 self.set_min_confidence(old_min_confidence) 3158 3159 def test_function_length_check_definition_below_severity1v0(self): 3160 old_min_confidence = self.set_min_confidence(0) 3161 self.assert_function_length_check_below_error_level(1) 3162 self.set_min_confidence(old_min_confidence) 3163 3164 def test_function_length_check_definition_at_severity1v0(self): 3165 old_min_confidence = self.set_min_confidence(0) 3166 self.assert_function_length_check_at_error_level(1) 3167 self.set_min_confidence(old_min_confidence) 3168 3169 def test_function_length_check_definition_below_severity1(self): 3170 self.assert_function_length_check_definition_ok(self.trigger_lines(1) - 1) 3171 3172 def test_function_length_check_definition_at_severity1(self): 3173 self.assert_function_length_check_definition_ok(self.trigger_lines(1)) 3174 3175 def test_function_length_check_definition_above_severity1(self): 3176 self.assert_function_length_check_above_error_level(1) 3177 3178 def test_function_length_check_definition_severity1_plus_indented(self): 3179 error_level = 1 3180 error_lines = self.trigger_lines(error_level) + 1 3181 trigger_level = self.trigger_lines(self.min_confidence) 3182 indent_spaces = ' ' 3183 self.assert_function_lengths_check( 3184 re.sub(r'(?m)^(.)', indent_spaces + r'\1', 3185 'void test_indent(int x)\n' + self.function_body(error_lines)), 3186 ('Small and focused functions are preferred: ' 3187 'test_indent() has %d non-comment lines ' 3188 '(error triggered by exceeding %d lines).' 3189 ' [readability/fn_size] [%d]') 3190 % (error_lines, trigger_level, error_level)) 3191 3192 def test_function_length_check_definition_severity1_plus_blanks(self): 3193 error_level = 1 3194 error_lines = self.trigger_lines(error_level) + 1 3195 trigger_level = self.trigger_lines(self.min_confidence) 3196 self.assert_function_lengths_check( 3197 'void test_blanks(int x)' + self.function_body(error_lines), 3198 ('Small and focused functions are preferred: ' 3199 'test_blanks() has %d non-comment lines ' 3200 '(error triggered by exceeding %d lines).' 3201 ' [readability/fn_size] [%d]') 3202 % (error_lines, trigger_level, error_level)) 3203 3204 def test_function_length_check_complex_definition_severity1(self): 3205 error_level = 1 3206 error_lines = self.trigger_lines(error_level) + 1 3207 trigger_level = self.trigger_lines(self.min_confidence) 3208 self.assert_function_lengths_check( 3209 ('my_namespace::my_other_namespace::MyVeryLongTypeName<Type1, bool func(const Element*)>*\n' 3210 'my_namespace::my_other_namespace<Type3, Type4>::~MyFunction<Type5<Type6, Type7> >(int arg1, char* arg2)' 3211 + self.function_body(error_lines)), 3212 ('Small and focused functions are preferred: ' 3213 'my_namespace::my_other_namespace<Type3, Type4>::~MyFunction<Type5<Type6, Type7> >()' 3214 ' has %d non-comment lines ' 3215 '(error triggered by exceeding %d lines).' 3216 ' [readability/fn_size] [%d]') 3217 % (error_lines, trigger_level, error_level)) 3218 3219 def test_function_length_check_definition_severity1_for_test(self): 3220 error_level = 1 3221 error_lines = self.trigger_test_lines(error_level) + 1 3222 trigger_level = self.trigger_test_lines(self.min_confidence) 3223 self.assert_function_lengths_check( 3224 'TEST_F(Test, Mutator)' + self.function_body(error_lines), 3225 ('Small and focused functions are preferred: ' 3226 'TEST_F(Test, Mutator) has %d non-comment lines ' 3227 '(error triggered by exceeding %d lines).' 3228 ' [readability/fn_size] [%d]') 3229 % (error_lines, trigger_level, error_level)) 3230 3231 def test_function_length_check_definition_severity1_for_split_line_test(self): 3232 error_level = 1 3233 error_lines = self.trigger_test_lines(error_level) + 1 3234 trigger_level = self.trigger_test_lines(self.min_confidence) 3235 self.assert_function_lengths_check( 3236 ('TEST_F(GoogleUpdateRecoveryRegistryProtectedTest,\n' 3237 ' FixGoogleUpdate_AllValues_MachineApp)' # note: 4 spaces 3238 + self.function_body(error_lines)), 3239 ('Small and focused functions are preferred: ' 3240 'TEST_F(GoogleUpdateRecoveryRegistryProtectedTest, ' # 1 space 3241 'FixGoogleUpdate_AllValues_MachineApp) has %d non-comment lines ' 3242 '(error triggered by exceeding %d lines).' 3243 ' [readability/fn_size] [%d]') 3244 % (error_lines, trigger_level, error_level)) 3245 3246 def test_function_length_check_definition_severity1_for_bad_test_doesnt_break(self): 3247 error_level = 1 3248 error_lines = self.trigger_test_lines(error_level) + 1 3249 trigger_level = self.trigger_test_lines(self.min_confidence) 3250 # Since the function name isn't valid, the function detection algorithm 3251 # will skip it, so no error is produced. 3252 self.assert_function_lengths_check( 3253 ('TEST_F(' 3254 + self.function_body(error_lines)), 3255 '') 3256 3257 def test_function_length_check_definition_severity1_with_embedded_no_lints(self): 3258 error_level = 1 3259 error_lines = self.trigger_lines(error_level) + 1 3260 trigger_level = self.trigger_lines(self.min_confidence) 3261 self.assert_function_lengths_check( 3262 'void test(int x)' + self.function_body_with_no_lints(error_lines), 3263 ('Small and focused functions are preferred: ' 3264 'test() has %d non-comment lines ' 3265 '(error triggered by exceeding %d lines).' 3266 ' [readability/fn_size] [%d]') 3267 % (error_lines, trigger_level, error_level)) 3268 3269 def test_function_length_check_definition_severity1_with_no_lint(self): 3270 self.assert_function_lengths_check( 3271 ('void test(int x)' + self.function_body(self.trigger_lines(1)) 3272 + ' // NOLINT -- long function'), 3273 '') 3274 3275 def test_function_length_check_definition_below_severity2(self): 3276 self.assert_function_length_check_below_error_level(2) 3277 3278 def test_function_length_check_definition_severity2(self): 3279 self.assert_function_length_check_at_error_level(2) 3280 3281 def test_function_length_check_definition_above_severity2(self): 3282 self.assert_function_length_check_above_error_level(2) 3283 3284 def test_function_length_check_definition_below_severity3(self): 3285 self.assert_function_length_check_below_error_level(3) 3286 3287 def test_function_length_check_definition_severity3(self): 3288 self.assert_function_length_check_at_error_level(3) 3289 3290 def test_function_length_check_definition_above_severity3(self): 3291 self.assert_function_length_check_above_error_level(3) 3292 3293 def test_function_length_check_definition_below_severity4(self): 3294 self.assert_function_length_check_below_error_level(4) 3295 3296 def test_function_length_check_definition_severity4(self): 3297 self.assert_function_length_check_at_error_level(4) 3298 3299 def test_function_length_check_definition_above_severity4(self): 3300 self.assert_function_length_check_above_error_level(4) 3301 3302 def test_function_length_check_definition_below_severity5(self): 3303 self.assert_function_length_check_below_error_level(5) 3304 3305 def test_function_length_check_definition_at_severity5(self): 3306 self.assert_function_length_check_at_error_level(5) 3307 3308 def test_function_length_check_definition_above_severity5(self): 3309 self.assert_function_length_check_above_error_level(5) 3310 3311 def test_function_length_check_definition_huge_lines(self): 3312 # 5 is the limit 3313 self.assert_function_length_check_definition(self.trigger_lines(6), 5) 3314 3315 def test_function_length_not_determinable(self): 3316 # Macro invocation without terminating semicolon. 3317 self.assert_function_lengths_check( 3318 'MACRO(arg)', 3319 '') 3320 3321 # Macro with underscores 3322 self.assert_function_lengths_check( 3323 'MACRO_WITH_UNDERSCORES(arg1, arg2, arg3)', 3324 '') 3325 3326 self.assert_function_lengths_check( 3327 'NonMacro(arg)', 3328 'Lint failed to find start of function body.' 3329 ' [readability/fn_size] [5]') 3330 3331 3332class NoNonVirtualDestructorsTest(CppStyleTestBase): 3333 3334 def test_no_error(self): 3335 self.assert_multi_line_lint( 3336 '''\ 3337 class Foo { 3338 virtual ~Foo(); 3339 virtual void foo(); 3340 };''', 3341 '') 3342 3343 self.assert_multi_line_lint( 3344 '''\ 3345 class Foo { 3346 virtual inline ~Foo(); 3347 virtual void foo(); 3348 };''', 3349 '') 3350 3351 self.assert_multi_line_lint( 3352 '''\ 3353 class Foo { 3354 inline virtual ~Foo(); 3355 virtual void foo(); 3356 };''', 3357 '') 3358 3359 self.assert_multi_line_lint( 3360 '''\ 3361 class Foo::Goo { 3362 virtual ~Goo(); 3363 virtual void goo(); 3364 };''', 3365 '') 3366 self.assert_multi_line_lint( 3367 'class Foo { void foo(); };', 3368 'More than one command on the same line [whitespace/newline] [4]') 3369 self.assert_multi_line_lint( 3370 'class MyClass {\n' 3371 ' int getIntValue() { ASSERT(m_ptr); return *m_ptr; }\n' 3372 '};\n', 3373 '') 3374 self.assert_multi_line_lint( 3375 'class MyClass {\n' 3376 ' int getIntValue()\n' 3377 ' {\n' 3378 ' ASSERT(m_ptr); return *m_ptr;\n' 3379 ' }\n' 3380 '};\n', 3381 'More than one command on the same line [whitespace/newline] [4]') 3382 3383 self.assert_multi_line_lint( 3384 '''\ 3385 class Qualified::Goo : public Foo { 3386 virtual void goo(); 3387 };''', 3388 '') 3389 3390 def test_no_destructor_when_virtual_needed(self): 3391 self.assert_multi_line_lint_re( 3392 '''\ 3393 class Foo { 3394 virtual void foo(); 3395 };''', 3396 'The class Foo probably needs a virtual destructor') 3397 3398 def test_enum_casing(self): 3399 self.assert_multi_line_lint( 3400 '''\ 3401 enum Foo { 3402 FOO_ONE = 1, 3403 FOO_TWO 3404 }; 3405 enum { FOO_ONE }; 3406 enum {FooOne, fooTwo}; 3407 enum { 3408 FOO_ONE 3409 };''', 3410 ['enum members should use InterCaps with an initial capital letter. [readability/enum_casing] [4]'] * 5) 3411 3412 self.assert_multi_line_lint( 3413 '''\ 3414 enum Foo { 3415 fooOne = 1, 3416 FooTwo = 2 3417 };''', 3418 'enum members should use InterCaps with an initial capital letter. [readability/enum_casing] [4]') 3419 3420 self.assert_multi_line_lint( 3421 '''\ 3422 enum Foo { 3423 FooOne = 1, 3424 FooTwo 3425 } fooVar = FooOne; 3426 enum { FooOne, FooTwo }; 3427 enum { FooOne, FooTwo } fooVar = FooTwo; 3428 enum { FooOne= FooTwo } foo; 3429 enum Enum123 { 3430 FooOne, 3431 FooTwo = FooOne, 3432 };''', 3433 '') 3434 3435 self.assert_multi_line_lint( 3436 '''\ 3437 // WebIDL enum 3438 enum Foo { 3439 FOO_ONE = 1, 3440 FOO_TWO = 2, 3441 };''', 3442 '') 3443 3444 self.assert_multi_line_lint( 3445 '''\ 3446 // WebKitIDL enum 3447 enum Foo { FOO_ONE, FOO_TWO };''', 3448 '') 3449 3450 def test_destructor_non_virtual_when_virtual_needed(self): 3451 self.assert_multi_line_lint_re( 3452 '''\ 3453 class Foo { 3454 ~Foo(); 3455 virtual void foo(); 3456 };''', 3457 'The class Foo probably needs a virtual destructor') 3458 3459 def test_no_warn_when_derived(self): 3460 self.assert_multi_line_lint( 3461 '''\ 3462 class Foo : public Goo { 3463 virtual void foo(); 3464 };''', 3465 '') 3466 3467 def test_internal_braces(self): 3468 self.assert_multi_line_lint_re( 3469 '''\ 3470 class Foo { 3471 enum Goo { 3472 Goo 3473 }; 3474 virtual void foo(); 3475 };''', 3476 'The class Foo probably needs a virtual destructor') 3477 3478 def test_inner_class_needs_virtual_destructor(self): 3479 self.assert_multi_line_lint_re( 3480 '''\ 3481 class Foo { 3482 class Goo { 3483 virtual void goo(); 3484 }; 3485 };''', 3486 'The class Goo probably needs a virtual destructor') 3487 3488 def test_outer_class_needs_virtual_destructor(self): 3489 self.assert_multi_line_lint_re( 3490 '''\ 3491 class Foo { 3492 class Goo { 3493 }; 3494 virtual void foo(); 3495 };''', 3496 'The class Foo probably needs a virtual destructor') 3497 3498 def test_qualified_class_needs_virtual_destructor(self): 3499 self.assert_multi_line_lint_re( 3500 '''\ 3501 class Qualified::Foo { 3502 virtual void foo(); 3503 };''', 3504 'The class Qualified::Foo probably needs a virtual destructor') 3505 3506 def test_multi_line_declaration_no_error(self): 3507 self.assert_multi_line_lint_re( 3508 '''\ 3509 class Foo 3510 : public Goo { 3511 virtual void foo(); 3512 };''', 3513 '') 3514 3515 def test_multi_line_declaration_with_error(self): 3516 self.assert_multi_line_lint( 3517 '''\ 3518 class Foo 3519 { 3520 virtual void foo(); 3521 };''', 3522 ['This { should be at the end of the previous line ' 3523 '[whitespace/braces] [4]', 3524 'The class Foo probably needs a virtual destructor due to having ' 3525 'virtual method(s), one declared at line 3. [runtime/virtual] [4]']) 3526 3527 3528class PassPtrTest(CppStyleTestBase): 3529 # For http://webkit.org/coding/RefPtr.html 3530 3531 def assert_pass_ptr_check(self, code, expected_message): 3532 """Check warnings for Pass*Ptr are as expected. 3533 3534 Args: 3535 code: C++ source code expected to generate a warning message. 3536 expected_message: Message expected to be generated by the C++ code. 3537 """ 3538 self.assertEqual(expected_message, 3539 self.perform_pass_ptr_check(code)) 3540 3541 def test_pass_ref_ptr_in_function(self): 3542 self.assert_pass_ptr_check( 3543 'int myFunction()\n' 3544 '{\n' 3545 ' PassRefPtr<Type1> variable = variable2;\n' 3546 '}', 3547 'Local variables should never be PassRefPtr (see ' 3548 'http://webkit.org/coding/RefPtr.html). [readability/pass_ptr] [5]') 3549 3550 def test_pass_own_ptr_in_function(self): 3551 self.assert_pass_ptr_check( 3552 'int myFunction()\n' 3553 '{\n' 3554 ' PassOwnPtr<Type1> variable = variable2;\n' 3555 '}', 3556 'Local variables should never be PassOwnPtr (see ' 3557 'http://webkit.org/coding/RefPtr.html). [readability/pass_ptr] [5]') 3558 3559 def test_pass_other_type_ptr_in_function(self): 3560 self.assert_pass_ptr_check( 3561 'int myFunction()\n' 3562 '{\n' 3563 ' PassOtherTypePtr<Type1> variable;\n' 3564 '}', 3565 'Local variables should never be PassOtherTypePtr (see ' 3566 'http://webkit.org/coding/RefPtr.html). [readability/pass_ptr] [5]') 3567 3568 def test_pass_ref_ptr_return_value(self): 3569 self.assert_pass_ptr_check( 3570 'PassRefPtr<Type1>\n' 3571 'myFunction(int)\n' 3572 '{\n' 3573 '}', 3574 '') 3575 self.assert_pass_ptr_check( 3576 'PassRefPtr<Type1> myFunction(int)\n' 3577 '{\n' 3578 '}', 3579 '') 3580 self.assert_pass_ptr_check( 3581 'PassRefPtr<Type1> myFunction();\n', 3582 '') 3583 self.assert_pass_ptr_check( 3584 'OwnRefPtr<Type1> myFunction();\n', 3585 '') 3586 self.assert_pass_ptr_check( 3587 'RefPtr<Type1> myFunction(int)\n' 3588 '{\n' 3589 '}', 3590 'The return type should use PassRefPtr instead of RefPtr. [readability/pass_ptr] [5]') 3591 self.assert_pass_ptr_check( 3592 'OwnPtr<Type1> myFunction(int)\n' 3593 '{\n' 3594 '}', 3595 'The return type should use PassOwnPtr instead of OwnPtr. [readability/pass_ptr] [5]') 3596 3597 def test_ref_ptr_parameter_value(self): 3598 self.assert_pass_ptr_check( 3599 'int myFunction(PassRefPtr<Type1>)\n' 3600 '{\n' 3601 '}', 3602 '') 3603 self.assert_pass_ptr_check( 3604 'int myFunction(RefPtr<Type1>)\n' 3605 '{\n' 3606 '}', 3607 'The parameter type should use PassRefPtr instead of RefPtr. [readability/pass_ptr] [5]') 3608 self.assert_pass_ptr_check( 3609 'int myFunction(RefPtr<Type1>&)\n' 3610 '{\n' 3611 '}', 3612 '') 3613 self.assert_pass_ptr_check( 3614 'int myFunction(RefPtr<Type1>*)\n' 3615 '{\n' 3616 '}', 3617 '') 3618 self.assert_pass_ptr_check( 3619 'int myFunction(RefPtr<Type1>* = 0)\n' 3620 '{\n' 3621 '}', 3622 '') 3623 self.assert_pass_ptr_check( 3624 'int myFunction(RefPtr<Type1>* = 0)\n' 3625 '{\n' 3626 '}', 3627 '') 3628 3629 def test_own_ptr_parameter_value(self): 3630 self.assert_pass_ptr_check( 3631 'int myFunction(PassOwnPtr<Type1>)\n' 3632 '{\n' 3633 '}', 3634 '') 3635 self.assert_pass_ptr_check( 3636 'int myFunction(OwnPtr<Type1>)\n' 3637 '{\n' 3638 '}', 3639 'The parameter type should use PassOwnPtr instead of OwnPtr. [readability/pass_ptr] [5]') 3640 self.assert_pass_ptr_check( 3641 'int myFunction(OwnPtr<Type1>& simple)\n' 3642 '{\n' 3643 '}', 3644 '') 3645 3646 def test_ref_ptr_member_variable(self): 3647 self.assert_pass_ptr_check( 3648 'class Foo {' 3649 ' RefPtr<Type1> m_other;\n' 3650 '};\n', 3651 '') 3652 3653 3654class LeakyPatternTest(CppStyleTestBase): 3655 3656 def assert_leaky_pattern_check(self, code, expected_message): 3657 """Check warnings for leaky patterns are as expected. 3658 3659 Args: 3660 code: C++ source code expected to generate a warning message. 3661 expected_message: Message expected to be generated by the C++ code. 3662 """ 3663 self.assertEqual(expected_message, 3664 self.perform_leaky_pattern_check(code)) 3665 3666 def test_get_dc(self): 3667 self.assert_leaky_pattern_check( 3668 'HDC hdc = GetDC(hwnd);', 3669 'Use the class HWndDC instead of calling GetDC to avoid potential ' 3670 'memory leaks. [runtime/leaky_pattern] [5]') 3671 3672 def test_get_dc(self): 3673 self.assert_leaky_pattern_check( 3674 'HDC hdc = GetDCEx(hwnd, 0, 0);', 3675 'Use the class HWndDC instead of calling GetDCEx to avoid potential ' 3676 'memory leaks. [runtime/leaky_pattern] [5]') 3677 3678 def test_own_get_dc(self): 3679 self.assert_leaky_pattern_check( 3680 'HWndDC hdc(hwnd);', 3681 '') 3682 3683 def test_create_dc(self): 3684 self.assert_leaky_pattern_check( 3685 'HDC dc2 = ::CreateDC();', 3686 'Use adoptPtr and OwnPtr<HDC> when calling CreateDC to avoid potential ' 3687 'memory leaks. [runtime/leaky_pattern] [5]') 3688 3689 self.assert_leaky_pattern_check( 3690 'adoptPtr(CreateDC());', 3691 '') 3692 3693 def test_create_compatible_dc(self): 3694 self.assert_leaky_pattern_check( 3695 'HDC dc2 = CreateCompatibleDC(dc);', 3696 'Use adoptPtr and OwnPtr<HDC> when calling CreateCompatibleDC to avoid potential ' 3697 'memory leaks. [runtime/leaky_pattern] [5]') 3698 self.assert_leaky_pattern_check( 3699 'adoptPtr(CreateCompatibleDC(dc));', 3700 '') 3701 3702 3703class WebKitStyleTest(CppStyleTestBase): 3704 3705 # for http://webkit.org/coding/coding-style.html 3706 def test_indentation(self): 3707 # 1. Use spaces, not tabs. Tabs should only appear in files that 3708 # require them for semantic meaning, like Makefiles. 3709 self.assert_multi_line_lint( 3710 'class Foo {\n' 3711 ' int goo;\n' 3712 '};', 3713 '') 3714 self.assert_multi_line_lint( 3715 'class Foo {\n' 3716 '\tint goo;\n' 3717 '};', 3718 'Tab found; better to use spaces [whitespace/tab] [1]') 3719 3720 # 2. The indent size is 4 spaces. 3721 self.assert_multi_line_lint( 3722 'class Foo {\n' 3723 ' int goo;\n' 3724 '};', 3725 '') 3726 self.assert_multi_line_lint( 3727 'class Foo {\n' 3728 ' int goo;\n' 3729 '};', 3730 'Weird number of spaces at line-start. Are you using a 4-space indent? [whitespace/indent] [3]') 3731 3732 # 3. In a header, code inside a namespace should not be indented. 3733 self.assert_multi_line_lint( 3734 'namespace WebCore {\n\n' 3735 'class Document {\n' 3736 ' int myVariable;\n' 3737 '};\n' 3738 '}', 3739 '', 3740 'foo.h') 3741 self.assert_multi_line_lint( 3742 'namespace OuterNamespace {\n' 3743 ' namespace InnerNamespace {\n' 3744 ' class Document {\n' 3745 '};\n' 3746 '};\n' 3747 '}', 3748 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3749 'foo.h') 3750 self.assert_multi_line_lint( 3751 'namespace OuterNamespace {\n' 3752 ' class Document {\n' 3753 ' namespace InnerNamespace {\n' 3754 '};\n' 3755 '};\n' 3756 '}', 3757 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3758 'foo.h') 3759 self.assert_multi_line_lint( 3760 'namespace WebCore {\n' 3761 '#if 0\n' 3762 ' class Document {\n' 3763 '};\n' 3764 '#endif\n' 3765 '}', 3766 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3767 'foo.h') 3768 self.assert_multi_line_lint( 3769 'namespace WebCore {\n' 3770 'class Document {\n' 3771 '};\n' 3772 '}', 3773 '', 3774 'foo.h') 3775 3776 # 4. In an implementation file (files with the extension .cpp, .c 3777 # or .mm), code inside a namespace should not be indented. 3778 self.assert_multi_line_lint( 3779 'namespace WebCore {\n\n' 3780 'Document::Foo()\n' 3781 ' : foo(bar)\n' 3782 ' , boo(far)\n' 3783 '{\n' 3784 ' stuff();\n' 3785 '}', 3786 '', 3787 'foo.cpp') 3788 self.assert_multi_line_lint( 3789 'namespace OuterNamespace {\n' 3790 'namespace InnerNamespace {\n' 3791 'Document::Foo() { }\n' 3792 ' void* p;\n' 3793 '}\n' 3794 '}\n', 3795 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3796 'foo.cpp') 3797 self.assert_multi_line_lint( 3798 'namespace OuterNamespace {\n' 3799 'namespace InnerNamespace {\n' 3800 'Document::Foo() { }\n' 3801 '}\n' 3802 ' void* p;\n' 3803 '}\n', 3804 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3805 'foo.cpp') 3806 self.assert_multi_line_lint( 3807 'namespace WebCore {\n\n' 3808 ' const char* foo = "start:;"\n' 3809 ' "dfsfsfs";\n' 3810 '}\n', 3811 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3812 'foo.cpp') 3813 self.assert_multi_line_lint( 3814 'namespace WebCore {\n\n' 3815 'const char* foo(void* a = ";", // ;\n' 3816 ' void* b);\n' 3817 ' void* p;\n' 3818 '}\n', 3819 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3820 'foo.cpp') 3821 self.assert_multi_line_lint( 3822 'namespace WebCore {\n\n' 3823 'const char* foo[] = {\n' 3824 ' "void* b);", // ;\n' 3825 ' "asfdf",\n' 3826 ' }\n' 3827 ' void* p;\n' 3828 '}\n', 3829 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3830 'foo.cpp') 3831 self.assert_multi_line_lint( 3832 'namespace WebCore {\n\n' 3833 'const char* foo[] = {\n' 3834 ' "void* b);", // }\n' 3835 ' "asfdf",\n' 3836 ' }\n' 3837 '}\n', 3838 '', 3839 'foo.cpp') 3840 self.assert_multi_line_lint( 3841 ' namespace WebCore {\n\n' 3842 ' void Document::Foo()\n' 3843 ' {\n' 3844 'start: // infinite loops are fun!\n' 3845 ' goto start;\n' 3846 ' }', 3847 'namespace should never be indented. [whitespace/indent] [4]', 3848 'foo.cpp') 3849 self.assert_multi_line_lint( 3850 'namespace WebCore {\n' 3851 ' Document::Foo() { }\n' 3852 '}', 3853 'Code inside a namespace should not be indented.' 3854 ' [whitespace/indent] [4]', 3855 'foo.cpp') 3856 self.assert_multi_line_lint( 3857 'namespace WebCore {\n' 3858 '#define abc(x) x; \\\n' 3859 ' x\n' 3860 '}', 3861 '', 3862 'foo.cpp') 3863 self.assert_multi_line_lint( 3864 'namespace WebCore {\n' 3865 '#define abc(x) x; \\\n' 3866 ' x\n' 3867 ' void* x;' 3868 '}', 3869 'Code inside a namespace should not be indented. [whitespace/indent] [4]', 3870 'foo.cpp') 3871 3872 # 5. A case label should line up with its switch statement. The 3873 # case statement is indented. 3874 self.assert_multi_line_lint( 3875 ' switch (condition) {\n' 3876 ' case fooCondition:\n' 3877 ' case barCondition:\n' 3878 ' i++;\n' 3879 ' break;\n' 3880 ' default:\n' 3881 ' i--;\n' 3882 ' }\n', 3883 '') 3884 self.assert_multi_line_lint( 3885 ' switch (condition) {\n' 3886 ' case fooCondition:\n' 3887 ' switch (otherCondition) {\n' 3888 ' default:\n' 3889 ' return;\n' 3890 ' }\n' 3891 ' default:\n' 3892 ' i--;\n' 3893 ' }\n', 3894 '') 3895 self.assert_multi_line_lint( 3896 ' switch (condition) {\n' 3897 ' case fooCondition: break;\n' 3898 ' default: return;\n' 3899 ' }\n', 3900 '') 3901 self.assert_multi_line_lint( 3902 ' switch (condition) {\n' 3903 ' case fooCondition:\n' 3904 ' case barCondition:\n' 3905 ' i++;\n' 3906 ' break;\n' 3907 ' default:\n' 3908 ' i--;\n' 3909 ' }\n', 3910 'A case label should not be indented, but line up with its switch statement.' 3911 ' [whitespace/indent] [4]') 3912 self.assert_multi_line_lint( 3913 ' switch (condition) {\n' 3914 ' case fooCondition:\n' 3915 ' break;\n' 3916 ' default:\n' 3917 ' i--;\n' 3918 ' }\n', 3919 'A case label should not be indented, but line up with its switch statement.' 3920 ' [whitespace/indent] [4]') 3921 self.assert_multi_line_lint( 3922 ' switch (condition) {\n' 3923 ' case fooCondition:\n' 3924 ' case barCondition:\n' 3925 ' switch (otherCondition) {\n' 3926 ' default:\n' 3927 ' return;\n' 3928 ' }\n' 3929 ' default:\n' 3930 ' i--;\n' 3931 ' }\n', 3932 'A case label should not be indented, but line up with its switch statement.' 3933 ' [whitespace/indent] [4]') 3934 self.assert_multi_line_lint( 3935 ' switch (condition) {\n' 3936 ' case fooCondition:\n' 3937 ' case barCondition:\n' 3938 ' i++;\n' 3939 ' break;\n\n' 3940 ' default:\n' 3941 ' i--;\n' 3942 ' }\n', 3943 'Non-label code inside switch statements should be indented.' 3944 ' [whitespace/indent] [4]') 3945 self.assert_multi_line_lint( 3946 ' switch (condition) {\n' 3947 ' case fooCondition:\n' 3948 ' case barCondition:\n' 3949 ' switch (otherCondition) {\n' 3950 ' default:\n' 3951 ' return;\n' 3952 ' }\n' 3953 ' default:\n' 3954 ' i--;\n' 3955 ' }\n', 3956 'Non-label code inside switch statements should be indented.' 3957 ' [whitespace/indent] [4]') 3958 3959 # 6. Boolean expressions at the same nesting level that span 3960 # multiple lines should have their operators on the left side of 3961 # the line instead of the right side. 3962 self.assert_multi_line_lint( 3963 ' return attr->name() == srcAttr\n' 3964 ' || attr->name() == lowsrcAttr;\n', 3965 '') 3966 self.assert_multi_line_lint( 3967 ' return attr->name() == srcAttr ||\n' 3968 ' attr->name() == lowsrcAttr;\n', 3969 'Boolean expressions that span multiple lines should have their ' 3970 'operators on the left side of the line instead of the right side.' 3971 ' [whitespace/operators] [4]') 3972 3973 def test_spacing(self): 3974 # 1. Do not place spaces around unary operators. 3975 self.assert_multi_line_lint( 3976 'i++;', 3977 '') 3978 self.assert_multi_line_lint( 3979 'i ++;', 3980 'Extra space for operator ++; [whitespace/operators] [4]') 3981 3982 # 2. Do place spaces around binary and ternary operators. 3983 self.assert_multi_line_lint( 3984 'y = m * x + b;', 3985 '') 3986 self.assert_multi_line_lint( 3987 'f(a, b);', 3988 '') 3989 self.assert_multi_line_lint( 3990 'c = a | b;', 3991 '') 3992 self.assert_multi_line_lint( 3993 'return condition ? 1 : 0;', 3994 '') 3995 self.assert_multi_line_lint( 3996 'y=m*x+b;', 3997 'Missing spaces around = [whitespace/operators] [4]') 3998 self.assert_multi_line_lint( 3999 'f(a,b);', 4000 'Missing space after , [whitespace/comma] [3]') 4001 self.assert_multi_line_lint( 4002 'c = a|b;', 4003 'Missing spaces around | [whitespace/operators] [3]') 4004 # FIXME: We cannot catch this lint error. 4005 # self.assert_multi_line_lint( 4006 # 'return condition ? 1:0;', 4007 # '') 4008 4009 # 3. Place spaces between control statements and their parentheses. 4010 self.assert_multi_line_lint( 4011 ' if (condition)\n' 4012 ' doIt();\n', 4013 '') 4014 self.assert_multi_line_lint( 4015 ' if(condition)\n' 4016 ' doIt();\n', 4017 'Missing space before ( in if( [whitespace/parens] [5]') 4018 4019 # 4. Do not place spaces between a function and its parentheses, 4020 # or between a parenthesis and its content. 4021 self.assert_multi_line_lint( 4022 'f(a, b);', 4023 '') 4024 self.assert_multi_line_lint( 4025 'f (a, b);', 4026 'Extra space before ( in function call [whitespace/parens] [4]') 4027 self.assert_multi_line_lint( 4028 'f( a, b );', 4029 ['Extra space after ( in function call [whitespace/parens] [4]', 4030 'Extra space before ) [whitespace/parens] [2]']) 4031 4032 def test_line_breaking(self): 4033 # 1. Each statement should get its own line. 4034 self.assert_multi_line_lint( 4035 ' x++;\n' 4036 ' y++;\n' 4037 ' if (condition);\n' 4038 ' doIt();\n', 4039 '') 4040 self.assert_multi_line_lint( 4041 ' if (condition) \\\n' 4042 ' doIt();\n', 4043 '') 4044 self.assert_multi_line_lint( 4045 ' x++; y++;', 4046 'More than one command on the same line [whitespace/newline] [4]') 4047 self.assert_multi_line_lint( 4048 ' if (condition) doIt();\n', 4049 'More than one command on the same line in if [whitespace/parens] [4]') 4050 # Ensure that having a # in the line doesn't hide the error. 4051 self.assert_multi_line_lint( 4052 ' x++; char a[] = "#";', 4053 'More than one command on the same line [whitespace/newline] [4]') 4054 # Ignore preprocessor if's. 4055 self.assert_multi_line_lint( 4056 '#if (condition) || (condition2)\n', 4057 '') 4058 4059 # 2. An else statement should go on the same line as a preceding 4060 # close brace if one is present, else it should line up with the 4061 # if statement. 4062 self.assert_multi_line_lint( 4063 'if (condition) {\n' 4064 ' doSomething();\n' 4065 ' doSomethingAgain();\n' 4066 '} else {\n' 4067 ' doSomethingElse();\n' 4068 ' doSomethingElseAgain();\n' 4069 '}\n', 4070 '') 4071 self.assert_multi_line_lint( 4072 'if (condition)\n' 4073 ' doSomething();\n' 4074 'else\n' 4075 ' doSomethingElse();\n', 4076 '') 4077 self.assert_multi_line_lint( 4078 'if (condition) {\n' 4079 ' doSomething();\n' 4080 '} else {\n' 4081 ' doSomethingElse();\n' 4082 ' doSomethingElseAgain();\n' 4083 '}\n', 4084 '') 4085 self.assert_multi_line_lint( 4086 '#define TEST_ASSERT(expression) do { if (!(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0)\n', 4087 '') 4088 self.assert_multi_line_lint( 4089 '#define TEST_ASSERT(expression) do { if ( !(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0)\n', 4090 'Extra space after ( in if [whitespace/parens] [5]') 4091 # FIXME: currently we only check first conditional, so we cannot detect errors in next ones. 4092 # self.assert_multi_line_lint( 4093 # '#define TEST_ASSERT(expression) do { if (!(expression)) { TestsController::shared().testFailed(__FILE__, __LINE__, #expression); return; } } while (0 )\n', 4094 # 'Mismatching spaces inside () in if [whitespace/parens] [5]') 4095 self.assert_multi_line_lint( 4096 'WTF_MAKE_NONCOPYABLE(ClassName); WTF_MAKE_FAST_ALLOCATED;\n', 4097 '') 4098 self.assert_multi_line_lint( 4099 'if (condition) {\n' 4100 ' doSomething();\n' 4101 ' doSomethingAgain();\n' 4102 '}\n' 4103 'else {\n' 4104 ' doSomethingElse();\n' 4105 ' doSomethingElseAgain();\n' 4106 '}\n', 4107 'An else should appear on the same line as the preceding } [whitespace/newline] [4]') 4108 self.assert_multi_line_lint( 4109 'if (condition) doSomething(); else doSomethingElse();\n', 4110 ['More than one command on the same line [whitespace/newline] [4]', 4111 'Else clause should never be on same line as else (use 2 lines) [whitespace/newline] [4]', 4112 'More than one command on the same line in if [whitespace/parens] [4]']) 4113 self.assert_multi_line_lint( 4114 'if (condition) doSomething(); else {\n' 4115 ' doSomethingElse();\n' 4116 '}\n', 4117 ['More than one command on the same line in if [whitespace/parens] [4]', 4118 'If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]']) 4119 self.assert_multi_line_lint( 4120 'void func()\n' 4121 '{\n' 4122 ' while (condition) { }\n' 4123 ' return 0;\n' 4124 '}\n', 4125 '') 4126 self.assert_multi_line_lint( 4127 'void func()\n' 4128 '{\n' 4129 ' for (i = 0; i < 42; i++) { foobar(); }\n' 4130 ' return 0;\n' 4131 '}\n', 4132 'More than one command on the same line in for [whitespace/parens] [4]') 4133 4134 # 3. An else if statement should be written as an if statement 4135 # when the prior if concludes with a return statement. 4136 self.assert_multi_line_lint( 4137 'if (motivated) {\n' 4138 ' if (liquid)\n' 4139 ' return money;\n' 4140 '} else if (tired) {\n' 4141 ' break;\n' 4142 '}', 4143 '') 4144 self.assert_multi_line_lint( 4145 'if (condition)\n' 4146 ' doSomething();\n' 4147 'else if (otherCondition)\n' 4148 ' doSomethingElse();\n', 4149 '') 4150 self.assert_multi_line_lint( 4151 'if (condition)\n' 4152 ' doSomething();\n' 4153 'else\n' 4154 ' doSomethingElse();\n', 4155 '') 4156 self.assert_multi_line_lint( 4157 'if (condition)\n' 4158 ' returnValue = foo;\n' 4159 'else if (otherCondition)\n' 4160 ' returnValue = bar;\n', 4161 '') 4162 self.assert_multi_line_lint( 4163 'if (condition)\n' 4164 ' returnValue = foo;\n' 4165 'else\n' 4166 ' returnValue = bar;\n', 4167 '') 4168 self.assert_multi_line_lint( 4169 'if (condition)\n' 4170 ' doSomething();\n' 4171 'else if (liquid)\n' 4172 ' return money;\n' 4173 'else if (broke)\n' 4174 ' return favor;\n' 4175 'else\n' 4176 ' sleep(28800);\n', 4177 '') 4178 self.assert_multi_line_lint( 4179 'if (liquid) {\n' 4180 ' prepare();\n' 4181 ' return money;\n' 4182 '} else if (greedy) {\n' 4183 ' keep();\n' 4184 ' return nothing;\n' 4185 '}\n', 4186 'An else if statement should be written as an if statement when the ' 4187 'prior "if" concludes with a return, break, continue or goto statement.' 4188 ' [readability/control_flow] [4]') 4189 self.assert_multi_line_lint( 4190 ' if (stupid) {\n' 4191 'infiniteLoop:\n' 4192 ' goto infiniteLoop;\n' 4193 ' } else if (evil)\n' 4194 ' goto hell;\n', 4195 ['If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]', 4196 'An else if statement should be written as an if statement when the ' 4197 'prior "if" concludes with a return, break, continue or goto statement.' 4198 ' [readability/control_flow] [4]']) 4199 self.assert_multi_line_lint( 4200 'if (liquid)\n' 4201 '{\n' 4202 ' prepare();\n' 4203 ' return money;\n' 4204 '}\n' 4205 'else if (greedy)\n' 4206 ' keep();\n', 4207 ['If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]', 4208 'This { should be at the end of the previous line [whitespace/braces] [4]', 4209 'An else should appear on the same line as the preceding } [whitespace/newline] [4]', 4210 'An else if statement should be written as an if statement when the ' 4211 'prior "if" concludes with a return, break, continue or goto statement.' 4212 ' [readability/control_flow] [4]']) 4213 self.assert_multi_line_lint( 4214 'if (gone)\n' 4215 ' return;\n' 4216 'else if (here)\n' 4217 ' go();\n', 4218 'An else if statement should be written as an if statement when the ' 4219 'prior "if" concludes with a return, break, continue or goto statement.' 4220 ' [readability/control_flow] [4]') 4221 self.assert_multi_line_lint( 4222 'if (gone)\n' 4223 ' return;\n' 4224 'else\n' 4225 ' go();\n', 4226 'An else statement can be removed when the prior "if" concludes ' 4227 'with a return, break, continue or goto statement.' 4228 ' [readability/control_flow] [4]') 4229 self.assert_multi_line_lint( 4230 'if (motivated) {\n' 4231 ' prepare();\n' 4232 ' continue;\n' 4233 '} else {\n' 4234 ' cleanUp();\n' 4235 ' break;\n' 4236 '}\n', 4237 'An else statement can be removed when the prior "if" concludes ' 4238 'with a return, break, continue or goto statement.' 4239 ' [readability/control_flow] [4]') 4240 self.assert_multi_line_lint( 4241 'if (tired)\n' 4242 ' break;\n' 4243 'else {\n' 4244 ' prepare();\n' 4245 ' continue;\n' 4246 '}\n', 4247 ['If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]', 4248 'An else statement can be removed when the prior "if" concludes ' 4249 'with a return, break, continue or goto statement.' 4250 ' [readability/control_flow] [4]']) 4251 4252 def test_braces(self): 4253 # 1. Function definitions: place each brace on its own line. 4254 self.assert_multi_line_lint( 4255 'int main()\n' 4256 '{\n' 4257 ' doSomething();\n' 4258 '}\n', 4259 '') 4260 self.assert_multi_line_lint( 4261 'int main() {\n' 4262 ' doSomething();\n' 4263 '}\n', 4264 'Place brace on its own line for function definitions. [whitespace/braces] [4]') 4265 4266 # 2. Other braces: place the open brace on the line preceding the 4267 # code block; place the close brace on its own line. 4268 self.assert_multi_line_lint( 4269 'class MyClass {\n' 4270 ' int foo;\n' 4271 '};\n', 4272 '') 4273 self.assert_multi_line_lint( 4274 'namespace WebCore {\n' 4275 'int foo;\n' 4276 '};\n', 4277 '') 4278 self.assert_multi_line_lint( 4279 'for (int i = 0; i < 10; i++) {\n' 4280 ' DoSomething();\n' 4281 '};\n', 4282 '') 4283 self.assert_multi_line_lint( 4284 'class MyClass\n' 4285 '{\n' 4286 ' int foo;\n' 4287 '};\n', 4288 'This { should be at the end of the previous line [whitespace/braces] [4]') 4289 self.assert_multi_line_lint( 4290 'if (condition)\n' 4291 '{\n' 4292 ' int foo;\n' 4293 '}\n', 4294 'This { should be at the end of the previous line [whitespace/braces] [4]') 4295 self.assert_multi_line_lint( 4296 'for (int i = 0; i < 10; i++)\n' 4297 '{\n' 4298 ' int foo;\n' 4299 '}\n', 4300 'This { should be at the end of the previous line [whitespace/braces] [4]') 4301 self.assert_multi_line_lint( 4302 'while (true)\n' 4303 '{\n' 4304 ' int foo;\n' 4305 '}\n', 4306 'This { should be at the end of the previous line [whitespace/braces] [4]') 4307 self.assert_multi_line_lint( 4308 'foreach (Foo* foo, foos)\n' 4309 '{\n' 4310 ' int bar;\n' 4311 '}\n', 4312 'This { should be at the end of the previous line [whitespace/braces] [4]') 4313 self.assert_multi_line_lint( 4314 'switch (type)\n' 4315 '{\n' 4316 'case foo: return;\n' 4317 '}\n', 4318 'This { should be at the end of the previous line [whitespace/braces] [4]') 4319 self.assert_multi_line_lint( 4320 'if (condition)\n' 4321 '{\n' 4322 ' int foo;\n' 4323 '}\n', 4324 'This { should be at the end of the previous line [whitespace/braces] [4]') 4325 self.assert_multi_line_lint( 4326 'for (int i = 0; i < 10; i++)\n' 4327 '{\n' 4328 ' int foo;\n' 4329 '}\n', 4330 'This { should be at the end of the previous line [whitespace/braces] [4]') 4331 self.assert_multi_line_lint( 4332 'while (true)\n' 4333 '{\n' 4334 ' int foo;\n' 4335 '}\n', 4336 'This { should be at the end of the previous line [whitespace/braces] [4]') 4337 self.assert_multi_line_lint( 4338 'switch (type)\n' 4339 '{\n' 4340 'case foo: return;\n' 4341 '}\n', 4342 'This { should be at the end of the previous line [whitespace/braces] [4]') 4343 self.assert_multi_line_lint( 4344 'else if (type)\n' 4345 '{\n' 4346 'case foo: return;\n' 4347 '}\n', 4348 'This { should be at the end of the previous line [whitespace/braces] [4]') 4349 4350 # 3. Curly braces are not required for single-line conditionals and 4351 # loop bodies, but are required for single-statement bodies that 4352 # span multiple lines. 4353 4354 # 4355 # Positive tests 4356 # 4357 self.assert_multi_line_lint( 4358 'if (condition1)\n' 4359 ' statement1();\n' 4360 'else\n' 4361 ' statement2();\n', 4362 '') 4363 4364 self.assert_multi_line_lint( 4365 'if (condition1)\n' 4366 ' statement1();\n' 4367 'else if (condition2)\n' 4368 ' statement2();\n', 4369 '') 4370 4371 self.assert_multi_line_lint( 4372 'if (condition1)\n' 4373 ' statement1();\n' 4374 'else if (condition2)\n' 4375 ' statement2();\n' 4376 'else\n' 4377 ' statement3();\n', 4378 '') 4379 4380 self.assert_multi_line_lint( 4381 'for (; foo; bar)\n' 4382 ' int foo;\n', 4383 '') 4384 4385 self.assert_multi_line_lint( 4386 'for (; foo; bar) {\n' 4387 ' int foo;\n' 4388 '}\n', 4389 '') 4390 4391 self.assert_multi_line_lint( 4392 'foreach (foo, foos) {\n' 4393 ' int bar;\n' 4394 '}\n', 4395 '') 4396 4397 self.assert_multi_line_lint( 4398 'foreach (foo, foos)\n' 4399 ' int bar;\n', 4400 '') 4401 4402 self.assert_multi_line_lint( 4403 'while (true) {\n' 4404 ' int foo;\n' 4405 '}\n', 4406 '') 4407 4408 self.assert_multi_line_lint( 4409 'while (true)\n' 4410 ' int foo;\n', 4411 '') 4412 4413 self.assert_multi_line_lint( 4414 'if (condition1) {\n' 4415 ' statement1();\n' 4416 '} else {\n' 4417 ' statement2();\n' 4418 '}\n', 4419 '') 4420 4421 self.assert_multi_line_lint( 4422 'if (condition1) {\n' 4423 ' statement1();\n' 4424 '} else if (condition2) {\n' 4425 ' statement2();\n' 4426 '}\n', 4427 '') 4428 4429 self.assert_multi_line_lint( 4430 'if (condition1) {\n' 4431 ' statement1();\n' 4432 '} else if (condition2) {\n' 4433 ' statement2();\n' 4434 '} else {\n' 4435 ' statement3();\n' 4436 '}\n', 4437 '') 4438 4439 self.assert_multi_line_lint( 4440 'if (condition1) {\n' 4441 ' statement1();\n' 4442 ' statement1_2();\n' 4443 '} else if (condition2) {\n' 4444 ' statement2();\n' 4445 ' statement2_2();\n' 4446 '}\n', 4447 '') 4448 4449 self.assert_multi_line_lint( 4450 'if (condition1) {\n' 4451 ' statement1();\n' 4452 ' statement1_2();\n' 4453 '} else if (condition2) {\n' 4454 ' statement2();\n' 4455 ' statement2_2();\n' 4456 '} else {\n' 4457 ' statement3();\n' 4458 ' statement3_2();\n' 4459 '}\n', 4460 '') 4461 4462 # 4463 # Negative tests 4464 # 4465 4466 self.assert_multi_line_lint( 4467 'if (condition)\n' 4468 ' doSomething(\n' 4469 ' spanningMultipleLines);\n', 4470 'A conditional or loop body must use braces if the statement is more than one line long. [whitespace/braces] [4]') 4471 4472 self.assert_multi_line_lint( 4473 'if (condition)\n' 4474 ' // Single-line comment\n' 4475 ' doSomething();\n', 4476 'A conditional or loop body must use braces if the statement is more than one line long. [whitespace/braces] [4]') 4477 4478 self.assert_multi_line_lint( 4479 'if (condition1)\n' 4480 ' statement1();\n' 4481 'else if (condition2)\n' 4482 ' // Single-line comment\n' 4483 ' statement2();\n', 4484 'A conditional or loop body must use braces if the statement is more than one line long. [whitespace/braces] [4]') 4485 4486 self.assert_multi_line_lint( 4487 'if (condition1)\n' 4488 ' statement1();\n' 4489 'else if (condition2)\n' 4490 ' statement2();\n' 4491 'else\n' 4492 ' // Single-line comment\n' 4493 ' statement3();\n', 4494 'A conditional or loop body must use braces if the statement is more than one line long. [whitespace/braces] [4]') 4495 4496 self.assert_multi_line_lint( 4497 'for (; foo; bar)\n' 4498 ' // Single-line comment\n' 4499 ' int foo;\n', 4500 'A conditional or loop body must use braces if the statement is more than one line long. [whitespace/braces] [4]') 4501 4502 self.assert_multi_line_lint( 4503 'foreach (foo, foos)\n' 4504 ' // Single-line comment\n' 4505 ' int bar;\n', 4506 'A conditional or loop body must use braces if the statement is more than one line long. [whitespace/braces] [4]') 4507 4508 self.assert_multi_line_lint( 4509 'while (true)\n' 4510 ' // Single-line comment\n' 4511 ' int foo;\n' 4512 '\n', 4513 'A conditional or loop body must use braces if the statement is more than one line long. [whitespace/braces] [4]') 4514 4515 # 4. If one part of an if-else statement uses curly braces, the 4516 # other part must too. 4517 4518 self.assert_multi_line_lint( 4519 'if (condition1) {\n' 4520 ' doSomething1();\n' 4521 ' doSomething1_2();\n' 4522 '} else if (condition2)\n' 4523 ' doSomething2();\n' 4524 'else\n' 4525 ' doSomething3();\n', 4526 'If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]') 4527 4528 self.assert_multi_line_lint( 4529 'if (condition1)\n' 4530 ' doSomething1();\n' 4531 'else if (condition2) {\n' 4532 ' doSomething2();\n' 4533 ' doSomething2_2();\n' 4534 '} else\n' 4535 ' doSomething3();\n', 4536 'If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]') 4537 4538 self.assert_multi_line_lint( 4539 'if (condition1) {\n' 4540 ' doSomething1();\n' 4541 '} else if (condition2) {\n' 4542 ' doSomething2();\n' 4543 ' doSomething2_2();\n' 4544 '} else\n' 4545 ' doSomething3();\n', 4546 'If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]') 4547 4548 self.assert_multi_line_lint( 4549 'if (condition1)\n' 4550 ' doSomething1();\n' 4551 'else if (condition2)\n' 4552 ' doSomething2();\n' 4553 'else {\n' 4554 ' doSomething3();\n' 4555 ' doSomething3_2();\n' 4556 '}\n', 4557 'If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]') 4558 4559 self.assert_multi_line_lint( 4560 'if (condition1) {\n' 4561 ' doSomething1();\n' 4562 ' doSomething1_2();\n' 4563 '} else if (condition2)\n' 4564 ' doSomething2();\n' 4565 'else {\n' 4566 ' doSomething3();\n' 4567 ' doSomething3_2();\n' 4568 '}\n', 4569 'If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]') 4570 4571 self.assert_multi_line_lint( 4572 'if (condition1)\n' 4573 ' doSomething1();\n' 4574 'else if (condition2) {\n' 4575 ' doSomething2();\n' 4576 ' doSomething2_2();\n' 4577 '} else {\n' 4578 ' doSomething3();\n' 4579 ' doSomething3_2();\n' 4580 '}\n', 4581 'If one part of an if-else statement uses curly braces, the other part must too. [whitespace/braces] [4]') 4582 4583 4584 # 5. Control clauses without a body should use empty braces. 4585 self.assert_multi_line_lint( 4586 'for ( ; current; current = current->next) { }\n', 4587 '') 4588 self.assert_multi_line_lint( 4589 'for ( ; current;\n' 4590 ' current = current->next) { }\n', 4591 'Weird number of spaces at line-start. Are you using a 4-space indent? [whitespace/indent] [3]') 4592 self.assert_multi_line_lint( 4593 'for ( ; current; current = current->next);\n', 4594 'Semicolon defining empty statement for this loop. Use { } instead. [whitespace/semicolon] [5]') 4595 self.assert_multi_line_lint( 4596 'while (true);\n', 4597 'Semicolon defining empty statement for this loop. Use { } instead. [whitespace/semicolon] [5]') 4598 self.assert_multi_line_lint( 4599 '} while (true);\n', 4600 '') 4601 4602 def test_null_false_zero(self): 4603 # 1. In C++, the null pointer value should be written as 0. In C, 4604 # it should be written as NULL. In Objective-C and Objective-C++, 4605 # follow the guideline for C or C++, respectively, but use nil to 4606 # represent a null Objective-C object. 4607 self.assert_lint( 4608 'functionCall(NULL)', 4609 'Use 0 instead of NULL.' 4610 ' [readability/null] [5]', 4611 'foo.cpp') 4612 self.assert_lint( 4613 "// Don't use NULL in comments since it isn't in code.", 4614 'Use 0 or null instead of NULL (even in *comments*).' 4615 ' [readability/null] [4]', 4616 'foo.cpp') 4617 self.assert_lint( 4618 '"A string with NULL" // and a comment with NULL is tricky to flag correctly in cpp_style.', 4619 'Use 0 or null instead of NULL (even in *comments*).' 4620 ' [readability/null] [4]', 4621 'foo.cpp') 4622 self.assert_lint( 4623 '"A string containing NULL is ok"', 4624 '', 4625 'foo.cpp') 4626 self.assert_lint( 4627 'if (aboutNULL)', 4628 '', 4629 'foo.cpp') 4630 self.assert_lint( 4631 'myVariable = NULLify', 4632 '', 4633 'foo.cpp') 4634 # Make sure that the NULL check does not apply to C and Objective-C files. 4635 self.assert_lint( 4636 'functionCall(NULL)', 4637 '', 4638 'foo.c') 4639 self.assert_lint( 4640 'functionCall(NULL)', 4641 '', 4642 'foo.m') 4643 4644 # Make sure that the NULL check does not apply to g_object_{set,get} and 4645 # g_str{join,concat} 4646 self.assert_lint( 4647 'g_object_get(foo, "prop", &bar, NULL);', 4648 '') 4649 self.assert_lint( 4650 'g_object_set(foo, "prop", bar, NULL);', 4651 '') 4652 self.assert_lint( 4653 'g_build_filename(foo, bar, NULL);', 4654 '') 4655 self.assert_lint( 4656 'gst_bin_add_many(foo, bar, boo, NULL);', 4657 '') 4658 self.assert_lint( 4659 'gst_bin_remove_many(foo, bar, boo, NULL);', 4660 '') 4661 self.assert_lint( 4662 'gst_element_link_many(foo, bar, boo, NULL);', 4663 '') 4664 self.assert_lint( 4665 'gst_element_unlink_many(foo, bar, boo, NULL);', 4666 '') 4667 self.assert_lint( 4668 'gst_structure_get(foo, "value", G_TYPE_INT, &value, NULL);', 4669 '') 4670 self.assert_lint( 4671 'gst_structure_set(foo, "value", G_TYPE_INT, value, NULL);', 4672 '') 4673 self.assert_lint( 4674 'gst_structure_remove_fields(foo, "value", "bar", NULL);', 4675 '') 4676 self.assert_lint( 4677 'gst_structure_new("foo", "value", G_TYPE_INT, value, NULL);', 4678 '') 4679 self.assert_lint( 4680 'gst_structure_id_new(FOO, VALUE, G_TYPE_INT, value, NULL);', 4681 '') 4682 self.assert_lint( 4683 'gst_structure_id_set(FOO, VALUE, G_TYPE_INT, value, NULL);', 4684 '') 4685 self.assert_lint( 4686 'gst_structure_id_get(FOO, VALUE, G_TYPE_INT, &value, NULL);', 4687 '') 4688 self.assert_lint( 4689 'gst_caps_new_simple(mime, "value", G_TYPE_INT, &value, NULL);', 4690 '') 4691 self.assert_lint( 4692 'gst_caps_new_full(structure1, structure2, NULL);', 4693 '') 4694 self.assert_lint( 4695 'gchar* result = g_strconcat("part1", "part2", "part3", NULL);', 4696 '') 4697 self.assert_lint( 4698 'gchar* result = g_strconcat("part1", NULL);', 4699 '') 4700 self.assert_lint( 4701 'gchar* result = g_strjoin(",", "part1", "part2", "part3", NULL);', 4702 '') 4703 self.assert_lint( 4704 'gchar* result = g_strjoin(",", "part1", NULL);', 4705 '') 4706 self.assert_lint( 4707 'gchar* result = gdk_pixbuf_save_to_callback(pixbuf, function, data, type, error, NULL);', 4708 '') 4709 self.assert_lint( 4710 'gchar* result = gdk_pixbuf_save_to_buffer(pixbuf, function, data, type, error, NULL);', 4711 '') 4712 self.assert_lint( 4713 'gchar* result = gdk_pixbuf_save_to_stream(pixbuf, function, data, type, error, NULL);', 4714 '') 4715 self.assert_lint( 4716 'gtk_widget_style_get(style, "propertyName", &value, "otherName", &otherValue, NULL);', 4717 '') 4718 self.assert_lint( 4719 'gtk_style_context_get_style(context, "propertyName", &value, "otherName", &otherValue, NULL);', 4720 '') 4721 self.assert_lint( 4722 'gtk_style_context_get(context, static_cast<GtkStateFlags>(0), "property", &value, NULL);', 4723 '') 4724 self.assert_lint( 4725 'gtk_widget_style_get_property(style, NULL, NULL);', 4726 'Use 0 instead of NULL. [readability/null] [5]', 4727 'foo.cpp') 4728 self.assert_lint( 4729 'gtk_widget_style_get_valist(style, NULL, NULL);', 4730 'Use 0 instead of NULL. [readability/null] [5]', 4731 'foo.cpp') 4732 4733 # 2. C++ and C bool values should be written as true and 4734 # false. Objective-C BOOL values should be written as YES and NO. 4735 # FIXME: Implement this. 4736 4737 # 3. Tests for true/false and null/non-null should be done without 4738 # equality comparisons. 4739 self.assert_lint_one_of_many_errors_re( 4740 'if (string != NULL)', 4741 r'Tests for true/false and null/non-null should be done without equality comparisons\.') 4742 self.assert_lint( 4743 'if (p == nullptr)', 4744 'Tests for true/false and null/non-null should be done without equality comparisons.' 4745 ' [readability/comparison_to_boolean] [5]') 4746 self.assert_lint( 4747 'if (condition == true)', 4748 'Tests for true/false and null/non-null should be done without equality comparisons.' 4749 ' [readability/comparison_to_boolean] [5]') 4750 self.assert_lint( 4751 'if (myVariable != /* Why would anyone put a comment here? */ false)', 4752 'Tests for true/false and null/non-null should be done without equality comparisons.' 4753 ' [readability/comparison_to_boolean] [5]') 4754 4755 self.assert_lint_one_of_many_errors_re( 4756 'if (NULL == thisMayBeNull)', 4757 r'Tests for true/false and null/non-null should be done without equality comparisons\.') 4758 self.assert_lint( 4759 'if (nullptr /* funny place for a comment */ == p)', 4760 'Tests for true/false and null/non-null should be done without equality comparisons.' 4761 ' [readability/comparison_to_boolean] [5]') 4762 self.assert_lint( 4763 'if (true != anotherCondition)', 4764 'Tests for true/false and null/non-null should be done without equality comparisons.' 4765 ' [readability/comparison_to_boolean] [5]') 4766 self.assert_lint( 4767 'if (false == myBoolValue)', 4768 'Tests for true/false and null/non-null should be done without equality comparisons.' 4769 ' [readability/comparison_to_boolean] [5]') 4770 4771 self.assert_lint( 4772 'if (fontType == trueType)', 4773 '') 4774 self.assert_lint( 4775 'if (othertrue == fontType)', 4776 '') 4777 self.assert_lint( 4778 'if (LIKELY(foo == 0))', 4779 '') 4780 self.assert_lint( 4781 'if (UNLIKELY(foo == 0))', 4782 '') 4783 self.assert_lint( 4784 'if ((a - b) == 0.5)', 4785 '') 4786 self.assert_lint( 4787 'if (0.5 == (a - b))', 4788 '') 4789 self.assert_lint( 4790 'if (LIKELY(foo == NULL))', 4791 'Use 0 instead of NULL. [readability/null] [5]') 4792 self.assert_lint( 4793 'if (UNLIKELY(foo == NULL))', 4794 'Use 0 instead of NULL. [readability/null] [5]') 4795 4796 def test_directive_indentation(self): 4797 self.assert_lint( 4798 " #if FOO", 4799 "preprocessor directives (e.g., #ifdef, #define, #import) should never be indented." 4800 " [whitespace/indent] [4]", 4801 "foo.cpp") 4802 4803 def test_using_std(self): 4804 self.assert_lint( 4805 'using std::min;', 4806 "Use 'using namespace std;' instead of 'using std::min;'." 4807 " [build/using_std] [4]", 4808 'foo.cpp') 4809 4810 def test_using_std_swap_ignored(self): 4811 self.assert_lint( 4812 'using std::swap;', 4813 '', 4814 'foo.cpp') 4815 4816 def test_max_macro(self): 4817 self.assert_lint( 4818 'int i = MAX(0, 1);', 4819 '', 4820 'foo.c') 4821 4822 self.assert_lint( 4823 'int i = MAX(0, 1);', 4824 'Use std::max() or std::max<type>() instead of the MAX() macro.' 4825 ' [runtime/max_min_macros] [4]', 4826 'foo.cpp') 4827 4828 self.assert_lint( 4829 'inline int foo() { return MAX(0, 1); }', 4830 'Use std::max() or std::max<type>() instead of the MAX() macro.' 4831 ' [runtime/max_min_macros] [4]', 4832 'foo.h') 4833 4834 def test_min_macro(self): 4835 self.assert_lint( 4836 'int i = MIN(0, 1);', 4837 '', 4838 'foo.c') 4839 4840 self.assert_lint( 4841 'int i = MIN(0, 1);', 4842 'Use std::min() or std::min<type>() instead of the MIN() macro.' 4843 ' [runtime/max_min_macros] [4]', 4844 'foo.cpp') 4845 4846 self.assert_lint( 4847 'inline int foo() { return MIN(0, 1); }', 4848 'Use std::min() or std::min<type>() instead of the MIN() macro.' 4849 ' [runtime/max_min_macros] [4]', 4850 'foo.h') 4851 4852 def test_ctype_fucntion(self): 4853 self.assert_lint( 4854 'int i = isascii(8);', 4855 'Use equivelent function in <wtf/ASCIICType.h> instead of the ' 4856 'isascii() function. [runtime/ctype_function] [4]', 4857 'foo.cpp') 4858 4859 def test_names(self): 4860 name_underscore_error_message = " is incorrectly named. Don't use underscores in your identifier names. [readability/naming/underscores] [4]" 4861 name_tooshort_error_message = " is incorrectly named. Don't use the single letter 'l' as an identifier name. [readability/naming] [4]" 4862 4863 # Basic cases from WebKit style guide. 4864 self.assert_lint('struct Data;', '') 4865 self.assert_lint('size_t bufferSize;', '') 4866 self.assert_lint('class HTMLDocument;', '') 4867 self.assert_lint('String mimeType();', '') 4868 self.assert_lint('size_t buffer_size;', 4869 'buffer_size' + name_underscore_error_message) 4870 self.assert_lint('short m_length;', '') 4871 self.assert_lint('short _length;', 4872 '_length' + name_underscore_error_message) 4873 self.assert_lint('short length_;', 4874 'length_' + name_underscore_error_message) 4875 self.assert_lint('unsigned _length;', 4876 '_length' + name_underscore_error_message) 4877 self.assert_lint('unsigned long _length;', 4878 '_length' + name_underscore_error_message) 4879 self.assert_lint('unsigned long long _length;', 4880 '_length' + name_underscore_error_message) 4881 4882 # Allow underscores in Objective C files. 4883 self.assert_lint('unsigned long long _length;', 4884 '', 4885 'foo.m') 4886 self.assert_lint('unsigned long long _length;', 4887 '', 4888 'foo.mm') 4889 self.assert_lint('#import "header_file.h"\n' 4890 'unsigned long long _length;', 4891 '', 4892 'foo.h') 4893 self.assert_lint('unsigned long long _length;\n' 4894 '@interface WebFullscreenWindow;', 4895 '', 4896 'foo.h') 4897 self.assert_lint('unsigned long long _length;\n' 4898 '@implementation WebFullscreenWindow;', 4899 '', 4900 'foo.h') 4901 self.assert_lint('unsigned long long _length;\n' 4902 '@class WebWindowFadeAnimation;', 4903 '', 4904 'foo.h') 4905 4906 # Variable name 'l' is easy to confuse with '1' 4907 self.assert_lint('int l;', 'l' + name_tooshort_error_message) 4908 self.assert_lint('size_t l;', 'l' + name_tooshort_error_message) 4909 self.assert_lint('long long l;', 'l' + name_tooshort_error_message) 4910 4911 # Pointers, references, functions, templates, and adjectives. 4912 self.assert_lint('char* under_score;', 4913 'under_score' + name_underscore_error_message) 4914 self.assert_lint('const int UNDER_SCORE;', 4915 'UNDER_SCORE' + name_underscore_error_message) 4916 self.assert_lint('static inline const char const& const under_score;', 4917 'under_score' + name_underscore_error_message) 4918 self.assert_lint('WebCore::RenderObject* under_score;', 4919 'under_score' + name_underscore_error_message) 4920 self.assert_lint('int func_name();', 4921 'func_name' + name_underscore_error_message) 4922 self.assert_lint('RefPtr<RenderObject*> under_score;', 4923 'under_score' + name_underscore_error_message) 4924 self.assert_lint('WTF::Vector<WTF::RefPtr<const RenderObject* const> > under_score;', 4925 'under_score' + name_underscore_error_message) 4926 self.assert_lint('int under_score[];', 4927 'under_score' + name_underscore_error_message) 4928 self.assert_lint('struct dirent* under_score;', 4929 'under_score' + name_underscore_error_message) 4930 self.assert_lint('long under_score;', 4931 'under_score' + name_underscore_error_message) 4932 self.assert_lint('long long under_score;', 4933 'under_score' + name_underscore_error_message) 4934 self.assert_lint('long double under_score;', 4935 'under_score' + name_underscore_error_message) 4936 self.assert_lint('long long int under_score;', 4937 'under_score' + name_underscore_error_message) 4938 4939 # Declarations in control statement. 4940 self.assert_lint('if (int under_score = 42) {', 4941 'under_score' + name_underscore_error_message) 4942 self.assert_lint('else if (int under_score = 42) {', 4943 'under_score' + name_underscore_error_message) 4944 self.assert_lint('for (int under_score = 42; cond; i++) {', 4945 'under_score' + name_underscore_error_message) 4946 self.assert_lint('while (foo & under_score = bar) {', 4947 'under_score' + name_underscore_error_message) 4948 self.assert_lint('for (foo * under_score = p; cond; i++) {', 4949 'under_score' + name_underscore_error_message) 4950 self.assert_lint('for (foo * under_score; cond; i++) {', 4951 'under_score' + name_underscore_error_message) 4952 self.assert_lint('while (foo & value_in_thirdparty_library) {', '') 4953 self.assert_lint('while (foo * value_in_thirdparty_library) {', '') 4954 self.assert_lint('if (mli && S_OK == mli->foo()) {', '') 4955 4956 # More member variables and functions. 4957 self.assert_lint('int SomeClass::s_validName', '') 4958 self.assert_lint('int m_under_score;', 4959 'm_under_score' + name_underscore_error_message) 4960 self.assert_lint('int SomeClass::s_under_score = 0;', 4961 'SomeClass::s_under_score' + name_underscore_error_message) 4962 self.assert_lint('int SomeClass::under_score = 0;', 4963 'SomeClass::under_score' + name_underscore_error_message) 4964 4965 # Other statements. 4966 self.assert_lint('return INT_MAX;', '') 4967 self.assert_lint('return_t under_score;', 4968 'under_score' + name_underscore_error_message) 4969 self.assert_lint('goto under_score;', 4970 'under_score' + name_underscore_error_message) 4971 self.assert_lint('delete static_cast<Foo*>(p);', '') 4972 4973 # Multiple variables in one line. 4974 self.assert_lint('void myFunction(int variable1, int another_variable);', 4975 'another_variable' + name_underscore_error_message) 4976 self.assert_lint('int variable1, another_variable;', 4977 'another_variable' + name_underscore_error_message) 4978 self.assert_lint('int first_variable, secondVariable;', 4979 'first_variable' + name_underscore_error_message) 4980 self.assert_lint('void my_function(int variable_1, int variable_2);', 4981 ['my_function' + name_underscore_error_message, 4982 'variable_1' + name_underscore_error_message, 4983 'variable_2' + name_underscore_error_message]) 4984 self.assert_lint('for (int variable_1, variable_2;;) {', 4985 ['variable_1' + name_underscore_error_message, 4986 'variable_2' + name_underscore_error_message]) 4987 4988 # There is an exception for op code functions but only in the JavaScriptCore directory. 4989 self.assert_lint('void this_op_code(int var1, int var2)', '', 'Source/JavaScriptCore/foo.cpp') 4990 self.assert_lint('void op_code(int var1, int var2)', '', 'Source/JavaScriptCore/foo.cpp') 4991 self.assert_lint('void this_op_code(int var1, int var2)', 'this_op_code' + name_underscore_error_message) 4992 4993 # GObject requires certain magical names in class declarations. 4994 self.assert_lint('void webkit_dom_object_init();', '') 4995 self.assert_lint('void webkit_dom_object_class_init();', '') 4996 4997 # There is an exception for GTK+ API. 4998 self.assert_lint('void webkit_web_view_load(int var1, int var2)', '', 'Source/Webkit/gtk/webkit/foo.cpp') 4999 self.assert_lint('void webkit_web_view_load(int var1, int var2)', '', 'Source/Webkit2/UIProcess/gtk/foo.cpp') 5000 5001 # Test that this doesn't also apply to files not in a 'gtk' directory. 5002 self.assert_lint('void webkit_web_view_load(int var1, int var2)', 5003 'webkit_web_view_load is incorrectly named. Don\'t use underscores in your identifier names.' 5004 ' [readability/naming/underscores] [4]', 'Source/Webkit/webkit/foo.cpp') 5005 # Test that this doesn't also apply to names that don't start with 'webkit_'. 5006 self.assert_lint_one_of_many_errors_re('void otherkit_web_view_load(int var1, int var2)', 5007 'otherkit_web_view_load is incorrectly named. Don\'t use underscores in your identifier names.' 5008 ' [readability/naming/underscores] [4]', 'Source/Webkit/webkit/foo.cpp') 5009 5010 # There is an exception for some unit tests that begin with "tst_". 5011 self.assert_lint('void tst_QWebFrame::arrayObjectEnumerable(int var1, int var2)', '') 5012 5013 # The Qt API uses names that begin with "qt_" or "_q_". 5014 self.assert_lint('void QTFrame::qt_drt_is_awesome(int var1, int var2)', '') 5015 self.assert_lint('void QTFrame::_q_drt_is_awesome(int var1, int var2)', '') 5016 self.assert_lint('void qt_drt_is_awesome(int var1, int var2);', '') 5017 self.assert_lint('void _q_drt_is_awesome(int var1, int var2);', '') 5018 5019 # Cairo forward-declarations should not be a failure. 5020 self.assert_lint('typedef struct _cairo cairo_t;', '') 5021 self.assert_lint('typedef struct _cairo_surface cairo_surface_t;', '') 5022 self.assert_lint('typedef struct _cairo_scaled_font cairo_scaled_font_t;', '') 5023 5024 # EFL forward-declarations should not be a failure. 5025 self.assert_lint('typedef struct _Ecore_Evas Ecore_Evas;', '') 5026 self.assert_lint('typedef struct _Ecore_Pipe Ecore_Pipe;', '') 5027 self.assert_lint('typedef struct _Eina_Rectangle Eina_Rectangle;', '') 5028 self.assert_lint('typedef struct _Evas_Object Evas_Object;', '') 5029 self.assert_lint('typedef struct _Ewk_History_Item Ewk_History_Item;', '') 5030 5031 # NPAPI functions that start with NPN_, NPP_ or NP_ are allowed. 5032 self.assert_lint('void NPN_Status(NPP, const char*)', '') 5033 self.assert_lint('NPError NPP_SetWindow(NPP instance, NPWindow *window)', '') 5034 self.assert_lint('NPObject* NP_Allocate(NPP, NPClass*)', '') 5035 5036 # const_iterator is allowed as well. 5037 self.assert_lint('typedef VectorType::const_iterator const_iterator;', '') 5038 5039 # vm_throw is allowed as well. 5040 self.assert_lint('int vm_throw;', '') 5041 5042 # Attributes. 5043 self.assert_lint('int foo ALLOW_UNUSED;', '') 5044 self.assert_lint('int foo_error ALLOW_UNUSED;', 'foo_error' + name_underscore_error_message) 5045 self.assert_lint('ThreadFunctionInvocation* leakedInvocation ALLOW_UNUSED = invocation.leakPtr()', '') 5046 5047 # Bitfields. 5048 self.assert_lint('unsigned _fillRule : 1;', 5049 '_fillRule' + name_underscore_error_message) 5050 5051 # new operators in initialization. 5052 self.assert_lint('OwnPtr<uint32_t> variable(new uint32_t);', '') 5053 self.assert_lint('OwnPtr<uint32_t> variable(new (expr) uint32_t);', '') 5054 self.assert_lint('OwnPtr<uint32_t> under_score(new uint32_t);', 5055 'under_score' + name_underscore_error_message) 5056 5057 # Conversion operator declaration. 5058 self.assert_lint('operator int64_t();', '') 5059 5060 def test_parameter_names(self): 5061 # Leave meaningless variable names out of function declarations. 5062 meaningless_variable_name_error_message = 'The parameter name "%s" adds no information, so it should be removed. [readability/parameter_name] [5]' 5063 5064 parameter_error_rules = ('-', 5065 '+readability/parameter_name') 5066 # No variable name, so no error. 5067 self.assertEqual('', 5068 self.perform_lint('void func(int);', 'test.cpp', parameter_error_rules)) 5069 5070 # Verify that copying the name of the set function causes the error (with some odd casing). 5071 self.assertEqual(meaningless_variable_name_error_message % 'itemCount', 5072 self.perform_lint('void setItemCount(size_t itemCount);', 'test.cpp', parameter_error_rules)) 5073 self.assertEqual(meaningless_variable_name_error_message % 'abcCount', 5074 self.perform_lint('void setABCCount(size_t abcCount);', 'test.cpp', parameter_error_rules)) 5075 5076 # Verify that copying a type name will trigger the warning (even if the type is a template parameter). 5077 self.assertEqual(meaningless_variable_name_error_message % 'context', 5078 self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context);', 'test.cpp', parameter_error_rules)) 5079 5080 # Verify that acronyms as variable names trigger the error (for both set functions and type names). 5081 self.assertEqual(meaningless_variable_name_error_message % 'ec', 5082 self.perform_lint('void setExceptionCode(int ec);', 'test.cpp', parameter_error_rules)) 5083 self.assertEqual(meaningless_variable_name_error_message % 'ec', 5084 self.perform_lint('void funct(ExceptionCode ec);', 'test.cpp', parameter_error_rules)) 5085 5086 # 'object' alone, appended, or as part of an acronym is meaningless. 5087 self.assertEqual(meaningless_variable_name_error_message % 'object', 5088 self.perform_lint('void funct(RenderView object);', 'test.cpp', parameter_error_rules)) 5089 self.assertEqual(meaningless_variable_name_error_message % 'viewObject', 5090 self.perform_lint('void funct(RenderView viewObject);', 'test.cpp', parameter_error_rules)) 5091 self.assertEqual(meaningless_variable_name_error_message % 'rvo', 5092 self.perform_lint('void funct(RenderView rvo);', 'test.cpp', parameter_error_rules)) 5093 5094 # Check that r, g, b, and a are allowed. 5095 self.assertEqual('', 5096 self.perform_lint('void setRGBAValues(int r, int g, int b, int a);', 'test.cpp', parameter_error_rules)) 5097 5098 # Verify that a simple substring match isn't done which would cause false positives. 5099 self.assertEqual('', 5100 self.perform_lint('void setNateLateCount(size_t elate);', 'test.cpp', parameter_error_rules)) 5101 self.assertEqual('', 5102 self.perform_lint('void funct(NateLate elate);', 'test.cpp', parameter_error_rules)) 5103 5104 # Don't have generate warnings for functions (only declarations). 5105 self.assertEqual('', 5106 self.perform_lint('void funct(PassRefPtr<ScriptExecutionContext> context)\n' 5107 '{\n' 5108 '}\n', 'test.cpp', parameter_error_rules)) 5109 5110 def test_comments(self): 5111 # A comment at the beginning of a line is ok. 5112 self.assert_lint('// comment', '') 5113 self.assert_lint(' // comment', '') 5114 5115 self.assert_lint('} // namespace WebCore', 5116 'One space before end of line comments' 5117 ' [whitespace/comments] [5]') 5118 5119 def test_webkit_export_check(self): 5120 webkit_export_error_rules = ('-', 5121 '+readability/webkit_export') 5122 self.assertEqual('', 5123 self.perform_lint('WEBKIT_EXPORT int foo();\n', 5124 'WebKit/chromium/public/test.h', 5125 webkit_export_error_rules)) 5126 self.assertEqual('', 5127 self.perform_lint('WEBKIT_EXPORT int foo();\n', 5128 'WebKit/chromium/tests/test.h', 5129 webkit_export_error_rules)) 5130 self.assertEqual('WEBKIT_EXPORT should only be used in header files. [readability/webkit_export] [5]', 5131 self.perform_lint('WEBKIT_EXPORT int foo();\n', 5132 'WebKit/chromium/public/test.cpp', 5133 webkit_export_error_rules)) 5134 self.assertEqual('WEBKIT_EXPORT should only appear in the chromium public (or tests) directory. [readability/webkit_export] [5]', 5135 self.perform_lint('WEBKIT_EXPORT int foo();\n', 5136 'WebKit/chromium/src/test.h', 5137 webkit_export_error_rules)) 5138 self.assertEqual('WEBKIT_EXPORT should not be used on a function with a body. [readability/webkit_export] [5]', 5139 self.perform_lint('WEBKIT_EXPORT int foo() { }\n', 5140 'WebKit/chromium/public/test.h', 5141 webkit_export_error_rules)) 5142 self.assertEqual('WEBKIT_EXPORT should not be used on a function with a body. [readability/webkit_export] [5]', 5143 self.perform_lint('WEBKIT_EXPORT inline int foo()\n' 5144 '{\n' 5145 '}\n', 5146 'WebKit/chromium/public/test.h', 5147 webkit_export_error_rules)) 5148 self.assertEqual('WEBKIT_EXPORT should not be used with a pure virtual function. [readability/webkit_export] [5]', 5149 self.perform_lint('{}\n' 5150 'WEBKIT_EXPORT\n' 5151 'virtual\n' 5152 'int\n' 5153 'foo() = 0;\n', 5154 'WebKit/chromium/public/test.h', 5155 webkit_export_error_rules)) 5156 self.assertEqual('', 5157 self.perform_lint('{}\n' 5158 'WEBKIT_EXPORT\n' 5159 'virtual\n' 5160 'int\n' 5161 'foo() = 0;\n', 5162 'test.h', 5163 webkit_export_error_rules)) 5164 5165 def test_other(self): 5166 # FIXME: Implement this. 5167 pass 5168 5169 5170class CppCheckerTest(unittest.TestCase): 5171 5172 """Tests CppChecker class.""" 5173 5174 def mock_handle_style_error(self): 5175 pass 5176 5177 def _checker(self): 5178 return CppChecker("foo", "h", self.mock_handle_style_error, 3) 5179 5180 def test_init(self): 5181 """Test __init__ constructor.""" 5182 checker = self._checker() 5183 self.assertEqual(checker.file_extension, "h") 5184 self.assertEqual(checker.file_path, "foo") 5185 self.assertEqual(checker.handle_style_error, self.mock_handle_style_error) 5186 self.assertEqual(checker.min_confidence, 3) 5187 5188 def test_eq(self): 5189 """Test __eq__ equality function.""" 5190 checker1 = self._checker() 5191 checker2 = self._checker() 5192 5193 # == calls __eq__. 5194 self.assertTrue(checker1 == checker2) 5195 5196 def mock_handle_style_error2(self): 5197 pass 5198 5199 # Verify that a difference in any argument cause equality to fail. 5200 checker = CppChecker("foo", "h", self.mock_handle_style_error, 3) 5201 self.assertFalse(checker == CppChecker("bar", "h", self.mock_handle_style_error, 3)) 5202 self.assertFalse(checker == CppChecker("foo", "c", self.mock_handle_style_error, 3)) 5203 self.assertFalse(checker == CppChecker("foo", "h", mock_handle_style_error2, 3)) 5204 self.assertFalse(checker == CppChecker("foo", "h", self.mock_handle_style_error, 4)) 5205 5206 def test_ne(self): 5207 """Test __ne__ inequality function.""" 5208 checker1 = self._checker() 5209 checker2 = self._checker() 5210 5211 # != calls __ne__. 5212 # By default, __ne__ always returns true on different objects. 5213 # Thus, just check the distinguishing case to verify that the 5214 # code defines __ne__. 5215 self.assertFalse(checker1 != checker2) 5216