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