check-webkit-style failed to complain about missing braces
[WebKit-https.git] / Tools / Scripts / webkitpy / style / checkers / cpp_unittest.py
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, 2013 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
38 import codecs
39 import os
40 import random
41 import re
42 import unittest2 as unittest
43 import cpp as cpp_style
44 from cpp import CppChecker
45 from ..filter import FilterConfiguration
46
47 # This class works as an error collector and replaces cpp_style.Error
48 # function for the unit tests.  We also verify each category we see
49 # is in STYLE_CATEGORIES, to help keep that list up to date.
50 class ErrorCollector:
51     _all_style_categories = CppChecker.categories
52     # This is a list including all categories seen in any unit test.
53     _seen_style_categories = {}
54
55     def __init__(self, assert_fn, filter=None, lines_to_check=None):
56         """assert_fn: a function to call when we notice a problem.
57            filter: filters the errors that we are concerned about."""
58         self._assert_fn = assert_fn
59         self._errors = []
60         self._lines_to_check = lines_to_check
61         if not filter:
62             filter = FilterConfiguration()
63         self._filter = filter
64
65     def __call__(self, line_number, category, confidence, message):
66         self._assert_fn(category in self._all_style_categories,
67                         'Message "%s" has category "%s",'
68                         ' which is not in STYLE_CATEGORIES' % (message, category))
69
70         if self._lines_to_check and not line_number in self._lines_to_check:
71             return False
72
73         if self._filter.should_check(category, ""):
74             self._seen_style_categories[category] = 1
75             self._errors.append('%s  [%s] [%d]' % (message, category, confidence))
76         return True
77
78     def results(self):
79         if len(self._errors) < 2:
80             return ''.join(self._errors)  # Most tests expect to have a string.
81         else:
82             return self._errors  # Let's give a list if there is more than one.
83
84     def result_list(self):
85         return self._errors
86
87     def verify_all_categories_are_seen(self):
88         """Fails if there's a category in _all_style_categories - _seen_style_categories.
89
90         This should only be called after all tests are run, so
91         _seen_style_categories has had a chance to fully populate.  Since
92         this isn't called from within the normal unittest framework, we
93         can't use the normal unittest assert macros.  Instead we just exit
94         when we see an error.  Good thing this test is always run last!
95         """
96         for category in self._all_style_categories:
97             if category not in self._seen_style_categories:
98                 import sys
99                 sys.exit('FATAL ERROR: There are no tests for category "%s"' % category)
100
101
102 # This class is a lame mock of codecs. We do not verify filename, mode, or
103 # encoding, but for the current use case it is not needed.
104 class MockIo:
105     def __init__(self, mock_file):
106         self.mock_file = mock_file
107
108     def open(self, unused_filename, unused_mode, unused_encoding, _):  # NOLINT
109         # (lint doesn't like open as a method name)
110         return self.mock_file
111
112
113 class CppFunctionsTest(unittest.TestCase):
114
115     """Supports testing functions that do not need CppStyleTestBase."""
116
117     def test_convert_to_lower_with_underscores(self):
118         self.assertEqual(cpp_style._convert_to_lower_with_underscores('ABC'), 'abc')
119         self.assertEqual(cpp_style._convert_to_lower_with_underscores('aB'), 'a_b')
120         self.assertEqual(cpp_style._convert_to_lower_with_underscores('isAName'), 'is_a_name')
121         self.assertEqual(cpp_style._convert_to_lower_with_underscores('AnotherTest'), 'another_test')
122         self.assertEqual(cpp_style._convert_to_lower_with_underscores('PassRefPtr<MyClass>'), 'pass_ref_ptr<my_class>')
123         self.assertEqual(cpp_style._convert_to_lower_with_underscores('_ABC'), '_abc')
124
125     def test_create_acronym(self):
126         self.assertEqual(cpp_style._create_acronym('ABC'), 'ABC')
127         self.assertEqual(cpp_style._create_acronym('IsAName'), 'IAN')
128         self.assertEqual(cpp_style._create_acronym('PassRefPtr<MyClass>'), 'PRP<MC>')
129
130     def test_is_c_or_objective_c(self):
131         clean_lines = cpp_style.CleansedLines([''])
132         clean_objc_lines = cpp_style.CleansedLines(['#import "header.h"'])
133         self.assertTrue(cpp_style._FileState(clean_lines, 'c').is_c_or_objective_c())
134         self.assertTrue(cpp_style._FileState(clean_lines, 'm').is_c_or_objective_c())
135         self.assertFalse(cpp_style._FileState(clean_lines, 'cpp').is_c_or_objective_c())
136         self.assertFalse(cpp_style._FileState(clean_lines, 'cc').is_c_or_objective_c())
137         self.assertFalse(cpp_style._FileState(clean_lines, 'h').is_c_or_objective_c())
138         self.assertTrue(cpp_style._FileState(clean_objc_lines, 'h').is_c_or_objective_c())
139
140     def test_parameter(self):
141         # Test type.
142         parameter = cpp_style.Parameter('ExceptionCode', 13, 1)
143         self.assertEqual(parameter.type, 'ExceptionCode')
144         self.assertEqual(parameter.name, '')
145         self.assertEqual(parameter.row, 1)
146
147         # Test type and name.
148         parameter = cpp_style.Parameter('PassRefPtr<MyClass> parent', 19, 1)
149         self.assertEqual(parameter.type, 'PassRefPtr<MyClass>')
150         self.assertEqual(parameter.name, 'parent')
151         self.assertEqual(parameter.row, 1)
152
153         # Test type, no name, with default value.
154         parameter = cpp_style.Parameter('MyClass = 0', 7, 0)
155         self.assertEqual(parameter.type, 'MyClass')
156         self.assertEqual(parameter.name, '')
157         self.assertEqual(parameter.row, 0)
158
159         # Test type, name, and default value.
160         parameter = cpp_style.Parameter('MyClass a = 0', 7, 0)
161         self.assertEqual(parameter.type, 'MyClass')
162         self.assertEqual(parameter.name, 'a')
163         self.assertEqual(parameter.row, 0)
164
165     def test_single_line_view(self):
166         start_position = cpp_style.Position(row=1, column=1)
167         end_position = cpp_style.Position(row=3, column=1)
168         single_line_view = cpp_style.SingleLineView(['0', 'abcde', 'fgh', 'i'], start_position, end_position)
169         self.assertEqual(single_line_view.single_line, 'bcde fgh i')
170         self.assertEqual(single_line_view.convert_column_to_row(0), 1)
171         self.assertEqual(single_line_view.convert_column_to_row(4), 1)
172         self.assertEqual(single_line_view.convert_column_to_row(5), 2)
173         self.assertEqual(single_line_view.convert_column_to_row(8), 2)
174         self.assertEqual(single_line_view.convert_column_to_row(9), 3)
175         self.assertEqual(single_line_view.convert_column_to_row(100), 3)
176
177         start_position = cpp_style.Position(row=0, column=3)
178         end_position = cpp_style.Position(row=0, column=4)
179         single_line_view = cpp_style.SingleLineView(['abcdef'], start_position, end_position)
180         self.assertEqual(single_line_view.single_line, 'd')
181
182     def test_create_skeleton_parameters(self):
183         self.assertEqual(cpp_style.create_skeleton_parameters(''), '')
184         self.assertEqual(cpp_style.create_skeleton_parameters(' '), ' ')
185         self.assertEqual(cpp_style.create_skeleton_parameters('long'), 'long,')
186         self.assertEqual(cpp_style.create_skeleton_parameters('const unsigned long int'), '                    int,')
187         self.assertEqual(cpp_style.create_skeleton_parameters('long int*'), '     int ,')
188         self.assertEqual(cpp_style.create_skeleton_parameters('PassRefPtr<Foo> a'), 'PassRefPtr      a,')
189         self.assertEqual(cpp_style.create_skeleton_parameters(
190                 'ComplexTemplate<NestedTemplate1<MyClass1, MyClass2>, NestedTemplate1<MyClass1, MyClass2> > param, int second'),
191                           'ComplexTemplate                                                                            param, int second,')
192         self.assertEqual(cpp_style.create_skeleton_parameters('int = 0, Namespace::Type& a'), 'int    ,            Type  a,')
193         # Create skeleton parameters is a bit too aggressive with function variables, but
194         # it allows for parsing other parameters and declarations like this are rare.
195         self.assertEqual(cpp_style.create_skeleton_parameters('void (*fn)(int a, int b), Namespace::Type& a'),
196                           'void                    ,            Type  a,')
197
198         # This doesn't look like functions declarations but the simplifications help to eliminate false positives.
199         self.assertEqual(cpp_style.create_skeleton_parameters('b{d}'), 'b   ,')
200
201     def test_find_parameter_name_index(self):
202         self.assertEqual(cpp_style.find_parameter_name_index(' int a '), 5)
203         self.assertEqual(cpp_style.find_parameter_name_index(' PassRefPtr     '), 16)
204         self.assertEqual(cpp_style.find_parameter_name_index('double'), 6)
205
206     def test_parameter_list(self):
207         elided_lines = ['int blah(PassRefPtr<MyClass> paramName,',
208                         'const Other1Class& foo,',
209                         'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),',
210                         'int* myCount = 0);']
211         start_position = cpp_style.Position(row=0, column=8)
212         end_position = cpp_style.Position(row=3, column=16)
213
214         expected_parameters = ({'type': 'PassRefPtr<MyClass>', 'name': 'paramName', 'row': 0},
215                                {'type': 'const Other1Class&', 'name': 'foo', 'row': 1},
216                                {'type': 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const *', 'name': 'param', 'row': 2},
217                                {'type': 'int*', 'name': 'myCount', 'row': 3})
218         index = 0
219         for parameter in cpp_style.parameter_list(elided_lines, start_position, end_position):
220             expected_parameter = expected_parameters[index]
221             self.assertEqual(parameter.type, expected_parameter['type'])
222             self.assertEqual(parameter.name, expected_parameter['name'])
223             self.assertEqual(parameter.row, expected_parameter['row'])
224             index += 1
225         self.assertEqual(index, len(expected_parameters))
226
227     def test_check_parameter_against_text(self):
228         error_collector = ErrorCollector(self.assertTrue)
229         parameter = cpp_style.Parameter('FooF ooF', 4, 1)
230         self.assertFalse(cpp_style._check_parameter_name_against_text(parameter, 'FooF', error_collector))
231         self.assertEqual(error_collector.results(),
232                           'The parameter name "ooF" adds no information, so it should be removed.  [readability/parameter_name] [5]')
233
234 class CppStyleTestBase(unittest.TestCase):
235     """Provides some useful helper functions for cpp_style tests.
236
237     Attributes:
238       min_confidence: An integer that is the current minimum confidence
239                       level for the tests.
240
241     """
242
243     # FIXME: Refactor the unit tests so the confidence level is passed
244     #        explicitly, just like it is in the real code.
245     min_confidence = 1;
246
247     # Helper function to avoid needing to explicitly pass confidence
248     # in all the unit test calls to cpp_style.process_file_data().
249     def process_file_data(self, filename, file_extension, lines, error, unit_test_config={}):
250         checker = CppChecker(filename, file_extension, error, self.min_confidence, unit_test_config)
251         checker.check(lines)
252
253     def perform_lint(self, code, filename, basic_error_rules, unit_test_config={}, lines_to_check=None):
254         error_collector = ErrorCollector(self.assertTrue, FilterConfiguration(basic_error_rules), lines_to_check)
255         lines = code.split('\n')
256         extension = filename.split('.')[1]
257         self.process_file_data(filename, extension, lines, error_collector, unit_test_config)
258         return error_collector.results()
259
260     # Perform lint on single line of input and return the error message.
261     def perform_single_line_lint(self, code, filename):
262         basic_error_rules = ('-build/header_guard',
263                              '-legal/copyright',
264                              '-readability/fn_size',
265                              '-readability/parameter_name',
266                              '-readability/pass_ptr',
267                              '-whitespace/ending_newline')
268         return self.perform_lint(code, filename, basic_error_rules)
269
270     # Perform lint over multiple lines and return the error message.
271     def perform_multi_line_lint(self, code, file_extension):
272         basic_error_rules = ('-build/header_guard',
273                              '-legal/copyright',
274                              '-readability/parameter_name',
275                              '-whitespace/ending_newline')
276         return self.perform_lint(code, 'test.' + file_extension, basic_error_rules)
277
278     # Only keep some errors related to includes, namespaces and rtti.
279     def perform_language_rules_check(self, filename, code, lines_to_check=None):
280         basic_error_rules = ('-',
281                              '+build/include',
282                              '+build/include_order',
283                              '+build/namespaces',
284                              '+runtime/rtti')
285         return self.perform_lint(code, filename, basic_error_rules, lines_to_check=lines_to_check)
286
287     # Only keep function length errors.
288     def perform_function_lengths_check(self, code):
289         basic_error_rules = ('-',
290                              '+readability/fn_size')
291         return self.perform_lint(code, 'test.cpp', basic_error_rules)
292
293     # Only keep pass ptr errors.
294     def perform_pass_ptr_check(self, code):
295         basic_error_rules = ('-',
296                              '+readability/pass_ptr')
297         return self.perform_lint(code, 'test.cpp', basic_error_rules)
298
299     # Only keep leaky pattern errors.
300     def perform_leaky_pattern_check(self, code):
301         basic_error_rules = ('-',
302                              '+runtime/leaky_pattern')
303         return self.perform_lint(code, 'test.cpp', basic_error_rules)
304
305     # Only include what you use errors.
306     def perform_include_what_you_use(self, code, filename='foo.h', io=codecs):
307         basic_error_rules = ('-',
308                              '+build/include_what_you_use')
309         unit_test_config = {cpp_style.INCLUDE_IO_INJECTION_KEY: io}
310         return self.perform_lint(code, filename, basic_error_rules, unit_test_config)
311
312     # Perform lint and compare the error message with "expected_message".
313     def assert_lint(self, code, expected_message, file_name='foo.cpp'):
314         self.assertEqual(expected_message, self.perform_single_line_lint(code, file_name))
315
316     def assert_lint_one_of_many_errors_re(self, code, expected_message_re, file_name='foo.cpp'):
317         messages = self.perform_single_line_lint(code, file_name)
318         for message in messages:
319             if re.search(expected_message_re, message):
320                 return
321
322         self.assertEqual(expected_message_re, messages)
323
324     def assert_multi_line_lint(self, code, expected_message, file_name='foo.h'):
325         file_extension = file_name[file_name.rfind('.') + 1:]
326         self.assertEqual(expected_message, self.perform_multi_line_lint(code, file_extension))
327
328     def assert_multi_line_lint_re(self, code, expected_message_re, file_name='foo.h'):
329         file_extension = file_name[file_name.rfind('.') + 1:]
330         message = self.perform_multi_line_lint(code, file_extension)
331         if not re.search(expected_message_re, message):
332             self.fail('Message was:\n' + message + 'Expected match to "' + expected_message_re + '"')
333
334     def assert_language_rules_check(self, file_name, code, expected_message, lines_to_check=None):
335         self.assertEqual(expected_message,
336                           self.perform_language_rules_check(file_name, code, lines_to_check))
337
338     def assert_include_what_you_use(self, code, expected_message):
339         self.assertEqual(expected_message,
340                           self.perform_include_what_you_use(code))
341
342     def assert_blank_lines_check(self, lines, start_errors, end_errors):
343         error_collector = ErrorCollector(self.assertTrue)
344         self.process_file_data('foo.cpp', 'cpp', lines, error_collector)
345         self.assertEqual(
346             start_errors,
347             error_collector.results().count(
348                 'Blank line at the start of a code block.  Is this needed?'
349                 '  [whitespace/blank_line] [2]'))
350         self.assertEqual(
351             end_errors,
352             error_collector.results().count(
353                 'Blank line at the end of a code block.  Is this needed?'
354                 '  [whitespace/blank_line] [3]'))
355
356     def assert_positions_equal(self, position, tuple_position):
357         """Checks if the two positions are equal.
358
359         position: a cpp_style.Position object.
360         tuple_position: a tuple (row, column) to compare against."""
361         self.assertEqual(position, cpp_style.Position(tuple_position[0], tuple_position[1]),
362                           'position %s, tuple_position %s' % (position, tuple_position))
363
364
365 class FunctionDetectionTest(CppStyleTestBase):
366     def perform_function_detection(self, lines, function_information, detection_line=0):
367         clean_lines = cpp_style.CleansedLines(lines)
368         function_state = cpp_style._FunctionState(5)
369         error_collector = ErrorCollector(self.assertTrue)
370         cpp_style.detect_functions(clean_lines, detection_line, function_state, error_collector)
371         if not function_information:
372             self.assertEqual(function_state.in_a_function, False)
373             return
374         self.assertEqual(function_state.in_a_function, True)
375         self.assertEqual(function_state.current_function, function_information['name'] + '()')
376         self.assertEqual(function_state.modifiers_and_return_type(), function_information['modifiers_and_return_type'])
377         self.assertEqual(function_state.is_pure, function_information['is_pure'])
378         self.assertEqual(function_state.is_declaration, function_information['is_declaration'])
379         self.assert_positions_equal(function_state.function_name_start_position, function_information['function_name_start_position'])
380         self.assert_positions_equal(function_state.parameter_start_position, function_information['parameter_start_position'])
381         self.assert_positions_equal(function_state.parameter_end_position, function_information['parameter_end_position'])
382         self.assert_positions_equal(function_state.body_start_position, function_information['body_start_position'])
383         self.assert_positions_equal(function_state.end_position, function_information['end_position'])
384         expected_parameters = function_information.get('parameter_list')
385         if expected_parameters:
386             actual_parameters = function_state.parameter_list()
387             self.assertEqual(len(actual_parameters), len(expected_parameters))
388             for index in range(len(expected_parameters)):
389                 actual_parameter = actual_parameters[index]
390                 expected_parameter = expected_parameters[index]
391                 self.assertEqual(actual_parameter.type, expected_parameter['type'])
392                 self.assertEqual(actual_parameter.name, expected_parameter['name'])
393                 self.assertEqual(actual_parameter.row, expected_parameter['row'])
394
395     def test_basic_function_detection(self):
396         self.perform_function_detection(
397             ['void theTestFunctionName(int) {',
398              '}'],
399             {'name': 'theTestFunctionName',
400              'modifiers_and_return_type': 'void',
401              'function_name_start_position': (0, 5),
402              'parameter_start_position': (0, 24),
403              'parameter_end_position': (0, 29),
404              'body_start_position': (0, 30),
405              'end_position': (1, 1),
406              'is_pure': False,
407              'is_declaration': False})
408
409     def test_function_declaration_detection(self):
410         self.perform_function_detection(
411             ['void aFunctionName(int);'],
412             {'name': 'aFunctionName',
413              'modifiers_and_return_type': 'void',
414              'function_name_start_position': (0, 5),
415              'parameter_start_position': (0, 18),
416              'parameter_end_position': (0, 23),
417              'body_start_position': (0, 23),
418              'end_position': (0, 24),
419              'is_pure': False,
420              'is_declaration': True})
421
422         self.perform_function_detection(
423             ['CheckedInt<T> operator /(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'],
424             {'name': 'operator /',
425              'modifiers_and_return_type': 'CheckedInt<T>',
426              'function_name_start_position': (0, 14),
427              'parameter_start_position': (0, 24),
428              'parameter_end_position': (0, 76),
429              'body_start_position': (0, 76),
430              'end_position': (0, 77),
431              'is_pure': False,
432              'is_declaration': True})
433
434         self.perform_function_detection(
435             ['CheckedInt<T> operator -(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'],
436             {'name': 'operator -',
437              'modifiers_and_return_type': 'CheckedInt<T>',
438              'function_name_start_position': (0, 14),
439              'parameter_start_position': (0, 24),
440              'parameter_end_position': (0, 76),
441              'body_start_position': (0, 76),
442              'end_position': (0, 77),
443              'is_pure': False,
444              'is_declaration': True})
445
446         self.perform_function_detection(
447             ['CheckedInt<T> operator !=(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'],
448             {'name': 'operator !=',
449              'modifiers_and_return_type': 'CheckedInt<T>',
450              'function_name_start_position': (0, 14),
451              'parameter_start_position': (0, 25),
452              'parameter_end_position': (0, 77),
453              'body_start_position': (0, 77),
454              'end_position': (0, 78),
455              'is_pure': False,
456              'is_declaration': True})
457
458         self.perform_function_detection(
459             ['CheckedInt<T> operator +(const CheckedInt<T> &lhs, const CheckedInt<T> &rhs);'],
460             {'name': 'operator +',
461              'modifiers_and_return_type': 'CheckedInt<T>',
462              'function_name_start_position': (0, 14),
463              'parameter_start_position': (0, 24),
464              'parameter_end_position': (0, 76),
465              'body_start_position': (0, 76),
466              'end_position': (0, 77),
467              'is_pure': False,
468              'is_declaration': True})
469
470     def test_pure_function_detection(self):
471         self.perform_function_detection(
472             ['virtual void theTestFunctionName(int = 0);'],
473             {'name': 'theTestFunctionName',
474              'modifiers_and_return_type': 'virtual void',
475              'function_name_start_position': (0, 13),
476              'parameter_start_position': (0, 32),
477              'parameter_end_position': (0, 41),
478              'body_start_position': (0, 41),
479              'end_position': (0, 42),
480              'is_pure': False,
481              'is_declaration': True})
482
483         self.perform_function_detection(
484             ['virtual void theTestFunctionName(int) = 0;'],
485             {'name': 'theTestFunctionName',
486              'modifiers_and_return_type': 'virtual void',
487              'function_name_start_position': (0, 13),
488              'parameter_start_position': (0, 32),
489              'parameter_end_position': (0, 37),
490              'body_start_position': (0, 41),
491              'end_position': (0, 42),
492              'is_pure': True,
493              'is_declaration': True})
494
495         # Hopefully, no one writes code like this but it is a tricky case.
496         self.perform_function_detection(
497             ['virtual void theTestFunctionName(int)',
498              ' = ',
499              ' 0 ;'],
500             {'name': 'theTestFunctionName',
501              'modifiers_and_return_type': 'virtual void',
502              'function_name_start_position': (0, 13),
503              'parameter_start_position': (0, 32),
504              'parameter_end_position': (0, 37),
505              'body_start_position': (2, 3),
506              'end_position': (2, 4),
507              'is_pure': True,
508              'is_declaration': True})
509
510     def test_ignore_macros(self):
511         self.perform_function_detection(['void aFunctionName(int); \\'], None)
512
513     def test_non_functions(self):
514         # This case exposed an error because the open brace was in quotes.
515         self.perform_function_detection(
516             ['asm(',
517              '    "stmdb sp!, {r1-r3}" "\n"',
518              ');'],
519             # This isn't a function but it looks like one to our simple
520             # algorithm and that is ok.
521             {'name': 'asm',
522              'modifiers_and_return_type': '',
523              'function_name_start_position': (0, 0),
524              'parameter_start_position': (0, 3),
525              'parameter_end_position': (2, 1),
526              'body_start_position': (2, 1),
527              'end_position': (2, 2),
528              'is_pure': False,
529              'is_declaration': True})
530
531         # Simple test case with something that is not a function.
532         self.perform_function_detection(['class Stuff;'], None)
533
534     def test_parameter_list(self):
535         # A function with no arguments.
536         function_state = self.perform_function_detection(
537             ['void functionName();'],
538             {'name': 'functionName',
539              'modifiers_and_return_type': 'void',
540              'function_name_start_position': (0, 5),
541              'parameter_start_position': (0, 17),
542              'parameter_end_position': (0, 19),
543              'body_start_position': (0, 19),
544              'end_position': (0, 20),
545              'is_pure': False,
546              'is_declaration': True,
547              'parameter_list': ()})
548
549         # A function with one argument.
550         function_state = self.perform_function_detection(
551             ['void functionName(int);'],
552             {'name': 'functionName',
553              'modifiers_and_return_type': 'void',
554              'function_name_start_position': (0, 5),
555              'parameter_start_position': (0, 17),
556              'parameter_end_position': (0, 22),
557              'body_start_position': (0, 22),
558              'end_position': (0, 23),
559              'is_pure': False,
560              'is_declaration': True,
561              'parameter_list':
562                  ({'type': 'int', 'name': '', 'row': 0},)})
563
564         # A function with unsigned and short arguments
565         function_state = self.perform_function_detection(
566             ['void functionName(unsigned a, short b, long c, long long short unsigned int);'],
567             {'name': 'functionName',
568              'modifiers_and_return_type': 'void',
569              'function_name_start_position': (0, 5),
570              'parameter_start_position': (0, 17),
571              'parameter_end_position': (0, 76),
572              'body_start_position': (0, 76),
573              'end_position': (0, 77),
574              'is_pure': False,
575              'is_declaration': True,
576              'parameter_list':
577                  ({'type': 'unsigned', 'name': 'a', 'row': 0},
578                   {'type': 'short', 'name': 'b', 'row': 0},
579                   {'type': 'long', 'name': 'c', 'row': 0},
580                   {'type': 'long long short unsigned int', 'name': '', 'row': 0})})
581
582         # Some parameter type with modifiers and no parameter names.
583         function_state = self.perform_function_detection(
584             ['virtual void determineARIADropEffects(Vector<String>*&, const unsigned long int*&, const MediaPlayer::Preload, Other<Other2, Other3<P1, P2> >, int);'],
585             {'name': 'determineARIADropEffects',
586              'modifiers_and_return_type': 'virtual void',
587              'parameter_start_position': (0, 37),
588              'function_name_start_position': (0, 13),
589              'parameter_end_position': (0, 147),
590              'body_start_position': (0, 147),
591              'end_position': (0, 148),
592              'is_pure': False,
593              'is_declaration': True,
594              'parameter_list':
595                  ({'type': 'Vector<String>*&', 'name': '', 'row': 0},
596                   {'type': 'const unsigned long int*&', 'name': '', 'row': 0},
597                   {'type': 'const MediaPlayer::Preload', 'name': '', 'row': 0},
598                   {'type': 'Other<Other2, Other3<P1, P2> >', 'name': '', 'row': 0},
599                   {'type': 'int', 'name': '', 'row': 0})})
600
601         # Try parsing a function with a very complex definition.
602         function_state = self.perform_function_detection(
603             ['#define MyMacro(a) a',
604              'virtual',
605              'AnotherTemplate<Class1, Class2> aFunctionName(PassRefPtr<MyClass> paramName,',
606              'const Other1Class& foo,',
607              'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const * param = new ComplexTemplate<Class1, NestedTemplate<P1, P2> >(34, 42),',
608              'int* myCount = 0);'],
609             {'name': 'aFunctionName',
610              'modifiers_and_return_type': 'virtual AnotherTemplate<Class1, Class2>',
611              'function_name_start_position': (2, 32),
612              'parameter_start_position': (2, 45),
613              'parameter_end_position': (5, 17),
614              'body_start_position': (5, 17),
615              'end_position': (5, 18),
616              'is_pure': False,
617              'is_declaration': True,
618              'parameter_list':
619                  ({'type': 'PassRefPtr<MyClass>', 'name': 'paramName', 'row': 2},
620                   {'type': 'const Other1Class&', 'name': 'foo', 'row': 3},
621                   {'type': 'const ComplexTemplate<Class1, NestedTemplate<P1, P2> >* const *', 'name': 'param', 'row': 4},
622                   {'type': 'int*', 'name': 'myCount', 'row': 5})},
623             detection_line=2)
624
625
626 class Cpp11StyleTest(CppStyleTestBase):
627     def test_rvaule_reference_at_end_of_line(self):
628         self.assert_lint('T&&', '')
629
630     def test_rvaule_reference_in_parameter_pack(self):
631         self.assert_lint('void requestCompleted(Arguments&&... arguments)', '')
632
633 class CppStyleTest(CppStyleTestBase):
634
635     def test_asm_lines_ignored(self):
636         self.assert_lint(
637             '__asm mov [registration], eax',
638             '')
639
640     # Test get line width.
641     def test_get_line_width(self):
642         self.assertEqual(0, cpp_style.get_line_width(''))
643         self.assertEqual(10, cpp_style.get_line_width(u'x' * 10))
644         self.assertEqual(16, cpp_style.get_line_width(u'都|道|府|県|支庁'))
645
646     def test_find_next_multi_line_comment_start(self):
647         self.assertEqual(1, cpp_style.find_next_multi_line_comment_start([''], 0))
648
649         lines = ['a', 'b', '/* c']
650         self.assertEqual(2, cpp_style.find_next_multi_line_comment_start(lines, 0))
651
652         lines = ['char a[] = "/*";']  # not recognized as comment.
653         self.assertEqual(1, cpp_style.find_next_multi_line_comment_start(lines, 0))
654
655     def test_find_next_multi_line_comment_end(self):
656         self.assertEqual(1, cpp_style.find_next_multi_line_comment_end([''], 0))
657         lines = ['a', 'b', ' c */']
658         self.assertEqual(2, cpp_style.find_next_multi_line_comment_end(lines, 0))
659
660     def test_remove_multi_line_comments_from_range(self):
661         lines = ['a', '  /* comment ', ' * still comment', ' comment */   ', 'b']
662         cpp_style.remove_multi_line_comments_from_range(lines, 1, 4)
663         self.assertEqual(['a', '// dummy', '// dummy', '// dummy', 'b'], lines)
664
665     def test_position(self):
666         position = cpp_style.Position(3, 4)
667         self.assert_positions_equal(position, (3, 4))
668         self.assertEqual(position.row, 3)
669         self.assertTrue(position > cpp_style.Position(position.row - 1, position.column + 1))
670         self.assertTrue(position > cpp_style.Position(position.row, position.column - 1))
671         self.assertTrue(position < cpp_style.Position(position.row, position.column + 1))
672         self.assertTrue(position < cpp_style.Position(position.row + 1, position.column - 1))
673         self.assertEqual(position.__str__(), '(3, 4)')
674
675     def test_rfind_in_lines(self):
676         not_found_position = cpp_style.Position(10, 11)
677         start_position = cpp_style.Position(2, 2)
678         lines = ['ab', 'ace', 'test']
679         self.assertEqual(not_found_position, cpp_style._rfind_in_lines('st', lines, start_position, not_found_position))
680         self.assertTrue(cpp_style.Position(1, 1) == cpp_style._rfind_in_lines('a', lines, start_position, not_found_position))
681         self.assertEqual(cpp_style.Position(2, 2), cpp_style._rfind_in_lines('(te|a)', lines, start_position, not_found_position))
682
683     def test_close_expression(self):
684         self.assertEqual(cpp_style.Position(1, -1), cpp_style.close_expression([')('], cpp_style.Position(0, 1)))
685         self.assertEqual(cpp_style.Position(1, -1), cpp_style.close_expression([') ()'], cpp_style.Position(0, 1)))
686         self.assertEqual(cpp_style.Position(0, 4), cpp_style.close_expression([')[)]'], cpp_style.Position(0, 1)))
687         self.assertEqual(cpp_style.Position(0, 5), cpp_style.close_expression(['}{}{}'], cpp_style.Position(0, 3)))
688         self.assertEqual(cpp_style.Position(1, 1), cpp_style.close_expression(['}{}{', '}'], cpp_style.Position(0, 3)))
689         self.assertEqual(cpp_style.Position(2, -1), cpp_style.close_expression(['][][', ' '], cpp_style.Position(0, 3)))
690
691     def test_spaces_at_end_of_line(self):
692         self.assert_lint(
693             '// Hello there ',
694             'Line ends in whitespace.  Consider deleting these extra spaces.'
695             '  [whitespace/end_of_line] [4]')
696
697     # Test C-style cast cases.
698     def test_cstyle_cast(self):
699         self.assert_lint(
700             'int a = (int)1.0;',
701             'Using C-style cast.  Use static_cast<int>(...) instead'
702             '  [readability/casting] [4]')
703         self.assert_lint(
704             'int *a = (int *)DEFINED_VALUE;',
705             'Using C-style cast.  Use reinterpret_cast<int *>(...) instead'
706             '  [readability/casting] [4]', 'foo.c')
707         self.assert_lint(
708             'uint16 a = (uint16)1.0;',
709             'Using C-style cast.  Use static_cast<uint16>(...) instead'
710             '  [readability/casting] [4]')
711         self.assert_lint(
712             'int32 a = (int32)1.0;',
713             'Using C-style cast.  Use static_cast<int32>(...) instead'
714             '  [readability/casting] [4]')
715         self.assert_lint(
716             'uint64 a = (uint64)1.0;',
717             'Using C-style cast.  Use static_cast<uint64>(...) instead'
718             '  [readability/casting] [4]')
719
720     # Test taking address of casts (runtime/casting)
721     def test_runtime_casting(self):
722         self.assert_lint(
723             'int* x = &static_cast<int*>(foo);',
724             'Are you taking an address of a cast?  '
725             'This is dangerous: could be a temp var.  '
726             'Take the address before doing the cast, rather than after'
727             '  [runtime/casting] [4]')
728
729         self.assert_lint(
730             'int* x = &dynamic_cast<int *>(foo);',
731             ['Are you taking an address of a cast?  '
732              'This is dangerous: could be a temp var.  '
733              'Take the address before doing the cast, rather than after'
734              '  [runtime/casting] [4]',
735              'Do not use dynamic_cast<>.  If you need to cast within a class '
736              'hierarchy, use static_cast<> to upcast.  Google doesn\'t support '
737              'RTTI.  [runtime/rtti] [5]'])
738
739         self.assert_lint(
740             'int* x = &reinterpret_cast<int *>(foo);',
741             'Are you taking an address of a cast?  '
742             'This is dangerous: could be a temp var.  '
743             'Take the address before doing the cast, rather than after'
744             '  [runtime/casting] [4]')
745
746         # It's OK to cast an address.
747         self.assert_lint(
748             'int* x = reinterpret_cast<int *>(&foo);',
749             '')
750
751     def test_runtime_selfinit(self):
752         self.assert_multi_line_lint(
753             '''\
754             Foo::Foo(Bar raa, Bel laa)
755                 : raa_(raa_)
756                 , laa_(laa_) { }''',
757             ['You seem to be initializing a member variable with itself.'
758             '  [runtime/init] [4]',
759             'You seem to be initializing a member variable with itself.'
760             '  [runtime/init] [4]'])
761         self.assert_multi_line_lint(
762             '''\
763             Foo::Foo(Bar raa, Bel laa)
764                 : raa_(raa)
765                 , laa_(laa) { }''',
766             '')
767         self.assert_multi_line_lint(
768             '''\
769             Foo::Foo(Bar raa)
770                 : raa_(raa)
771                 , laa_(raa_)
772                 , llaa_(laa_) { }''',
773             '')
774
775     def test_runtime_rtti(self):
776         statement = 'int* x = dynamic_cast<int*>(&foo);'
777         error_message = (
778             'Do not use dynamic_cast<>.  If you need to cast within a class '
779             'hierarchy, use static_cast<> to upcast.  Google doesn\'t support '
780             'RTTI.  [runtime/rtti] [5]')
781         # dynamic_cast is disallowed in most files.
782         self.assert_language_rules_check('foo.cpp', statement, error_message)
783         self.assert_language_rules_check('foo.h', statement, error_message)
784
785     # Test for static_cast readability.
786     def test_static_cast_readability(self):
787         self.assert_lint(
788             'Text* x = static_cast<Text*>(foo);',
789             'Consider using toText helper function in WebCore/dom/Text.h '
790             'instead of static_cast<Text*>'
791             '  [readability/check] [4]')
792
793     # We cannot test this functionality because of difference of
794     # function definitions.  Anyway, we may never enable this.
795     #
796     # # Test for unnamed arguments in a method.
797     # def test_check_for_unnamed_params(self):
798     #   message = ('All parameters should be named in a function'
799     #              '  [readability/function] [3]')
800     #   self.assert_lint('virtual void A(int*) const;', message)
801     #   self.assert_lint('virtual void B(void (*fn)(int*));', message)
802     #   self.assert_lint('virtual void C(int*);', message)
803     #   self.assert_lint('void *(*f)(void *) = x;', message)
804     #   self.assert_lint('void Method(char*) {', message)
805     #   self.assert_lint('void Method(char*);', message)
806     #   self.assert_lint('void Method(char* /*x*/);', message)
807     #   self.assert_lint('typedef void (*Method)(int32);', message)
808     #   self.assert_lint('static void operator delete[](void*) throw();', message)
809     #
810     #   self.assert_lint('virtual void D(int* p);', '')
811     #   self.assert_lint('void operator delete(void* x) throw();', '')
812     #   self.assert_lint('void Method(char* x)\n{', '')
813     #   self.assert_lint('void Method(char* /*x*/)\n{', '')
814     #   self.assert_lint('void Method(char* x);', '')
815     #   self.assert_lint('typedef void (*Method)(int32 x);', '')
816     #   self.assert_lint('static void operator delete[](void* x) throw();', '')
817     #   self.assert_lint('static void operator delete[](void* /*x*/) throw();', '')
818     #
819     #   # This one should technically warn, but doesn't because the function
820     #   # pointer is confusing.
821     #   self.assert_lint('virtual void E(void (*fn)(int* p));', '')
822
823     # Test deprecated casts such as int(d)
824     def test_deprecated_cast(self):
825         self.assert_lint(
826             'int a = int(2.2);',
827             'Using deprecated casting style.  '
828             'Use static_cast<int>(...) instead'
829             '  [readability/casting] [4]')
830         # Checks for false positives...
831         self.assert_lint(
832             'int a = int(); // Constructor, o.k.',
833             '')
834         self.assert_multi_line_lint(
835             '''\
836             X::X()
837                 : a(int()) { } // default Constructor, o.k.''',
838             '')
839         self.assert_lint(
840             'operator bool(); // Conversion operator, o.k.',
841             '')
842
843     # The second parameter to a gMock method definition is a function signature
844     # that often looks like a bad cast but should not picked up by lint.
845     def test_mock_method(self):
846         self.assert_lint(
847             'MOCK_METHOD0(method, int());',
848             '')
849         self.assert_lint(
850             'MOCK_CONST_METHOD1(method, float(string));',
851             '')
852         self.assert_lint(
853             'MOCK_CONST_METHOD2_T(method, double(float, float));',
854             '')
855
856     # Test sizeof(type) cases.
857     def test_sizeof_type(self):
858         self.assert_lint(
859             'sizeof(int);',
860             'Using sizeof(type).  Use sizeof(varname) instead if possible'
861             '  [runtime/sizeof] [1]')
862         self.assert_lint(
863             'sizeof(int *);',
864             'Using sizeof(type).  Use sizeof(varname) instead if possible'
865             '  [runtime/sizeof] [1]')
866
867     # Test typedef cases.  There was a bug that cpp_style misidentified
868     # typedef for pointer to function as C-style cast and produced
869     # false-positive error messages.
870     def test_typedef_for_pointer_to_function(self):
871         self.assert_lint(
872             'typedef void (*Func)(int x);',
873             '')
874         self.assert_lint(
875             'typedef void (*Func)(int *x);',
876             '')
877         self.assert_lint(
878             'typedef void Func(int x);',
879             '')
880         self.assert_lint(
881             'typedef void Func(int *x);',
882             '')
883
884     def test_include_what_you_use_no_implementation_files(self):
885         code = 'std::vector<int> foo;'
886         self.assertEqual('Add #include <vector> for vector<>'
887                           '  [build/include_what_you_use] [4]',
888                           self.perform_include_what_you_use(code, 'foo.h'))
889         self.assertEqual('',
890                           self.perform_include_what_you_use(code, 'foo.cpp'))
891
892     def test_include_what_you_use(self):
893         self.assert_include_what_you_use(
894             '''#include <vector>
895                std::vector<int> foo;
896             ''',
897             '')
898         self.assert_include_what_you_use(
899             '''#include <map>
900                std::pair<int,int> foo;
901             ''',
902             '')
903         self.assert_include_what_you_use(
904             '''#include <multimap>
905                std::pair<int,int> foo;
906             ''',
907             '')
908         self.assert_include_what_you_use(
909             '''#include <hash_map>
910                std::pair<int,int> foo;
911             ''',
912             '')
913         self.assert_include_what_you_use(
914             '''#include <utility>
915                std::pair<int,int> foo;
916             ''',
917             '')
918         self.assert_include_what_you_use(
919             '''#include <vector>
920                DECLARE_string(foobar);
921             ''',
922             '')
923         self.assert_include_what_you_use(
924             '''#include <vector>
925                DEFINE_string(foobar, "", "");
926             ''',
927             '')
928         self.assert_include_what_you_use(
929             '''#include <vector>
930                std::pair<int,int> foo;
931             ''',
932             'Add #include <utility> for pair<>'
933             '  [build/include_what_you_use] [4]')
934         self.assert_include_what_you_use(
935             '''#include "base/foobar.h"
936                std::vector<int> foo;
937             ''',
938             'Add #include <vector> for vector<>'
939             '  [build/include_what_you_use] [4]')
940         self.assert_include_what_you_use(
941             '''#include <vector>
942                std::set<int> foo;
943             ''',
944             'Add #include <set> for set<>'
945             '  [build/include_what_you_use] [4]')
946         self.assert_include_what_you_use(
947             '''#include "base/foobar.h"
948               hash_map<int, int> foobar;
949             ''',
950             'Add #include <hash_map> for hash_map<>'
951             '  [build/include_what_you_use] [4]')
952         self.assert_include_what_you_use(
953             '''#include "base/foobar.h"
954                bool foobar = std::less<int>(0,1);
955             ''',
956             'Add #include <functional> for less<>'
957             '  [build/include_what_you_use] [4]')
958         self.assert_include_what_you_use(
959             '''#include "base/foobar.h"
960                bool foobar = min<int>(0,1);
961             ''',
962             'Add #include <algorithm> for min  [build/include_what_you_use] [4]')
963         self.assert_include_what_you_use(
964             'void a(const string &foobar);',
965             'Add #include <string> for string  [build/include_what_you_use] [4]')
966         self.assert_include_what_you_use(
967             '''#include "base/foobar.h"
968                bool foobar = swap(0,1);
969             ''',
970             'Add #include <algorithm> for swap  [build/include_what_you_use] [4]')
971         self.assert_include_what_you_use(
972             '''#include "base/foobar.h"
973                bool foobar = transform(a.begin(), a.end(), b.start(), Foo);
974             ''',
975             'Add #include <algorithm> for transform  '
976             '[build/include_what_you_use] [4]')
977         self.assert_include_what_you_use(
978             '''#include "base/foobar.h"
979                bool foobar = min_element(a.begin(), a.end());
980             ''',
981             'Add #include <algorithm> for min_element  '
982             '[build/include_what_you_use] [4]')
983         self.assert_include_what_you_use(
984             '''foo->swap(0,1);
985                foo.swap(0,1);
986             ''',
987             '')
988         self.assert_include_what_you_use(
989             '''#include <string>
990                void a(const std::multimap<int,string> &foobar);
991             ''',
992             'Add #include <map> for multimap<>'
993             '  [build/include_what_you_use] [4]')
994         self.assert_include_what_you_use(
995             '''#include <queue>
996                void a(const std::priority_queue<int> &foobar);
997             ''',
998             '')
999         self.assert_include_what_you_use(
1000              '''#include "base/basictypes.h"
1001                 #include "base/port.h"
1002                 #include <assert.h>
1003                 #include <string>
1004                 #include <vector>
1005                 vector<string> hajoa;''', '')
1006         self.assert_include_what_you_use(
1007             '''#include <string>
1008                int i = numeric_limits<int>::max()
1009             ''',
1010             'Add #include <limits> for numeric_limits<>'
1011             '  [build/include_what_you_use] [4]')
1012         self.assert_include_what_you_use(
1013             '''#include <limits>
1014                int i = numeric_limits<int>::max()
1015             ''',
1016             '')
1017
1018         # Test the UpdateIncludeState code path.
1019         mock_header_contents = ['#include "blah/foo.h"', '#include "blah/bar.h"']
1020         message = self.perform_include_what_you_use(
1021             '#include "config.h"\n'
1022             '#include "blah/a.h"\n',
1023             filename='blah/a.cpp',
1024             io=MockIo(mock_header_contents))
1025         self.assertEqual(message, '')
1026
1027         mock_header_contents = ['#include <set>']
1028         message = self.perform_include_what_you_use(
1029             '''#include "config.h"
1030                #include "blah/a.h"
1031
1032                std::set<int> foo;''',
1033             filename='blah/a.cpp',
1034             io=MockIo(mock_header_contents))
1035         self.assertEqual(message, '')
1036
1037         # If there's just a .cpp and the header can't be found then it's ok.
1038         message = self.perform_include_what_you_use(
1039             '''#include "config.h"
1040                #include "blah/a.h"
1041
1042                std::set<int> foo;''',
1043             filename='blah/a.cpp')
1044         self.assertEqual(message, '')
1045
1046         # Make sure we find the headers with relative paths.
1047         mock_header_contents = ['']
1048         message = self.perform_include_what_you_use(
1049             '''#include "config.h"
1050                #include "%s%sa.h"
1051
1052                std::set<int> foo;''' % (os.path.basename(os.getcwd()), os.path.sep),
1053             filename='a.cpp',
1054             io=MockIo(mock_header_contents))
1055         self.assertEqual(message, 'Add #include <set> for set<>  '
1056                                    '[build/include_what_you_use] [4]')
1057
1058     def test_files_belong_to_same_module(self):
1059         f = cpp_style.files_belong_to_same_module
1060         self.assertEqual((True, ''), f('a.cpp', 'a.h'))
1061         self.assertEqual((True, ''), f('base/google.cpp', 'base/google.h'))
1062         self.assertEqual((True, ''), f('base/google_test.cpp', 'base/google.h'))
1063         self.assertEqual((True, ''),
1064                           f('base/google_unittest.cpp', 'base/google.h'))
1065         self.assertEqual((True, ''),
1066                           f('base/internal/google_unittest.cpp',
1067                             'base/public/google.h'))
1068         self.assertEqual((True, 'xxx/yyy/'),
1069                           f('xxx/yyy/base/internal/google_unittest.cpp',
1070                             'base/public/google.h'))
1071         self.assertEqual((True, 'xxx/yyy/'),
1072                           f('xxx/yyy/base/google_unittest.cpp',
1073                             'base/public/google.h'))
1074         self.assertEqual((True, ''),
1075                           f('base/google_unittest.cpp', 'base/google-inl.h'))
1076         self.assertEqual((True, '/home/build/google3/'),
1077                           f('/home/build/google3/base/google.cpp', 'base/google.h'))
1078
1079         self.assertEqual((False, ''),
1080                           f('/home/build/google3/base/google.cpp', 'basu/google.h'))
1081         self.assertEqual((False, ''), f('a.cpp', 'b.h'))
1082
1083     def test_cleanse_line(self):
1084         self.assertEqual('int foo = 0;  ',
1085                           cpp_style.cleanse_comments('int foo = 0;  // danger!'))
1086         self.assertEqual('int o = 0;',
1087                           cpp_style.cleanse_comments('int /* foo */ o = 0;'))
1088         self.assertEqual('foo(int a, int b);',
1089                           cpp_style.cleanse_comments('foo(int a /* abc */, int b);'))
1090         self.assertEqual('f(a, b);',
1091                          cpp_style.cleanse_comments('f(a, /* name */ b);'))
1092         self.assertEqual('f(a, b);',
1093                          cpp_style.cleanse_comments('f(a /* name */, b);'))
1094         self.assertEqual('f(a, b);',
1095                          cpp_style.cleanse_comments('f(a, /* name */b);'))
1096
1097     def test_multi_line_comments(self):
1098         # missing explicit is bad
1099         self.assert_multi_line_lint(
1100             r'''int a = 0;
1101                 /* multi-liner
1102                 class Foo {
1103                 Foo(int f);  // should cause a lint warning in code
1104                 }
1105             */ ''',
1106         '')
1107         self.assert_multi_line_lint(
1108             '''\
1109             /* int a = 0; multi-liner
1110             static const int b = 0;''',
1111             ['Could not find end of multi-line comment'
1112              '  [readability/multiline_comment] [5]',
1113              'Complex multi-line /*...*/-style comment found. '
1114              'Lint may give bogus warnings.  Consider replacing these with '
1115              '//-style comments, with #if 0...#endif, or with more clearly '
1116              'structured multi-line comments.  [readability/multiline_comment] [5]'])
1117         self.assert_multi_line_lint(r'''    /* multi-line comment''',
1118                                     ['Could not find end of multi-line comment'
1119                                      '  [readability/multiline_comment] [5]',
1120                                      'Complex multi-line /*...*/-style comment found. '
1121                                      'Lint may give bogus warnings.  Consider replacing these with '
1122                                      '//-style comments, with #if 0...#endif, or with more clearly '
1123                                      'structured multi-line comments.  [readability/multiline_comment] [5]'])
1124         self.assert_multi_line_lint(r'''    // /* comment, but not multi-line''', '')
1125
1126     def test_multiline_strings(self):
1127         multiline_string_error_message = (
1128             'Multi-line string ("...") found.  This lint script doesn\'t '
1129             'do well with such strings, and may give bogus warnings.  They\'re '
1130             'ugly and unnecessary, and you should use concatenation instead".'
1131             '  [readability/multiline_string] [5]')
1132
1133         file_path = 'mydir/foo.cpp'
1134
1135         error_collector = ErrorCollector(self.assertTrue)
1136         self.process_file_data(file_path, 'cpp',
1137                                ['const char* str = "This is a\\',
1138                                 ' multiline string.";'],
1139                                error_collector)
1140         self.assertEqual(
1141             2,  # One per line.
1142             error_collector.result_list().count(multiline_string_error_message))
1143
1144     # Test non-explicit single-argument constructors
1145     def test_explicit_single_argument_constructors(self):
1146         # missing explicit is bad
1147         self.assert_multi_line_lint(
1148             '''\
1149             class Foo {
1150                 Foo(int f);
1151             };''',
1152             'Single-argument constructors should be marked explicit.'
1153             '  [runtime/explicit] [5]')
1154         # missing explicit is bad, even with whitespace
1155         self.assert_multi_line_lint(
1156             '''\
1157             class Foo {
1158                 Foo (int f);
1159             };''',
1160             ['Extra space before ( in function call  [whitespace/parens] [4]',
1161              'Single-argument constructors should be marked explicit.'
1162              '  [runtime/explicit] [5]'])
1163         # missing explicit, with distracting comment, is still bad
1164         self.assert_multi_line_lint(
1165             '''\
1166             class Foo {
1167                 Foo(int f); // simpler than Foo(blargh, blarg)
1168             };''',
1169             'Single-argument constructors should be marked explicit.'
1170             '  [runtime/explicit] [5]')
1171         # missing explicit, with qualified classname
1172         self.assert_multi_line_lint(
1173             '''\
1174             class Qualifier::AnotherOne::Foo {
1175                 Foo(int f);
1176             };''',
1177             'Single-argument constructors should be marked explicit.'
1178             '  [runtime/explicit] [5]')
1179         # structs are caught as well.
1180         self.assert_multi_line_lint(
1181             '''\
1182             struct Foo {
1183                 Foo(int f);
1184             };''',
1185             'Single-argument constructors should be marked explicit.'
1186             '  [runtime/explicit] [5]')
1187         # Templatized classes are caught as well.
1188         self.assert_multi_line_lint(
1189             '''\
1190             template<typename T> class Foo {
1191                 Foo(int f);
1192             };''',
1193             'Single-argument constructors should be marked explicit.'
1194             '  [runtime/explicit] [5]')
1195         # proper style is okay
1196         self.assert_multi_line_lint(
1197             '''\
1198             class Foo {
1199                 explicit Foo(int f);
1200             };''',
1201             '')
1202         # two argument constructor is okay
1203         self.assert_multi_line_lint(
1204             '''\
1205             class Foo {
1206                 Foo(int f, int b);
1207             };''',
1208             '')
1209         # two argument constructor, across two lines, is okay
1210         self.assert_multi_line_lint(
1211             '''\
1212             class Foo {
1213                 Foo(int f,
1214                     int b);
1215             };''',
1216             '')
1217         # non-constructor (but similar name), is okay
1218         self.assert_multi_line_lint(
1219             '''\
1220             class Foo {
1221                 aFoo(int f);
1222             };''',
1223             '')
1224         # constructor with void argument is okay
1225         self.assert_multi_line_lint(
1226             '''\
1227             class Foo {
1228                 Foo(void);
1229             };''',
1230             '')
1231         # single argument method is okay
1232         self.assert_multi_line_lint(
1233             '''\
1234             class Foo {
1235                 Bar(int b);
1236             };''',
1237             '')
1238         # comments should be ignored
1239         self.assert_multi_line_lint(
1240             '''\
1241             class Foo {
1242             // Foo(int f);
1243             };''',
1244             '')
1245         # single argument function following class definition is okay
1246         # (okay, it's not actually valid, but we don't want a false positive)
1247         self.assert_multi_line_lint(
1248             '''\
1249             class Foo {
1250                 Foo(int f, int b);
1251             };
1252             Foo(int f);''',
1253             '')
1254         # single argument function is okay
1255         self.assert_multi_line_lint(
1256             '''static Foo(int f);''',
1257             '')
1258         # single argument copy constructor is okay.
1259         self.assert_multi_line_lint(
1260             '''\
1261             class Foo {
1262                 Foo(const Foo&);
1263             };''',
1264             '')
1265         self.assert_multi_line_lint(
1266             '''\
1267             class Foo {
1268                 Foo(Foo&);
1269             };''',
1270             '')
1271
1272     def test_slash_star_comment_on_single_line(self):
1273         self.assert_multi_line_lint(
1274             '''/* static */ Foo(int f);''',
1275             '')
1276         self.assert_multi_line_lint(
1277             '''/*/ static */  Foo(int f);''',
1278             '')
1279         self.assert_multi_line_lint(
1280             '''/*/ static Foo(int f);''',
1281             'Could not find end of multi-line comment'
1282             '  [readability/multiline_comment] [5]')
1283         self.assert_multi_line_lint(
1284             '''    /*/ static Foo(int f);''',
1285             'Could not find end of multi-line comment'
1286             '  [readability/multiline_comment] [5]')
1287
1288     # Test suspicious usage of "if" like this:
1289     # if (a == b) {
1290     #   DoSomething();
1291     # } if (a == c) {   // Should be "else if".
1292     #   DoSomething();  // This gets called twice if a == b && a == c.
1293     # }
1294     def test_suspicious_usage_of_if(self):
1295         self.assert_lint(
1296             '    if (a == b) {',
1297             '')
1298         self.assert_lint(
1299             '    } if (a == b) {',
1300             'Did you mean "else if"? If not, start a new line for "if".'
1301             '  [readability/braces] [4]')
1302
1303     # Test suspicious usage of memset. Specifically, a 0
1304     # as the final argument is almost certainly an error.
1305     def test_suspicious_usage_of_memset(self):
1306         # Normal use is okay.
1307         self.assert_lint(
1308             '    memset(buf, 0, sizeof(buf))',
1309             '')
1310
1311         # A 0 as the final argument is almost certainly an error.
1312         self.assert_lint(
1313             '    memset(buf, sizeof(buf), 0)',
1314             'Did you mean "memset(buf, 0, sizeof(buf))"?'
1315             '  [runtime/memset] [4]')
1316         self.assert_lint(
1317             '    memset(buf, xsize * ysize, 0)',
1318             'Did you mean "memset(buf, 0, xsize * ysize)"?'
1319             '  [runtime/memset] [4]')
1320
1321         # There is legitimate test code that uses this form.
1322         # This is okay since the second argument is a literal.
1323         self.assert_lint(
1324             "    memset(buf, 'y', 0)",
1325             '')
1326         self.assert_lint(
1327             '    memset(buf, 4, 0)',
1328             '')
1329         self.assert_lint(
1330             '    memset(buf, -1, 0)',
1331             '')
1332         self.assert_lint(
1333             '    memset(buf, 0xF1, 0)',
1334             '')
1335         self.assert_lint(
1336             '    memset(buf, 0xcd, 0)',
1337             '')
1338
1339     def test_check_posix_threading(self):
1340         self.assert_lint('sctime_r()', '')
1341         self.assert_lint('strtok_r()', '')
1342         self.assert_lint('    strtok_r(foo, ba, r)', '')
1343         self.assert_lint('brand()', '')
1344         self.assert_lint('_rand()', '')
1345         self.assert_lint('.rand()', '')
1346         self.assert_lint('>rand()', '')
1347         self.assert_lint('rand()',
1348                          'Consider using rand_r(...) instead of rand(...)'
1349                          ' for improved thread safety.'
1350                          '  [runtime/threadsafe_fn] [2]')
1351         self.assert_lint('strtok()',
1352                          'Consider using strtok_r(...) '
1353                          'instead of strtok(...)'
1354                          ' for improved thread safety.'
1355                          '  [runtime/threadsafe_fn] [2]')
1356
1357     # Test potential format string bugs like printf(foo).
1358     def test_format_strings(self):
1359         self.assert_lint('printf("foo")', '')
1360         self.assert_lint('printf("foo: %s", foo)', '')
1361         self.assert_lint('DocidForPrintf(docid)', '')  # Should not trigger.
1362         self.assert_lint(
1363             'printf(foo)',
1364             'Potential format string bug. Do printf("%s", foo) instead.'
1365             '  [runtime/printf] [4]')
1366         self.assert_lint(
1367             'printf(foo.c_str())',
1368             'Potential format string bug. '
1369             'Do printf("%s", foo.c_str()) instead.'
1370             '  [runtime/printf] [4]')
1371         self.assert_lint(
1372             'printf(foo->c_str())',
1373             'Potential format string bug. '
1374             'Do printf("%s", foo->c_str()) instead.'
1375             '  [runtime/printf] [4]')
1376         self.assert_lint(
1377             'StringPrintf(foo)',
1378             'Potential format string bug. Do StringPrintf("%s", foo) instead.'
1379             ''
1380             '  [runtime/printf] [4]')
1381
1382     # Variable-length arrays are not permitted.
1383     def test_variable_length_array_detection(self):
1384         errmsg = ('Do not use variable-length arrays.  Use an appropriately named '
1385                   "('k' followed by CamelCase) compile-time constant for the size."
1386                   '  [runtime/arrays] [1]')
1387
1388         self.assert_lint('int a[any_old_variable];', errmsg)
1389         self.assert_lint('int doublesize[some_var * 2];', errmsg)
1390         self.assert_lint('int a[afunction()];', errmsg)
1391         self.assert_lint('int a[function(kMaxFooBars)];', errmsg)
1392         self.assert_lint('bool aList[items_->size()];', errmsg)
1393         self.assert_lint('namespace::Type buffer[len+1];', errmsg)
1394
1395         self.assert_lint('int a[64];', '')
1396         self.assert_lint('int a[0xFF];', '')
1397         self.assert_lint('int first[256], second[256];', '')
1398         self.assert_lint('int arrayName[kCompileTimeConstant];', '')
1399         self.assert_lint('char buf[somenamespace::kBufSize];', '')
1400         self.assert_lint('int arrayName[ALL_CAPS];', '')
1401         self.assert_lint('AClass array1[foo::bar::ALL_CAPS];', '')
1402         self.assert_lint('int a[kMaxStrLen + 1];', '')
1403         self.assert_lint('int a[sizeof(foo)];', '')
1404         self.assert_lint('int a[sizeof(*foo)];', '')
1405         self.assert_lint('int a[sizeof foo];', '')
1406         self.assert_lint('int a[sizeof(struct Foo)];', '')
1407         self.assert_lint('int a[128 - sizeof(const bar)];', '')
1408         self.assert_lint('int a[(sizeof(foo) * 4)];', '')
1409         self.assert_lint('int a[(arraysize(fixed_size_array)/2) << 1];', 'Missing spaces around /  [whitespace/operators] [3]')
1410         self.assert_lint('delete a[some_var];', '')
1411         self.assert_lint('return a[some_var];', '')
1412
1413     # Brace usage
1414     def test_braces(self):
1415         # Braces shouldn't be followed by a ; unless they're defining a struct
1416         # or initializing an array
1417         self.assert_lint('int a[3] = { 1, 2, 3 };', '')
1418         self.assert_lint(
1419             '''\
1420             const int foo[] =
1421                 {1, 2, 3 };''',
1422             '')
1423         # For single line, unmatched '}' with a ';' is ignored (not enough context)
1424         self.assert_multi_line_lint(
1425             '''\
1426             int a[3] = { 1,
1427                 2,
1428                 3 };''',
1429             '')
1430         self.assert_multi_line_lint(
1431             '''\
1432             int a[2][3] = { { 1, 2 },
1433                 { 3, 4 } };''',
1434             '')
1435         self.assert_multi_line_lint(
1436             '''\
1437             int a[2][3] =
1438                 { { 1, 2 },
1439                 { 3, 4 } };''',
1440             '')
1441
1442     # CHECK/EXPECT_TRUE/EXPECT_FALSE replacements
1443     def test_check_check(self):
1444         self.assert_lint('CHECK(x == 42)',
1445                          'Consider using CHECK_EQ instead of CHECK(a == b)'
1446                          '  [readability/check] [2]')
1447         self.assert_lint('CHECK(x != 42)',
1448                          'Consider using CHECK_NE instead of CHECK(a != b)'
1449                          '  [readability/check] [2]')
1450         self.assert_lint('CHECK(x >= 42)',
1451                          'Consider using CHECK_GE instead of CHECK(a >= b)'
1452                          '  [readability/check] [2]')
1453         self.assert_lint('CHECK(x > 42)',
1454                          'Consider using CHECK_GT instead of CHECK(a > b)'
1455                          '  [readability/check] [2]')
1456         self.assert_lint('CHECK(x <= 42)',
1457                          'Consider using CHECK_LE instead of CHECK(a <= b)'
1458                          '  [readability/check] [2]')
1459         self.assert_lint('CHECK(x < 42)',
1460                          'Consider using CHECK_LT instead of CHECK(a < b)'
1461                          '  [readability/check] [2]')
1462
1463         self.assert_lint('DCHECK(x == 42)',
1464                          'Consider using DCHECK_EQ instead of DCHECK(a == b)'
1465                          '  [readability/check] [2]')
1466         self.assert_lint('DCHECK(x != 42)',
1467                          'Consider using DCHECK_NE instead of DCHECK(a != b)'
1468                          '  [readability/check] [2]')
1469         self.assert_lint('DCHECK(x >= 42)',
1470                          'Consider using DCHECK_GE instead of DCHECK(a >= b)'
1471                          '  [readability/check] [2]')
1472         self.assert_lint('DCHECK(x > 42)',
1473                          'Consider using DCHECK_GT instead of DCHECK(a > b)'
1474                          '  [readability/check] [2]')
1475         self.assert_lint('DCHECK(x <= 42)',
1476                          'Consider using DCHECK_LE instead of DCHECK(a <= b)'
1477                          '  [readability/check] [2]')
1478         self.assert_lint('DCHECK(x < 42)',
1479                          'Consider using DCHECK_LT instead of DCHECK(a < b)'
1480                          '  [readability/check] [2]')
1481
1482         self.assert_lint(
1483             'EXPECT_TRUE("42" == x)',
1484             'Consider using EXPECT_EQ instead of EXPECT_TRUE(a == b)'
1485             '  [readability/check] [2]')
1486         self.assert_lint(
1487             'EXPECT_TRUE("42" != x)',
1488             'Consider using EXPECT_NE instead of EXPECT_TRUE(a != b)'
1489             '  [readability/check] [2]')
1490         self.assert_lint(
1491             'EXPECT_TRUE(+42 >= x)',
1492             'Consider using EXPECT_GE instead of EXPECT_TRUE(a >= b)'
1493             '  [readability/check] [2]')
1494         self.assert_lint(
1495             'EXPECT_TRUE_M(-42 > x)',
1496             'Consider using EXPECT_GT_M instead of EXPECT_TRUE_M(a > b)'
1497             '  [readability/check] [2]')
1498         self.assert_lint(
1499             'EXPECT_TRUE_M(42U <= x)',
1500             'Consider using EXPECT_LE_M instead of EXPECT_TRUE_M(a <= b)'
1501             '  [readability/check] [2]')
1502         self.assert_lint(
1503             'EXPECT_TRUE_M(42L < x)',
1504             'Consider using EXPECT_LT_M instead of EXPECT_TRUE_M(a < b)'
1505             '  [readability/check] [2]')
1506
1507         self.assert_lint(
1508             'EXPECT_FALSE(x == 42)',
1509             'Consider using EXPECT_NE instead of EXPECT_FALSE(a == b)'
1510             '  [readability/check] [2]')
1511         self.assert_lint(
1512             'EXPECT_FALSE(x != 42)',
1513             'Consider using EXPECT_EQ instead of EXPECT_FALSE(a != b)'
1514             '  [readability/check] [2]')
1515         self.assert_lint(
1516             'EXPECT_FALSE(x >= 42)',
1517             'Consider using EXPECT_LT instead of EXPECT_FALSE(a >= b)'
1518             '  [readability/check] [2]')
1519         self.assert_lint(
1520             'ASSERT_FALSE(x > 42)',
1521             'Consider using ASSERT_LE instead of ASSERT_FALSE(a > b)'
1522             '  [readability/check] [2]')
1523         self.assert_lint(
1524             'ASSERT_FALSE(x <= 42)',
1525             'Consider using ASSERT_GT instead of ASSERT_FALSE(a <= b)'
1526             '  [readability/check] [2]')
1527         self.assert_lint(
1528             'ASSERT_FALSE_M(x < 42)',
1529             'Consider using ASSERT_GE_M instead of ASSERT_FALSE_M(a < b)'
1530             '  [readability/check] [2]')
1531
1532         self.assert_lint('CHECK(some_iterator == obj.end())', '')
1533         self.assert_lint('EXPECT_TRUE(some_iterator == obj.end())', '')
1534         self.assert_lint('EXPECT_FALSE(some_iterator == obj.end())', '')
1535
1536         self.assert_lint('CHECK(CreateTestFile(dir, (1 << 20)));', '')
1537         self.assert_lint('CHECK(CreateTestFile(dir, (1 >> 20)));', '')
1538
1539         self.assert_lint('CHECK(x<42)',
1540                          ['Missing spaces around <'
1541                           '  [whitespace/operators] [3]',
1542                           'Consider using CHECK_LT instead of CHECK(a < b)'
1543                           '  [readability/check] [2]'])
1544         self.assert_lint('CHECK(x>42)',
1545                          'Consider using CHECK_GT instead of CHECK(a > b)'
1546                          '  [readability/check] [2]')
1547
1548         self.assert_lint(
1549             '    EXPECT_TRUE(42 < x) // Random comment.',
1550             'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)'
1551             '  [readability/check] [2]')
1552         self.assert_lint(
1553             'EXPECT_TRUE( 42 < x )',
1554             ['Extra space after ( in function call'
1555              '  [whitespace/parens] [4]',
1556              'Consider using EXPECT_LT instead of EXPECT_TRUE(a < b)'
1557              '  [readability/check] [2]'])
1558         self.assert_lint(
1559             'CHECK("foo" == "foo")',
1560             'Consider using CHECK_EQ instead of CHECK(a == b)'
1561             '  [readability/check] [2]')
1562
1563         self.assert_lint('CHECK_EQ("foo", "foo")', '')
1564
1565     def test_brace_at_begin_of_line(self):
1566         self.assert_lint('{',
1567                          'This { should be at the end of the previous line'
1568                          '  [whitespace/braces] [4]')
1569         self.assert_multi_line_lint(
1570             '#endif\n'
1571             '{\n'
1572             '}\n',
1573             '')
1574         self.assert_multi_line_lint(
1575             'if (condition) {',
1576             '')
1577         self.assert_multi_line_lint(
1578             '    MACRO1(macroArg) {',
1579             '')
1580         self.assert_multi_line_lint(
1581             'ACCESSOR_GETTER(MessageEventPorts) {',
1582             'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
1583         self.assert_multi_line_lint(
1584             'int foo() {',
1585             'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
1586         self.assert_multi_line_lint(
1587             'int foo() const {',
1588             'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
1589         self.assert_multi_line_lint(
1590             'int foo() const override {',
1591             'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
1592         self.assert_multi_line_lint(
1593             'int foo() override {',
1594             'Place brace on its own line for function definitions.  [whitespace/braces] [4]')
1595         self.assert_multi_line_lint(
1596             'int foo() const\n'
1597             '{\n'
1598             '}\n',
1599             '')
1600         self.assert_multi_line_lint(
1601             'int foo() override\n'
1602             '{\n'
1603             '}\n',
1604             '')
1605         self.assert_multi_line_lint(
1606             'if (condition\n'
1607             '    && condition2\n'
1608             '    && condition3) {\n'
1609             '}\n',
1610             '')
1611         self.assert_multi_line_lint(
1612             'auto Foo:bar() -> Baz\n'
1613             '{\n'
1614             '}\n',
1615             '')
1616
1617     def test_mismatching_spaces_in_parens(self):
1618         self.assert_lint('if (foo ) {', 'Extra space before ) in if'
1619                          '  [whitespace/parens] [5]')
1620         self.assert_lint('switch ( foo) {', 'Extra space after ( in switch'
1621                          '  [whitespace/parens] [5]')
1622         self.assert_lint('for (foo; ba; bar ) {', 'Extra space before ) in for'
1623                          '  [whitespace/parens] [5]')
1624         self.assert_lint('for ((foo); (ba); (bar) ) {', 'Extra space before ) in for'
1625                          '  [whitespace/parens] [5]')
1626         self.assert_lint('for (; foo; bar) {', '')
1627         self.assert_lint('for (; (foo); (bar)) {', '')
1628         self.assert_lint('for ( ; foo; bar) {', '')
1629         self.assert_lint('for ( ; (foo); (bar)) {', '')
1630         self.assert_lint('for ( ; foo; bar ) {', 'Extra space before ) in for'
1631                          '  [whitespace/parens] [5]')
1632         self.assert_lint('for ( ; (foo); (bar) ) {', 'Extra space before ) in for'
1633                          '  [whitespace/parens] [5]')
1634         self.assert_lint('for (foo; bar; ) {', '')
1635         self.assert_lint('for ((foo); (bar); ) {', '')
1636         self.assert_lint('while (  foo) {', 'Extra space after ( in while'
1637                          '  [whitespace/parens] [5]')
1638
1639     def test_spacing_for_fncall(self):
1640         self.assert_lint('if (foo) {', '')
1641         self.assert_lint('for (foo;bar;baz) {', '')
1642         self.assert_lint('while (foo) {', '')
1643         self.assert_lint('switch (foo) {', '')
1644         self.assert_lint('new (RenderArena()) RenderInline(document())', '')
1645         self.assert_lint('foo( bar)', 'Extra space after ( in function call'
1646                          '  [whitespace/parens] [4]')
1647         self.assert_lint('foobar( \\', '')
1648         self.assert_lint('foobar(     \\', '')
1649         self.assert_lint('( a + b)', 'Extra space after ('
1650                          '  [whitespace/parens] [2]')
1651         self.assert_lint('((a+b))', '')
1652         self.assert_lint('foo (foo)', 'Extra space before ( in function call'
1653                          '  [whitespace/parens] [4]')
1654         self.assert_lint('@property (readonly) NSUInteger count;', '')
1655         self.assert_lint('#elif (foo(bar))', '')
1656         self.assert_lint('#elif (foo(bar) && foo(baz))', '')
1657         self.assert_lint('typedef foo (*foo)(foo)', '')
1658         self.assert_lint('typedef foo (*foo12bar_)(foo)', '')
1659         self.assert_lint('typedef foo (Foo::*bar)(foo)', '')
1660         self.assert_lint('foo (Foo::*bar)(',
1661                          'Extra space before ( in function call'
1662                          '  [whitespace/parens] [4]')
1663         self.assert_lint('typedef foo (Foo::*bar)(', '')
1664         self.assert_lint('(foo)(bar)', '')
1665         self.assert_lint('Foo (*foo)(bar)', '')
1666         self.assert_lint('Foo (*foo)(Bar bar,', '')
1667         self.assert_lint('char (*p)[sizeof(foo)] = &foo', '')
1668         self.assert_lint('char (&ref)[sizeof(foo)] = &foo', '')
1669         self.assert_lint('const char32 (*table[])[6];', '')
1670         self.assert_lint('@interface Foo (Category)', '')
1671         self.assert_lint('@interface Foo ()', '')
1672         self.assert_lint('@implementation Foo (Category)', '')
1673         self.assert_lint('@implementation Foo ()', '')
1674
1675     def test_spacing_before_braces(self):
1676         self.assert_lint('if (foo){', 'Missing space before {'
1677                          '  [whitespace/braces] [5]')
1678         self.assert_lint('for{', 'Missing space before {'
1679                          '  [whitespace/braces] [5]')
1680         self.assert_lint('for {', '')
1681         self.assert_lint('EXPECT_DEBUG_DEATH({', '')
1682
1683     def test_spacing_between_braces(self):
1684         self.assert_lint('    { }', '')
1685         self.assert_lint('    {}', 'Missing space inside { }.  [whitespace/braces] [5]')
1686         self.assert_lint('    {   }', 'Too many spaces inside { }.  [whitespace/braces] [5]')
1687
1688     def test_spacing_around_else(self):
1689         self.assert_lint('}else {', 'Missing space before else'
1690                          '  [whitespace/braces] [5]')
1691         self.assert_lint('} else{', 'Missing space before {'
1692                          '  [whitespace/braces] [5]')
1693         self.assert_lint('} else {', '')
1694         self.assert_lint('} else if', '')
1695
1696     def test_spacing_for_binary_ops(self):
1697         self.assert_lint('if (foo<=bar) {', 'Missing spaces around <='
1698                          '  [whitespace/operators] [3]')
1699         self.assert_lint('if (foo<bar) {', 'Missing spaces around <'
1700                          '  [whitespace/operators] [3]')
1701         self.assert_lint('if (foo<bar->baz) {', 'Missing spaces around <'
1702                          '  [whitespace/operators] [3]')
1703         self.assert_lint('if (foo<bar->bar) {', 'Missing spaces around <'
1704                          '  [whitespace/operators] [3]')
1705         self.assert_lint('typedef hash_map<Foo, Bar', 'Missing spaces around <'
1706                          '  [whitespace/operators] [3]')
1707         self.assert_lint('typedef hash_map<FoooooType, BaaaaarType,', '')
1708         self.assert_lint('a<Foo> t+=b;', 'Missing spaces around +='
1709                          '  [whitespace/operators] [3]')
1710         self.assert_lint('a<Foo> t-=b;', 'Missing spaces around -='
1711                          '  [whitespace/operators] [3]')
1712         self.assert_lint('a<Foo*> t*=b;', 'Missing spaces around *='
1713                          '  [whitespace/operators] [3]')
1714         self.assert_lint('a<Foo*> t/=b;', 'Missing spaces around /='
1715                          '  [whitespace/operators] [3]')
1716         self.assert_lint('a<Foo*> t|=b;', 'Missing spaces around |='
1717                          '  [whitespace/operators] [3]')
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|c;', 'Missing spaces around >>='
1725                          '  [whitespace/operators] [3]')
1726         self.assert_lint('a<Foo*> t<<=*b/c;', 'Missing spaces around <<='
1727                          '  [whitespace/operators] [3]')
1728         self.assert_lint('a<Foo> t -= b;', '')
1729         self.assert_lint('a<Foo> t += b;', '')
1730         self.assert_lint('a<Foo*> t *= b;', '')
1731         self.assert_lint('a<Foo*> t /= b;', '')
1732         self.assert_lint('a<Foo*> t |= b;', '')
1733         self.assert_lint('a<Foo*> t &= b;', '')
1734         self.assert_lint('a<Foo*> t <<= b;', '')
1735         self.assert_lint('a<Foo*> t >>= b;', '')
1736         self.assert_lint('a<Foo*> t >>= &b|c;', 'Missing spaces around |'
1737                          '  [whitespace/operators] [3]')
1738         self.assert_lint('a<Foo*> t <<= *b/c;', 'Missing spaces around /'
1739                          '  [whitespace/operators] [3]')
1740         self.assert_lint('a<Foo*> t <<= b/c; //Test', [
1741                          'Should have a space between // and comment  '
1742                          '[whitespace/comments] [4]', 'Missing'
1743                          ' spaces around /  [whitespace/operators] [3]'])
1744         self.assert_lint('a<Foo*> t <<= b||c;  //Test', ['One space before end'
1745                          ' of line comments  [whitespace/comments] [5]',
1746                          'Should have a space between // and comment  '
1747                          '[whitespace/comments] [4]',
1748                          'Missing spaces around ||  [whitespace/operators] [3]'])
1749         self.assert_lint('a<Foo*> t <<= b||c; // Test', 'Missing spaces around'
1750                          ' ||  [whitespace/operators] [3]')
1751         self.assert_lint('a<Foo*> t <<= b||&c; // Test', 'Missing spaces around'
1752                          ' ||  [whitespace/operators] [3]')
1753         self.assert_lint('a<Foo*> t <<= b||*c; // Test', 'Missing spaces around'
1754                          ' ||  [whitespace/operators] [3]')
1755         self.assert_lint('a<Foo*> t <<= b && *c; // Test', '')
1756         self.assert_lint('a<Foo*> t <<= b && &c; // Test', '')
1757         self.assert_lint('a<Foo*> t <<= b || &c;  /*Test', 'Complex multi-line '
1758                          '/*...*/-style comment found. Lint may give bogus '
1759                          'warnings.  Consider replacing these with //-style'
1760                          ' comments, with #if 0...#endif, or with more clearly'
1761                          ' structured multi-line comments.  [readability/multiline_comment] [5]')
1762         self.assert_lint('a<Foo&> t <<= &b | &c;', '')
1763         self.assert_lint('a<Foo*> t <<= &b & &c; // Test', '')
1764         self.assert_lint('a<Foo*> t <<= *b / &c; // Test', '')
1765         self.assert_lint('if (a=b == 1)', 'Missing spaces around =  [whitespace/operators] [4]')
1766         self.assert_lint('if (a = b == 1)', '')
1767         self.assert_multi_line_lint('#include <sys/io.h>\n', '')
1768         self.assert_multi_line_lint('#import <foo/bar.h>\n', '')
1769         self.assert_multi_line_lint('#if __has_include(<ApplicationServices/ApplicationServicesPriv.h>)\n', '')
1770         self.assert_lint('Foo&& a = bar();', '')
1771
1772     def test_operator_methods(self):
1773         self.assert_lint('String operator+(const String&, const String&);', '')
1774         self.assert_lint('String operator/(const String&, const String&);', '')
1775         self.assert_lint('bool operator==(const String&, const String&);', '')
1776         self.assert_lint('String& operator-=(const String&, const String&);', '')
1777         self.assert_lint('String& operator+=(const String&, const String&);', '')
1778         self.assert_lint('String& operator*=(const String&, const String&);', '')
1779         self.assert_lint('String& operator%=(const String&, const String&);', '')
1780         self.assert_lint('String& operator&=(const String&, const String&);', '')
1781         self.assert_lint('String& operator<<=(const String&, const String&);', '')
1782         self.assert_lint('String& operator>>=(const String&, const String&);', '')
1783         self.assert_lint('String& operator|=(const String&, const String&);', '')
1784         self.assert_lint('String& operator^=(const String&, const String&);', '')
1785
1786     def test_spacing_before_last_semicolon(self):
1787         self.assert_lint('call_function() ;',
1788                          'Extra space before last semicolon. If this should be an '
1789                          'empty statement, use { } instead.'
1790                          '  [whitespace/semicolon] [5]')
1791         self.assert_lint('while (true) ;',
1792                          'Extra space before last semicolon. If this should be an '
1793                          'empty statement, use { } instead.'
1794                          '  [whitespace/semicolon] [5]')
1795         self.assert_lint('default:;',
1796                          'Semicolon defining empty statement. Use { } instead.'
1797                          '  [whitespace/semicolon] [5]')
1798         self.assert_lint('        ;',
1799                          'Line contains only semicolon. If this should be an empty '
1800                          'statement, use { } instead.'
1801                          '  [whitespace/semicolon] [5]')
1802         self.assert_lint('for (int i = 0; ;', '')
1803
1804     # Static or global STL strings.
1805     def test_static_or_global_stlstrings(self):
1806         self.assert_lint('string foo;',
1807                          'For a static/global string constant, use a C style '
1808                          'string instead: "char foo[]".'
1809                          '  [runtime/string] [4]')
1810         self.assert_lint('string kFoo = "hello"; // English',
1811                          'For a static/global string constant, use a C style '
1812                          'string instead: "char kFoo[]".'
1813                          '  [runtime/string] [4]')
1814         self.assert_lint('static string foo;',
1815                          'For a static/global string constant, use a C style '
1816                          'string instead: "static char foo[]".'
1817                          '  [runtime/string] [4]')
1818         self.assert_lint('static const string foo;',
1819                          'For a static/global string constant, use a C style '
1820                          'string instead: "static const char foo[]".'
1821                          '  [runtime/string] [4]')
1822         self.assert_lint('string Foo::bar;',
1823                          'For a static/global string constant, use a C style '
1824                          'string instead: "char Foo::bar[]".'
1825                          '  [runtime/string] [4]')
1826         # Rare case.
1827         self.assert_lint('string foo("foobar");',
1828                          'For a static/global string constant, use a C style '
1829                          'string instead: "char foo[]".'
1830                          '  [runtime/string] [4]')
1831         # Should not catch local or member variables.
1832         self.assert_lint('    string foo', '')
1833         # Should not catch functions.
1834         self.assert_lint('string EmptyString() { return ""; }', '')
1835         self.assert_lint('string EmptyString () { return ""; }', '')
1836         self.assert_lint('string VeryLongNameFunctionSometimesEndsWith(\n'
1837                          '    VeryLongNameType veryLongNameVariable) { }', '')
1838         self.assert_lint('template<>\n'
1839                          'string FunctionTemplateSpecialization<SomeType>(\n'
1840                          '    int x) { return ""; }', '')
1841         self.assert_lint('template<>\n'
1842                          'string FunctionTemplateSpecialization<vector<A::B>* >(\n'
1843                          '    int x) { return ""; }', '')
1844
1845         # should not catch methods of template classes.
1846         self.assert_lint('string Class<Type>::Method() const\n'
1847                          '{\n'
1848                          '    return "";\n'
1849                          '}\n', '')
1850         self.assert_lint('string Class<Type>::Method(\n'
1851                          '    int arg) const\n'
1852                          '{\n'
1853                          '    return "";\n'
1854                          '}\n', '')
1855
1856     def test_no_spaces_in_function_calls(self):
1857         self.assert_lint('TellStory(1, 3);',
1858                          '')
1859         self.assert_lint('TellStory(1, 3 );',
1860                          'Extra space before )'
1861                          '  [whitespace/parens] [2]')
1862         self.assert_lint('TellStory(1 /* wolf */, 3 /* pigs */);',
1863                          '')
1864         self.assert_multi_line_lint('#endif\n    );',
1865                                     '')
1866
1867     def test_one_spaces_between_code_and_comments(self):
1868         self.assert_lint('} // namespace foo',
1869                          '')
1870         self.assert_lint('}// namespace foo',
1871                          'One space before end of line comments'
1872                          '  [whitespace/comments] [5]')
1873         self.assert_lint('printf("foo"); // Outside quotes.',
1874                          '')
1875         self.assert_lint('int i = 0; // Having one space is fine.','')
1876         self.assert_lint('int i = 0;  // Having two spaces is bad.',
1877                          'One space before end of line comments'
1878                          '  [whitespace/comments] [5]')
1879         self.assert_lint('int i = 0;   // Having three spaces is bad.',
1880                          'One space before end of line comments'
1881                          '  [whitespace/comments] [5]')
1882         self.assert_lint('// Top level comment', '')
1883         self.assert_lint('    // Line starts with four spaces.', '')
1884         self.assert_lint('foo();\n'
1885                          '{ // A scope is opening.', '')
1886         self.assert_lint('    foo();\n'
1887                          '    { // An indented scope is opening.', '')
1888         self.assert_lint('if (foo) { // not a pure scope',
1889                          '')
1890         self.assert_lint('printf("// In quotes.")', '')
1891         self.assert_lint('printf("\\"%s // In quotes.")', '')
1892         self.assert_lint('printf("%s", "// In quotes.")', '')
1893
1894     def test_one_spaces_after_punctuation_in_comments(self):
1895         self.assert_lint('int a; // This is a sentence.',
1896                          '')
1897         self.assert_lint('int a; // This is a sentence.  ',
1898                          'Line ends in whitespace.  Consider deleting these extra spaces.  [whitespace/end_of_line] [4]')
1899         self.assert_lint('int a; // This is a sentence. This is a another sentence.',
1900                          '')
1901         self.assert_lint('int a; // This is a sentence.  This is a another sentence.',
1902                          'Should have only a single space after a punctuation in a comment.  [whitespace/comments] [5]')
1903         self.assert_lint('int a; // This is a sentence!  This is a another sentence.',
1904                          'Should have only a single space after a punctuation in a comment.  [whitespace/comments] [5]')
1905         self.assert_lint('int a; // Why did I write this?  This is a another sentence.',
1906                          'Should have only a single space after a punctuation in a comment.  [whitespace/comments] [5]')
1907         self.assert_lint('int a; // Elementary,  my dear.',
1908                          'Should have only a single space after a punctuation in a comment.  [whitespace/comments] [5]')
1909         self.assert_lint('int a; // The following should be clear:  Is it?',
1910                          'Should have only a single space after a punctuation in a comment.  [whitespace/comments] [5]')
1911         self.assert_lint('int a; // Look at the follow semicolon;  I hope this gives an error.',
1912                          'Should have only a single space after a punctuation in a comment.  [whitespace/comments] [5]')
1913
1914     def test_space_after_comment_marker(self):
1915         self.assert_lint('//', '')
1916         self.assert_lint('//x', 'Should have a space between // and comment'
1917                          '  [whitespace/comments] [4]')
1918         self.assert_lint('// x', '')
1919         self.assert_lint('//----', '')
1920         self.assert_lint('//====', '')
1921         self.assert_lint('//////', '')
1922         self.assert_lint('////// x', '')
1923         self.assert_lint('/// x', '')
1924         self.assert_lint('////x', 'Should have a space between // and comment'
1925                          '  [whitespace/comments] [4]')
1926
1927     def test_newline_at_eof(self):
1928         def do_test(self, data, is_missing_eof):
1929             error_collector = ErrorCollector(self.assertTrue)
1930             self.process_file_data('foo.cpp', 'cpp', data.split('\n'),
1931                                    error_collector)
1932             # The warning appears only once.
1933             self.assertEqual(
1934                 int(is_missing_eof),
1935                 error_collector.results().count(
1936                     'Could not find a newline character at the end of the file.'
1937                     '  [whitespace/ending_newline] [5]'))
1938
1939         do_test(self, '// Newline\n// at EOF\n', False)
1940         do_test(self, '// Newline2\n\n// at EOF\n', False)
1941         do_test(self, '// No newline\n// at EOF', True)
1942         do_test(self, '// No newline2\n\n// at EOF', True)
1943
1944     def test_extra_newlines_at_eof(self):
1945         def do_test(self, data, too_many_newlines):
1946             error_collector = ErrorCollector(self.assertTrue)
1947             self.process_file_data('foo.cpp', 'cpp', data.split('\n'),
1948                                    error_collector)
1949             # The warning appears only once.
1950             self.assertEqual(
1951                 int(too_many_newlines),
1952                 error_collector.results().count(
1953                     'There was more than one newline at the end of the file.'
1954                     '  [whitespace/ending_newline] [5]'))
1955
1956         do_test(self, '// No Newline\n// at EOF', False)
1957         do_test(self, '// No Newline2\n\n// at EOF', False)
1958         do_test(self, '// One Newline\n// at EOF\n', False)
1959         do_test(self, '// One Newline2\n\n// at EOF\n', False)
1960         do_test(self, '// Two Newlines\n// at EOF\n\n', True)
1961         do_test(self, '// Three Newlines\n// at EOF\n\n\n', True)
1962
1963     def test_invalid_utf8(self):
1964         def do_test(self, raw_bytes, has_invalid_utf8):
1965             error_collector = ErrorCollector(self.assertTrue)
1966             self.process_file_data('foo.cpp', 'cpp',
1967                                    unicode(raw_bytes, 'utf8', 'replace').split('\n'),
1968                                    error_collector)
1969             # The warning appears only once.
1970             self.assertEqual(
1971                 int(has_invalid_utf8),
1972                 error_collector.results().count(
1973                     'Line contains invalid UTF-8'
1974                     ' (or Unicode replacement character).'
1975                     '  [readability/utf8] [5]'))
1976
1977         do_test(self, 'Hello world\n', False)
1978         do_test(self, '\xe9\x8e\xbd\n', False)
1979         do_test(self, '\xe9x\x8e\xbd\n', True)
1980         # This is the encoding of the replacement character itself (which
1981         # you can see by evaluating codecs.getencoder('utf8')(u'\ufffd')).
1982         do_test(self, '\xef\xbf\xbd\n', True)
1983
1984     def test_is_blank_line(self):
1985         self.assertTrue(cpp_style.is_blank_line(''))
1986         self.assertTrue(cpp_style.is_blank_line(' '))
1987         self.assertTrue(cpp_style.is_blank_line(' \t\r\n'))
1988         self.assertTrue(not cpp_style.is_blank_line('int a;'))
1989         self.assertTrue(not cpp_style.is_blank_line('{'))
1990
1991     def test_blank_lines_check(self):
1992         self.assert_blank_lines_check(['{\n', '\n', '\n', '}\n'], 1, 1)
1993         self.assert_blank_lines_check(['  if (foo) {\n', '\n', '  }\n'], 1, 1)
1994         self.assert_blank_lines_check(
1995             ['\n', '// {\n', '\n', '\n', '// Comment\n', '{\n', '}\n'], 0, 0)
1996         self.assert_blank_lines_check(['\n', 'run("{");\n', '\n'], 0, 0)
1997         self.assert_blank_lines_check(['\n', '  if (foo) { return 0; }\n', '\n'], 0, 0)
1998
1999     def test_allow_blank_line_before_closing_namespace(self):
2000         error_collector = ErrorCollector(self.assertTrue)
2001         self.process_file_data('foo.cpp', 'cpp',
2002                                ['namespace {', '', '}  // namespace'],
2003                                error_collector)
2004         self.assertEqual(0, error_collector.results().count(
2005             'Blank line at the end of a code block.  Is this needed?'
2006             '  [whitespace/blank_line] [3]'))
2007
2008     def test_allow_blank_line_before_if_else_chain(self):
2009         error_collector = ErrorCollector(self.assertTrue)
2010         self.process_file_data('foo.cpp', 'cpp',
2011                                ['if (hoge) {',
2012                                 '',  # No warning
2013                                 '} else if (piyo) {',
2014                                 '',  # No warning
2015                                 '} else if (piyopiyo) {',
2016                                 '  hoge = true;',  # No warning
2017                                 '} else {',
2018                                 '',  # Warning on this line
2019                                 '}'],
2020                                error_collector)
2021         self.assertEqual(1, error_collector.results().count(
2022             'Blank line at the end of a code block.  Is this needed?'
2023             '  [whitespace/blank_line] [3]'))
2024
2025     def test_else_on_same_line_as_closing_braces(self):
2026         error_collector = ErrorCollector(self.assertTrue)
2027         self.process_file_data('foo.cpp', 'cpp',
2028                                ['if (hoge) {',
2029                                 '',
2030                                 '}',
2031                                 ' else {'  # Warning on this line
2032                                 '',
2033                                 '}'],
2034                                error_collector)
2035         self.assertEqual(1, error_collector.results().count(
2036             'An else should appear on the same line as the preceding }'
2037             '  [whitespace/newline] [4]'))
2038
2039     def test_else_clause_not_on_same_line_as_else(self):
2040         self.assert_lint('    else DoSomethingElse();',
2041                          'Else clause should never be on same line as else '
2042                          '(use 2 lines)  [whitespace/newline] [4]')
2043         self.assert_lint('    else ifDoSomethingElse();',
2044                          'Else clause should never be on same line as else '
2045                          '(use 2 lines)  [whitespace/newline] [4]')
2046         self.assert_lint('    else if (blah) {', '')
2047         self.assert_lint('    variable_ends_in_else = true;', '')
2048
2049     def test_comma(self):
2050         self.assert_lint('a = f(1,2);',
2051                          'Missing space after ,  [whitespace/comma] [3]')
2052         self.assert_lint('int tmp=a,a=b,b=tmp;',
2053                          ['Missing spaces around =  [whitespace/operators] [4]',
2054                           'Missing space after ,  [whitespace/comma] [3]'])
2055         self.assert_lint('f(a, /* name */ b);', '')
2056         self.assert_lint('f(a, /* name */b);', '')
2057
2058     def test_declaration(self):
2059         self.assert_lint('int a;', '')
2060         self.assert_lint('int   a;', 'Extra space between int and a  [whitespace/declaration] [3]')
2061         self.assert_lint('int*  a;', 'Extra space between int* and a  [whitespace/declaration] [3]')
2062         self.assert_lint('else if { }', '')
2063         self.assert_lint('else   if { }', 'Extra space between else and if  [whitespace/declaration] [3]')
2064
2065     def test_pointer_reference_marker_location(self):
2066         self.assert_lint('int* b;', '', 'foo.cpp')
2067         self.assert_lint('int *b;',
2068                          'Declaration has space between type name and * in int *b  [whitespace/declaration] [3]',
2069                          'foo.cpp')
2070         self.assert_lint('int * b;',
2071                          'Declaration has space between type name and * in int * b  [whitespace/declaration] [3]',
2072                          'foo.cpp')
2073         self.assert_lint('return *b;', '', 'foo.cpp')
2074         self.assert_lint('return a * b;', '', 'foo.cpp')
2075         self.assert_lint('delete *b;', '', 'foo.cpp')
2076         self.assert_lint('int *b;', '', 'foo.c')
2077         self.assert_lint('int* b;',
2078                          'Declaration has space between * and variable name in int* b  [whitespace/declaration] [3]',
2079                          'foo.c')
2080         self.assert_lint('int& b;', '', 'foo.cpp')
2081         self.assert_lint('int &b;',
2082                          'Declaration has space between type name and & in int &b  [whitespace/declaration] [3]',
2083                          'foo.cpp')
2084         self.assert_lint('return &b;', '', 'foo.cpp')
2085         self.assert_lint('*foo = bar;', '', 'foo.cpp')
2086
2087     def test_indent(self):
2088         self.assert_lint('static int noindent;', '')
2089         self.assert_lint('    int fourSpaceIndent;', '')
2090         self.assert_lint(' int oneSpaceIndent;',
2091                          'Weird number of spaces at line-start.  '
2092                          'Are you using a 4-space indent?  [whitespace/indent] [3]')
2093         self.assert_lint('   int threeSpaceIndent;',
2094                          'Weird number of spaces at line-start.  '
2095                          'Are you using a 4-space indent?  [whitespace/indent] [3]')
2096         self.assert_lint(' char* oneSpaceIndent = "public:";',
2097                          'Weird number of spaces at line-start.  '
2098                          'Are you using a 4-space indent?  [whitespace/indent] [3]')
2099         self.assert_lint(' public:',
2100                          'Weird number of spaces at line-start.  '
2101                          'Are you using a 4-space indent?  [whitespace/indent] [3]')
2102         self.assert_lint('  public:',
2103                          'Weird number of spaces at line-start.  '
2104                          'Are you using a 4-space indent?  [whitespace/indent] [3]')
2105         self.assert_lint('   public:',
2106                          'Weird number of spaces at line-start.  '
2107                          'Are you using a 4-space indent?  [whitespace/indent] [3]')
2108         self.assert_multi_line_lint(
2109             'class Foo {\n'
2110             'public:\n'
2111             '    enum Bar {\n'
2112             '        Alpha,\n'
2113             '        Beta,\n'
2114             '#if ENABLED_BETZ\n'
2115             '        Charlie,\n'
2116             '#endif\n'
2117             '    };\n'
2118             '};',
2119             '')
2120
2121     def test_not_alabel(self):
2122         self.assert_lint('MyVeryLongNamespace::MyVeryLongClassName::', '')
2123
2124     def test_tab(self):
2125         self.assert_lint('\tint a;',
2126                          'Tab found; better to use spaces  [whitespace/tab] [1]')
2127         self.assert_lint('int a = 5;\t// set a to 5',
2128                          'Tab found; better to use spaces  [whitespace/tab] [1]')
2129
2130     def test_unnamed_namespaces_in_headers(self):
2131         self.assert_language_rules_check(
2132             'foo.h', 'namespace {',
2133             'Do not use unnamed namespaces in header files.  See'
2134             ' http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Namespaces'
2135             ' for more information.  [build/namespaces] [4]')
2136         # namespace registration macros are OK.
2137         self.assert_language_rules_check('foo.h', 'namespace {  \\', '')
2138         # named namespaces are OK.
2139         self.assert_language_rules_check('foo.h', 'namespace foo {', '')
2140         self.assert_language_rules_check('foo.h', 'namespace foonamespace {', '')
2141         self.assert_language_rules_check('foo.cpp', 'namespace {', '')
2142         self.assert_language_rules_check('foo.cpp', 'namespace foo {', '')
2143
2144     def test_build_class(self):
2145         # Test that the linter can parse to the end of class definitions,
2146         # and that it will report when it can't.
2147         # Use multi-line linter because it performs the ClassState check.
2148         self.assert_multi_line_lint(
2149             'class Foo {',
2150             'Failed to find complete declaration of class Foo'
2151             '  [build/class] [5]')
2152         # Don't warn on forward declarations of various types.
2153         self.assert_multi_line_lint(
2154             'class Foo;',
2155             '')
2156         self.assert_multi_line_lint(
2157             '''\
2158             struct Foo*
2159                 foo = NewFoo();''',
2160             '')
2161         # Here is an example where the linter gets confused, even though
2162         # the code doesn't violate the style guide.
2163         self.assert_multi_line_lint(
2164             'class Foo\n'
2165             '#ifdef DERIVE_FROM_GOO\n'
2166             '    : public Goo {\n'
2167             '#else\n'
2168             '    : public Hoo {\n'
2169             '#endif\n'
2170             '};',
2171             'Failed to find complete declaration of class Foo'
2172             '  [build/class] [5]')
2173
2174     def test_build_end_comment(self):
2175         # The crosstool compiler we currently use will fail to compile the
2176         # code in this test, so we might consider removing the lint check.
2177         self.assert_lint('#endif Not a comment',
2178                          'Uncommented text after #endif is non-standard.'
2179                          '  Use a comment.'
2180                          '  [build/endif_comment] [5]')
2181
2182     def test_build_forward_decl(self):
2183         # The crosstool compiler we currently use will fail to compile the
2184         # code in this test, so we might consider removing the lint check.
2185         self.assert_lint('class Foo::Goo;',
2186                          'Inner-style forward declarations are invalid.'
2187                          '  Remove this line.'
2188                          '  [build/forward_decl] [5]')
2189
2190     def test_build_header_guard(self):
2191         file_path = 'mydir/Foo.h'
2192
2193         # We can't rely on our internal stuff to get a sane path on the open source
2194         # side of things, so just parse out the suggested header guard. This
2195         # doesn't allow us to test the suggested header guard, but it does let us
2196         # test all the other header tests.
2197         error_collector = ErrorCollector(self.assertTrue)
2198         self.process_file_data(file_path, 'h', [], error_collector)
2199         expected_guard = ''
2200         matcher = re.compile(
2201             'No \#ifndef header guard found\, suggested CPP variable is\: ([A-Za-z_0-9]+) ')
2202         for error in error_collector.result_list():
2203             matches = matcher.match(error)
2204             if matches:
2205                 expected_guard = matches.group(1)
2206                 break
2207
2208         # Make sure we extracted something for our header guard.
2209         self.assertNotEqual(expected_guard, '')
2210
2211         # Wrong guard
2212         error_collector = ErrorCollector(self.assertTrue)
2213         self.process_file_data(file_path, 'h',
2214                                ['#ifndef FOO_H', '#define FOO_H'], error_collector)
2215         self.assertEqual(
2216             1,
2217             error_collector.result_list().count(
2218                 '#ifndef header guard has wrong style, please use: %s'
2219                 '  [build/header_guard] [5]' % expected_guard),
2220             error_collector.result_list())
2221
2222         # No define
2223         error_collector = ErrorCollector(self.assertTrue)
2224         self.process_file_data(file_path, 'h',
2225                                ['#ifndef %s' % expected_guard], error_collector)
2226         self.assertEqual(
2227             1,
2228             error_collector.result_list().count(
2229                 'No #ifndef header guard found, suggested CPP variable is: %s'
2230                 '  [build/header_guard] [5]' % expected_guard),
2231             error_collector.result_list())
2232
2233         # Mismatched define
2234         error_collector = ErrorCollector(self.assertTrue)
2235         self.process_file_data(file_path, 'h',
2236                                ['#ifndef %s' % expected_guard,
2237                                 '#define FOO_H'],
2238                                error_collector)
2239         self.assertEqual(
2240             1,
2241             error_collector.result_list().count(
2242                 'No #ifndef header guard found, suggested CPP variable is: %s'
2243                 '  [build/header_guard] [5]' % expected_guard),
2244             error_collector.result_list())
2245
2246         # No header guard errors
2247         error_collector = ErrorCollector(self.assertTrue)
2248         self.process_file_data(file_path, 'h',
2249                                ['#ifndef %s' % expected_guard,
2250                                 '#define %s' % expected_guard,
2251                                 '#endif // %s' % expected_guard],
2252                                error_collector)
2253         for line in error_collector.result_list():
2254             if line.find('build/header_guard') != -1:
2255                 self.fail('Unexpected error: %s' % line)
2256
2257         # Completely incorrect header guard
2258         error_collector = ErrorCollector(self.assertTrue)
2259         self.process_file_data(file_path, 'h',
2260                                ['#ifndef FOO',
2261                                 '#define FOO',
2262                                 '#endif  // FOO'],
2263                                error_collector)
2264         self.assertEqual(
2265             1,
2266             error_collector.result_list().count(
2267                 '#ifndef header guard has wrong style, please use: %s'
2268                 '  [build/header_guard] [5]' % expected_guard),
2269             error_collector.result_list())
2270
2271         # Special case for flymake
2272         error_collector = ErrorCollector(self.assertTrue)
2273         self.process_file_data('mydir/Foo_flymake.h', 'h',
2274                                ['#ifndef %s' % expected_guard,
2275                                 '#define %s' % expected_guard,
2276                                 '#endif // %s' % expected_guard],
2277                                error_collector)
2278         for line in error_collector.result_list():
2279             if line.find('build/header_guard') != -1:
2280                 self.fail('Unexpected error: %s' % line)
2281
2282         error_collector = ErrorCollector(self.assertTrue)
2283         self.process_file_data('mydir/Foo_flymake.h', 'h', [], error_collector)
2284         self.assertEqual(
2285             1,
2286             error_collector.result_list().count(
2287                 'No #ifndef header guard found, suggested CPP variable is: %s'
2288                 '  [build/header_guard] [5]' % expected_guard),
2289             error_collector.result_list())
2290
2291         # Verify that we don't blindly suggest the WTF prefix for all headers.
2292         self.assertFalse(expected_guard.startswith('WTF_'))
2293
2294         # Allow the WTF_ prefix for files in that directory.
2295         header_guard_filter = FilterConfiguration(('-', '+build/header_guard'))
2296         error_collector = ErrorCollector(self.assertTrue, header_guard_filter)
2297         self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h',
2298                                ['#ifndef WTF_TestName_h', '#define WTF_TestName_h'],
2299                                error_collector)
2300         self.assertEqual(0, len(error_collector.result_list()),
2301                           error_collector.result_list())
2302
2303         # Also allow the non WTF_ prefix for files in that directory.
2304         error_collector = ErrorCollector(self.assertTrue, header_guard_filter)
2305         self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h',
2306                                ['#ifndef TestName_h', '#define TestName_h'],
2307                                error_collector)
2308         self.assertEqual(0, len(error_collector.result_list()),
2309                           error_collector.result_list())
2310
2311         # Verify that we suggest the WTF prefix version.
2312         error_collector = ErrorCollector(self.assertTrue, header_guard_filter)
2313         self.process_file_data('Source/JavaScriptCore/wtf/TestName.h', 'h',
2314                                ['#ifndef BAD_TestName_h', '#define BAD_TestName_h'],
2315                                error_collector)
2316         self.assertEqual(
2317             1,
2318             error_collector.result_list().count(
2319                 '#ifndef header guard has wrong style, please use: WTF_TestName_h'
2320                 '  [build/header_guard] [5]'),
2321             error_collector.result_list())
2322
2323     def test_build_printf_format(self):
2324         self.assert_lint(
2325             r'printf("\%%d", value);',
2326             '%, [, (, and { are undefined character escapes.  Unescape them.'
2327             '  [build/printf_format] [3]')
2328
2329         self.assert_lint(
2330             r'snprintf(buffer, sizeof(buffer), "\[%d", value);',
2331             '%, [, (, and { are undefined character escapes.  Unescape them.'
2332             '  [build/printf_format] [3]')
2333
2334         self.assert_lint(
2335             r'fprintf(file, "\(%d", value);',
2336             '%, [, (, and { are undefined character escapes.  Unescape them.'
2337             '  [build/printf_format] [3]')
2338
2339         self.assert_lint(
2340             r'vsnprintf(buffer, sizeof(buffer), "\\\{%d", ap);',
2341             '%, [, (, and { are undefined character escapes.  Unescape them.'
2342             '  [build/printf_format] [3]')
2343
2344         # Don't warn if double-slash precedes the symbol
2345         self.assert_lint(r'printf("\\%%%d", value);',
2346                          '')
2347
2348     def test_runtime_printf_format(self):
2349         self.assert_lint(
2350             r'fprintf(file, "%q", value);',
2351             '%q in format strings is deprecated.  Use %ll instead.'
2352             '  [runtime/printf_format] [3]')
2353
2354         self.assert_lint(
2355             r'aprintf(file, "The number is %12q", value);',
2356             '%q in format strings is deprecated.  Use %ll instead.'
2357             '  [runtime/printf_format] [3]')
2358
2359         self.assert_lint(
2360             r'printf(file, "The number is" "%-12q", value);',
2361             '%q in format strings is deprecated.  Use %ll instead.'
2362             '  [runtime/printf_format] [3]')
2363
2364         self.assert_lint(
2365             r'printf(file, "The number is" "%+12q", value);',
2366             '%q in format strings is deprecated.  Use %ll instead.'
2367             '  [runtime/printf_format] [3]')
2368
2369         self.assert_lint(
2370             r'printf(file, "The number is" "% 12q", value);',
2371             '%q in format strings is deprecated.  Use %ll instead.'
2372             '  [runtime/printf_format] [3]')
2373
2374         self.assert_lint(
2375             r'snprintf(file, "Never mix %d and %1$d parmaeters!", value);',
2376             '%N$ formats are unconventional.  Try rewriting to avoid them.'
2377             '  [runtime/printf_format] [2]')
2378
2379     def assert_lintLogCodeOnError(self, code, expected_message):
2380         # Special assert_lint which logs the input code on error.
2381         result = self.perform_single_line_lint(code, 'foo.cpp')
2382         if result != expected_message:
2383             self.fail('For code: "%s"\nGot: "%s"\nExpected: "%s"'
2384                       % (code, result, expected_message))
2385
2386     def test_build_storage_class(self):
2387         qualifiers = [None, 'const', 'volatile']
2388         signs = [None, 'signed', 'unsigned']
2389         types = ['void', 'char', 'int', 'float', 'double',
2390                  'schar', 'int8', 'uint8', 'int16', 'uint16',
2391                  'int32', 'uint32', 'int64', 'uint64']
2392         storage_classes = ['auto', 'extern', 'register', 'static', 'typedef']
2393
2394         build_storage_class_error_message = (
2395             'Storage class (static, extern, typedef, etc) should be first.'
2396             '  [build/storage_class] [5]')
2397
2398         # Some explicit cases. Legal in C++, deprecated in C99.
2399         self.assert_lint('const int static foo = 5;',
2400                          build_storage_class_error_message)
2401
2402         self.assert_lint('char static foo;',
2403                          build_storage_class_error_message)
2404
2405         self.assert_lint('double const static foo = 2.0;',
2406                          build_storage_class_error_message)
2407
2408         self.assert_lint('uint64 typedef unsignedLongLong;',
2409                          build_storage_class_error_message)
2410
2411         self.assert_lint('int register foo = 0;',
2412                          build_storage_class_error_message)
2413
2414         # Since there are a very large number of possibilities, randomly
2415         # construct declarations.
2416         # Make sure that the declaration is logged if there's an error.
2417         # Seed generator with an integer for absolute reproducibility.
2418         random.seed(25)
2419         for unused_i in range(10):
2420             # Build up random list of non-storage-class declaration specs.
2421             other_decl_specs = [random.choice(qualifiers), random.choice(signs),
2422                                 random.choice(types)]
2423             # remove None
2424             other_decl_specs = filter(lambda x: x is not None, other_decl_specs)
2425
2426             # shuffle
2427             random.shuffle(other_decl_specs)
2428
2429             # insert storage class after the first
2430             storage_class = random.choice(storage_classes)
2431             insertion_point = random.randint(1, len(other_decl_specs))
2432             decl_specs = (other_decl_specs[0:insertion_point]
2433                           + [storage_class]
2434                           + other_decl_specs[insertion_point:])
2435
2436             self.assert_lintLogCodeOnError(
2437                 ' '.join(decl_specs) + ';',
2438                 build_storage_class_error_message)
2439
2440             # but no error if storage class is first
2441             self.assert_lintLogCodeOnError(
2442                 storage_class + ' ' + ' '.join(other_decl_specs),
2443                 '')
2444
2445     def test_legal_copyright(self):
2446         legal_copyright_message = (
2447             'No copyright message found.  '
2448             'You should have a line: "Copyright [year] <Copyright Owner>"'
2449             '  [legal/copyright] [5]')
2450
2451         copyright_line = '// Copyright 2008 Google Inc. All Rights Reserved.'
2452
2453         file_path = 'mydir/googleclient/foo.cpp'
2454
2455         # There should be a copyright message in the first 10 lines
2456         error_collector = ErrorCollector(self.assertTrue)
2457         self.process_file_data(file_path, 'cpp', [], error_collector)
2458         self.assertEqual(
2459             1,
2460             error_collector.result_list().count(legal_copyright_message))
2461
2462         error_collector = ErrorCollector(self.assertTrue)
2463         self.process_file_data(
2464             file_path, 'cpp',
2465             ['' for unused_i in range(10)] + [copyright_line],
2466             error_collector)
2467         self.assertEqual(
2468             1,
2469             error_collector.result_list().count(legal_copyright_message))
2470
2471         # Test that warning isn't issued if Copyright line appears early enough.
2472         error_collector = ErrorCollector(self.assertTrue)
2473         self.process_file_data(file_path, 'cpp', [copyright_line], error_collector)
2474         for message in error_collector.result_list():
2475             if message.find('legal/copyright') != -1:
2476                 self.fail('Unexpected error: %s' % message)
2477
2478         error_collector = ErrorCollector(self.assertTrue)
2479         self.process_file_data(
2480             file_path, 'cpp',
2481             ['' for unused_i in range(9)] + [copyright_line],
2482             error_collector)
2483         for message in error_collector.result_list():
2484             if message.find('legal/copyright') != -1:
2485                 self.fail('Unexpected error: %s' % message)
2486
2487     def test_invalid_increment(self):
2488         self.assert_lint('*count++;',
2489                          'Changing pointer instead of value (or unused value of '
2490                          'operator*).  [runtime/invalid_increment] [5]')
2491
2492     # Integral bitfields must be declared with either signed or unsigned keyword.
2493     def test_plain_integral_bitfields(self):
2494         errmsg = ('Please declare integral type bitfields with either signed or unsigned.  [runtime/bitfields] [5]')
2495
2496         self.assert_lint('int a : 30;', errmsg)
2497         self.assert_lint('mutable short a : 14;', errmsg)
2498         self.assert_lint('const char a : 6;', errmsg)
2499         self.assert_lint('long int a : 30;', errmsg)
2500         self.assert_lint('int a = 1 ? 0 : 30;', '')
2501
2502 class CleansedLinesTest(unittest.TestCase):
2503     def test_init(self):
2504         lines = ['Line 1',
2505                  'Line 2',
2506                  'Line 3 // Comment test',
2507                  'Line 4 "foo"']
2508
2509         clean_lines = cpp_style.CleansedLines(lines)
2510         self.assertEqual(lines, clean_lines.raw_lines)
2511         self.assertEqual(4, clean_lines.num_lines())
2512
2513         self.assertEqual(['Line 1',
2514                            'Line 2',
2515                            'Line 3 ',
2516                            'Line 4 "foo"'],
2517                           clean_lines.lines)
2518
2519         self.assertEqual(['Line 1',
2520                            'Line 2',
2521                            'Line 3 ',
2522                            'Line 4 ""'],
2523                           clean_lines.elided)
2524
2525     def test_init_empty(self):
2526         clean_lines = cpp_style.CleansedLines([])
2527         self.assertEqual([], clean_lines.raw_lines)
2528         self.assertEqual(0, clean_lines.num_lines())
2529
2530     def test_collapse_strings(self):
2531         collapse = cpp_style.CleansedLines.collapse_strings
2532         self.assertEqual('""', collapse('""'))             # ""     (empty)
2533         self.assertEqual('"""', collapse('"""'))           # """    (bad)
2534         self.assertEqual('""', collapse('"xyz"'))          # "xyz"  (string)
2535         self.assertEqual('""', collapse('"\\\""'))         # "\""   (string)
2536         self.assertEqual('""', collapse('"\'"'))           # "'"    (string)
2537         self.assertEqual('"\"', collapse('"\"'))           # "\"    (bad)
2538         self.assertEqual('""', collapse('"\\\\"'))         # "\\"   (string)
2539         self.assertEqual('"', collapse('"\\\\\\"'))        # "\\\"  (bad)
2540         self.assertEqual('""', collapse('"\\\\\\\\"'))     # "\\\\" (string)
2541
2542         self.assertEqual('\'\'', collapse('\'\''))         # ''     (empty)
2543         self.assertEqual('\'\'', collapse('\'a\''))        # 'a'    (char)
2544         self.assertEqual('\'\'', collapse('\'\\\'\''))     # '\''   (char)
2545         self.assertEqual('\'', collapse('\'\\\''))         # '\'    (bad)
2546         self.assertEqual('', collapse('\\012'))            # '\012' (char)
2547         self.assertEqual('', collapse('\\xfF0'))           # '\xfF0' (char)
2548         self.assertEqual('', collapse('\\n'))              # '\n' (char)
2549         self.assertEqual('\#', collapse('\\#'))            # '\#' (bad)
2550
2551         self.assertEqual('StringReplace(body, "", "");',
2552                           collapse('StringReplace(body, "\\\\", "\\\\\\\\");'))
2553         self.assertEqual('\'\' ""',
2554                           collapse('\'"\' "foo"'))
2555
2556
2557 class OrderOfIncludesTest(CppStyleTestBase):
2558     def setUp(self):
2559         self.include_state = cpp_style._IncludeState()
2560
2561         # Cheat os.path.abspath called in FileInfo class.
2562         self.os_path_abspath_orig = os.path.abspath
2563         self.os_path_isfile_orig = os.path.isfile
2564         os.path.abspath = lambda value: value
2565
2566     def tearDown(self):
2567         os.path.abspath = self.os_path_abspath_orig
2568         os.path.isfile = self.os_path_isfile_orig
2569
2570     def test_check_next_include_order__no_config(self):
2571         self.assertEqual('Header file should not contain WebCore config.h.',
2572                          self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, True, True))
2573
2574     def test_check_next_include_order__no_self(self):
2575         self.assertEqual('Header file should not contain itself.',
2576                          self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, True, True))
2577         # Test actual code to make sure that header types are correctly assigned.
2578         self.assert_language_rules_check('Foo.h',
2579                                          '#include "Foo.h"\n',
2580                                          'Header file should not contain itself. Should be: alphabetically sorted.'
2581                                          '  [build/include_order] [4]')
2582         self.assert_language_rules_check('FooBar.h',
2583                                          '#include "Foo.h"\n',
2584                                          '')
2585
2586     def test_check_next_include_order__likely_then_config(self):
2587         self.assertEqual('Found header this file implements before WebCore config.h.',
2588                          self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, False, True))
2589         self.assertEqual('Found WebCore config.h after a header this file implements.',
2590                          self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False, True))
2591
2592     def test_check_next_include_order__other_then_config(self):
2593         self.assertEqual('Found other header before WebCore config.h.',
2594                          self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False, True))
2595         self.assertEqual('Found WebCore config.h after other header.',
2596                          self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False, True))
2597
2598     def test_check_next_include_order__config_then_other_then_likely(self):
2599         self.assertEqual('', self.include_state.check_next_include_order(cpp_style._CONFIG_HEADER, False, True))
2600         self.assertEqual('Found other header before a header this file implements.',
2601                          self.include_state.check_next_include_order(cpp_style._OTHER_HEADER, False, True))
2602         self.assertEqual('Found header this file implements after other header.',
2603                          self.include_state.check_next_include_order(cpp_style._PRIMARY_HEADER, False, True))
2604
2605     def test_check_alphabetical_include_order(self):
2606         self.assert_language_rules_check('foo.h',
2607                                          '#include "a.h"\n'
2608                                          '#include "c.h"\n'
2609                                          '#include "b.h"\n',
2610                                          'Alphabetical sorting problem.  [build/include_order] [4]')
2611
2612         self.assert_language_rules_check('foo.h',
2613                                          '#include "a.h"\n'
2614                                          '#include "b.h"\n'
2615                                          '#include "c.h"\n',
2616                                          '')
2617
2618         self.assert_language_rules_check('foo.h',
2619                                          '#include <assert.h>\n'
2620                                          '#include "bar.h"\n',
2621                                          'Bad include order. Mixing system and custom headers.  [build/include_order] [4]')
2622
2623         self.assert_language_rules_check('foo.h',
2624                                          '#include "bar.h"\n'
2625                                          '#include <assert.h>\n',
2626                                          '')
2627
2628     def test_check_alphabetical_include_order_errors_reported_for_both_lines(self):
2629         # If one of the two lines of out of order headers are filtered, the error should be
2630         # reported on the other line.
2631         self.assert_language_rules_check('foo.h',
2632                                          '#include "a.h"\n'
2633                                          '#include "c.h"\n'
2634                                          '#include "b.h"\n',
2635                                          'Alphabetical sorting problem.  [build/include_order] [4]',
2636                                          lines_to_check=[2])
2637
2638         self.assert_language_rules_check('foo.h',
2639                                          '#include "a.h"\n'
2640                                          '#include "c.h"\n'
2641                                          '#include "b.h"\n',
2642                                          'Alphabetical sorting problem.  [build/include_order] [4]',
2643                                          lines_to_check=[3])
2644
2645         # If no lines are filtered, the error should be reported only once.
2646         self.assert_language_rules_check('foo.h',
2647                                          '#include "a.h"\n'
2648                                          '#include "c.h"\n'
2649                                          '#include "b.h"\n',
2650                                          'Alphabetical sorting problem.  [build/include_order] [4]')
2651
2652     def test_check_line_break_after_own_header(self):
2653         self.assert_language_rules_check('foo.cpp',
2654                                          '#include "config.h"\n'
2655                                          '#include "foo.h"\n'
2656                                          '#include "bar.h"\n',
2657                                          'You should add a blank line after implementation file\'s own header.  [build/include_order] [4]')
2658
2659         self.assert_language_rules_check('foo.cpp',
2660                                          '#include "config.h"\n'
2661                                          '#include "foo.h"\n'
2662                                          '\n'
2663                                          '#include "bar.h"\n',
2664                                          '')
2665
2666     def test_check_line_break_before_own_header(self):
2667         self.assert_language_rules_check('foo.cpp',
2668                                          '#include "config.h"\n'
2669                                          '\n'
2670                                          '#include "foo.h"\n'
2671                                          '\n'
2672                                          '#include "bar.h"\n',
2673                                          'You should not add a blank line before implementation file\'s own header.  [build/include_order] [4]')
2674
2675         self.assert_language_rules_check('foo.cpp',
2676                                          '#include "config.h"\n'
2677                                          '#include "foo.h"\n'
2678                                          '\n'
2679                                          '#include "bar.h"\n',
2680                                          '')
2681
2682     def test_check_preprocessor_in_include_section(self):
2683         self.assert_language_rules_check('foo.cpp',
2684                                          '#include "config.h"\n'
2685                                          '#include "foo.h"\n'
2686                                          '\n'
2687                                          '#ifdef BAZ\n'
2688                                          '#include "baz.h"\n'
2689                                          '#else\n'
2690                                          '#include "foobar.h"\n'
2691                                          '#endif"\n'
2692                                          '#include "bar.h"\n', # No flag because previous is in preprocessor section
2693                                          '')
2694
2695         self.assert_language_rules_check('foo.cpp',
2696                                          '#include "config.h"\n'
2697                                          '#include "foo.h"\n'
2698                                          '\n'
2699                                          '#ifdef BAZ\n'
2700                                          '#include "baz.h"\n'
2701                                          '#endif"\n'
2702                                          '#include "bar.h"\n'
2703                                          '#include "a.h"\n', # Should still flag this.
2704                                          'Alphabetical sorting problem.  [build/include_order] [4]')
2705
2706         self.assert_language_rules_check('foo.cpp',
2707                                          '#include "config.h"\n'
2708                                          '#include "foo.h"\n'
2709                                          '\n'
2710                                          '#ifdef BAZ\n'
2711                                          '#include "baz.h"\n'
2712                                          '#include "bar.h"\n' #Should still flag this
2713                                          '#endif"\n',
2714                                          'Alphabetical sorting problem.  [build/include_order] [4]')
2715
2716         self.assert_language_rules_check('foo.cpp',
2717                                          '#include "config.h"\n'
2718                                          '#include "foo.h"\n'
2719                                          '\n'
2720                                          '#ifdef BAZ\n'
2721                                          '#include "baz.h"\n'
2722                                          '#endif"\n'
2723                                          '#ifdef FOOBAR\n'
2724                                          '#include "foobar.h"\n'
2725                                          '#endif"\n'
2726                                          '#include "bar.h"\n'
2727                                          '#include "a.h"\n', # Should still flag this.
2728                                          'Alphabetical sorting problem.  [build/include_order] [4]')
2729
2730         # Check that after an already included error, the sorting rules still work.
2731         self.assert_language_rules_check('foo.cpp',
2732                                          '#include "config.h"\n'
2733                                          '#include "foo.h"\n'
2734                                          '\n'
2735                                          '#include "foo.h"\n'
2736                                          '#include "g.h"\n',
2737                                          '"foo.h" already included at foo.cpp:2  [build/include] [4]')
2738
2739     def test_primary_header(self):
2740         # File with non-existing primary header should not produce errors.
2741         self.assert_language_rules_check('foo.cpp',
2742                                          '#include "config.h"\n'
2743                                          '\n'
2744                                          '#include "bar.h"\n',
2745                                          '')
2746         # Pretend that header files exist.
2747         os.path.isfile = lambda filename: True
2748         # Missing include for existing primary header -> error.
2749         self.assert_language_rules_check('foo.cpp',
2750                                          '#include "config.h"\n'
2751                                          '\n'
2752                                          '#include "bar.h"\n',
2753                                          'Found other header before a header this file implements. '
2754                                          'Should be: config.h, primary header, blank line, and then '
2755                                          'alphabetically sorted.  [build/include_order] [4]')
2756         # Having include for existing primary header -> no error.
2757         self.assert_language_rules_check('foo.cpp',
2758                                          '#include "config.h"\n'
2759                                          '#include "foo.h"\n'
2760                                          '\n'
2761                                          '#include "bar.h"\n',
2762                                          '')
2763
2764         os.path.isfile = self.os_path_isfile_orig
2765
2766     def test_public_primary_header(self):
2767         # System header is not considered a primary header.
2768         self.assert_language_rules_check('foo.cpp',
2769                                          '#include "config.h"\n'
2770                                          '#include <other/foo.h>\n'
2771                                          '\n'
2772                                          '#include "a.h"\n',
2773                                          'Bad include order. Mixing system and custom headers.  [build/include_order] [4]')
2774
2775         # ...except that it starts with public/.
2776         self.assert_language_rules_check('foo.cpp',
2777                                          '#include "config.h"\n'
2778                                          '#include <public/foo.h>\n'
2779                                          '\n'
2780                                          '#include "a.h"\n',
2781                                          '')
2782
2783         # Even if it starts with public/ its base part must match with the source file name.
2784         self.assert_language_rules_check('foo.cpp',
2785                                          '#include "config.h"\n'
2786                                          '#include <public/foop.h>\n'
2787                                          '\n'
2788                                          '#include "a.h"\n',
2789                                          'Bad include order. Mixing system and custom headers.  [build/include_order] [4]')
2790
2791     def test_check_wtf_includes(self):
2792         self.assert_language_rules_check('foo.cpp',
2793                                          '#include "config.h"\n'
2794                                          '#include "foo.h"\n'
2795                                          '\n'
2796                                          '#include <wtf/Assertions.h>\n',
2797                                          '')
2798         self.assert_language_rules_check('foo.cpp',
2799                                          '#include "config.h"\n'
2800                                          '#include "foo.h"\n'
2801                                          '\n'
2802                                          '#include "wtf/Assertions.h"\n',
2803                                          'wtf includes should be <wtf/file.h> instead of "wtf/file.h".'
2804                                          '  [build/include] [4]')
2805
2806     def test_classify_include(self):
2807         classify_include = cpp_style._classify_include
2808         include_state = cpp_style._IncludeState()
2809         self.assertEqual(cpp_style._CONFIG_HEADER,
2810                          classify_include('foo/foo.cpp',
2811                                           'config.h',
2812                                           False, include_state))
2813         self.assertEqual(cpp_style._PRIMARY_HEADER,
2814                          classify_include('foo/internal/foo.cpp',
2815                                           'foo/public/foo.h',
2816                                           False, include_state))
2817         self.assertEqual(cpp_style._PRIMARY_HEADER,
2818                          classify_include('foo/internal/foo.cpp',
2819                                           'foo/other/public/foo.h',
2820                                           False, include_state))
2821         self.assertEqual(cpp_style._OTHER_HEADER,
2822                          classify_include('foo/internal/foo.cpp',
2823                       &