Lines Matching refs:self
60 def __init__(self, assert_fn): argument
62 self._assert_fn = assert_fn
63 self._errors = []
66 def __call__(self, unused_filename, linenum, argument
68 self._assert_fn(category in self._ERROR_CATEGORIES,
71 self._SEEN_ERROR_CATEGORIES[category] = 1
73 self._errors.append('%s [%s] [%d]' % (message, category, confidence))
75 def Results(self): argument
76 if len(self._errors) < 2:
77 return ''.join(self._errors) # Most tests expect to have a string.
79 return self._errors # Let's give a list if there is more than one.
81 def ResultList(self): argument
82 return self._errors
84 def VerifyAllCategoriesAreSeen(self): argument
93 for category in self._ERROR_CATEGORIES:
94 if category not in self._SEEN_ERROR_CATEGORIES:
97 def RemoveIfPresent(self, substr): argument
98 for (index, error) in enumerate(self._errors):
100 self._errors = self._errors[0:index] + self._errors[(index + 1):]
108 def __init__(self, mock_file): argument
109 self.mock_file = mock_file
111 def open(self, # pylint: disable-msg=C6409 argument
113 return self.mock_file
119 def setUp(self): argument
121 self.os_path_abspath_orig = os.path.abspath
123 def tearDown(self): argument
124 os.path.abspath = self.os_path_abspath_orig
127 def PerformSingleLineLint(self, code): argument
128 error_collector = ErrorCollector(self.assert_)
145 def PerformMultiLineLint(self, code): argument
146 error_collector = ErrorCollector(self.assert_)
162 def PerformLanguageRulesCheck(self, file_name, code): argument
163 error_collector = ErrorCollector(self.assert_)
175 def PerformFunctionLengthsCheck(self, code): argument
191 error_collector = ErrorCollector(self.assert_)
201 def PerformIncludeWhatYouUse(self, code, filename='foo.h', io=codecs): argument
203 error_collector = ErrorCollector(self.assert_)
222 def TestLint(self, code, expected_message): argument
223 self.assertEquals(expected_message, self.PerformSingleLineLint(code))
225 def TestMultiLineLint(self, code, expected_message): argument
226 self.assertEquals(expected_message, self.PerformMultiLineLint(code))
228 def TestMultiLineLintRE(self, code, expected_message_re): argument
229 message = self.PerformMultiLineLint(code)
231 self.fail('Message was:\n' + message + 'Expected match to "' +
234 def TestLanguageRulesCheck(self, file_name, code, expected_message): argument
235 self.assertEquals(expected_message,
236 self.PerformLanguageRulesCheck(file_name, code))
238 def TestIncludeWhatYouUse(self, code, expected_message): argument
239 self.assertEquals(expected_message,
240 self.PerformIncludeWhatYouUse(code))
242 def TestBlankLinesCheck(self, lines, start_errors, end_errors): argument
243 error_collector = ErrorCollector(self.assert_)
245 self.assertEquals(
250 self.assertEquals(
259 def GetNamespaceResults(self, lines): argument
260 error_collector = ErrorCollector(self.assert_)
271 def testForwardDeclarationNameSpaceIndentation(self): argument
276 results = self.GetNamespaceResults(lines)
277 self.assertEquals(results, 'Do not indent within a namespace '
280 def testNameSpaceIndentationForClass(self): argument
287 results = self.GetNamespaceResults(lines)
288 self.assertEquals(results, 'Do not indent within a namespace '
291 def testNameSpaceIndentationNoError(self): argument
296 results = self.GetNamespaceResults(lines)
297 self.assertEquals(results, '')
299 def testWhitespaceBeforeNamespace(self): argument
304 results = self.GetNamespaceResults(lines)
305 self.assertEquals(results, '')
307 def testFalsePositivesNoError(self): argument
315 results = self.GetNamespaceResults(lines)
316 self.assertEquals(results, '')
320 def testGetLineWidth(self): argument
321 self.assertEquals(0, cpplint.GetLineWidth(''))
322 self.assertEquals(10, cpplint.GetLineWidth(u'x' * 10))
323 self.assertEquals(16, cpplint.GetLineWidth(u'都|道|府|県|支庁'))
324 self.assertEquals(5 + 13 + 9, cpplint.GetLineWidth(
327 def testGetTextInside(self): argument
328 self.assertEquals('', cpplint._GetTextInside('fun()', r'fun\('))
329 self.assertEquals('x, y', cpplint._GetTextInside('f(x, y)', r'f\('))
330 self.assertEquals('a(), b(c())', cpplint._GetTextInside(
332 self.assertEquals('x, y{}', cpplint._GetTextInside('f[x, y{}]', r'f\['))
333 self.assertEquals(None, cpplint._GetTextInside('f[a, b(}]', r'f\['))
334 self.assertEquals(None, cpplint._GetTextInside('f[x, y]', r'f\('))
335 self.assertEquals('y, h(z, (a + b))', cpplint._GetTextInside(
337 self.assertEquals('f(f(x))', cpplint._GetTextInside('f(f(f(x)))', r'f\('))
339 self.assertEquals('\n return loop(x);\n',
343 self.assertEquals('x, y',
350 def testFindNextMultiLineCommentStart(self): argument
351 self.assertEquals(1, cpplint.FindNextMultiLineCommentStart([''], 0))
354 self.assertEquals(2, cpplint.FindNextMultiLineCommentStart(lines, 0))
357 self.assertEquals(1, cpplint.FindNextMultiLineCommentStart(lines, 0))
359 def testFindNextMultiLineCommentEnd(self): argument
360 self.assertEquals(1, cpplint.FindNextMultiLineCommentEnd([''], 0))
362 self.assertEquals(2, cpplint.FindNextMultiLineCommentEnd(lines, 0))
364 def testRemoveMultiLineCommentsFromRange(self): argument
367 self.assertEquals(['a', '/**/', '/**/', '/**/', 'b'], lines)
369 def testSpacesAtEndOfLine(self): argument
370 self.TestLint(
376 def testLineLengthCheck(self): argument
377 self.TestLint(
380 self.TestLint(
384 self.TestLint(
388 self.TestLint(
391 self.TestLint(
394 self.TestLint(
398 self.TestLint(
401 self.TestLint(
404 self.TestLint(
408 self.TestLint(
411 self.TestLint(
414 self.TestLint(
418 self.TestMultiLineLint(
422 self.TestMultiLineLint(
425 self.TestMultiLineLint(
430 self.TestMultiLineLint(
436 def testErrorSuppression(self): argument
438 self.TestLint(
446 self.TestLint(
451 self.TestLint('long a = (int64) 65; // NOLINT', '')
452 self.TestLint('long a = (int64) 65; // NOLINT(*)', '')
454 self.TestLint(
461 self.TestLint(
466 error_collector = ErrorCollector(self.assert_)
473 self.assertEquals('', error_collector.Results())
475 error_collector = ErrorCollector(self.assert_)
483 self.assertEquals('', error_collector.Results())
509 error_collector = ErrorCollector(self.assert_)
519 self.assertEquals('', error_collector.Results())
521 error_collector = ErrorCollector(self.assert_)
531 self.assertEquals('', error_collector.Results())
533 error_collector = ErrorCollector(self.assert_)
546 self.assertEquals('', error_collector.Results())
549 def testVariableDeclarations(self): argument
550 self.TestLint(
554 self.TestLint(
557 self.TestLint(
563 def testCStyleCast(self): argument
564 self.TestLint(
568 self.TestLint(
572 self.TestLint(
577 self.TestLint(
581 self.TestLint(
585 self.TestLint(
591 self.TestLint('u a = (u)NULL;', '')
592 self.TestLint('uint a = (uint)NULL;', '')
593 self.TestLint('typedef MockCallback<int(int)> CallbackType;', '')
594 self.TestLint('scoped_ptr< MockCallback<int(int)> > callback_value;', '')
595 self.TestLint('std::function<int(bool)>', '')
596 self.TestLint('x = sizeof(int)', '')
597 self.TestLint('x = alignof(int)', '')
598 self.TestLint('alignas(int) char x[42]', '')
599 self.TestLint('alignas(alignof(x)) char y[42]', '')
600 self.TestLint('void F(int (func)(int));', '')
601 self.TestLint('void F(int (func)(int*));', '')
602 self.TestLint('void F(int (Class::member)(int));', '')
603 self.TestLint('void F(int (Class::member)(int*));', '')
604 self.TestLint('void F(int (Class::member)(int), int param);', '')
605 self.TestLint('void F(int (Class::member)(int*), int param);', '')
608 self.TestLint('[](int/*unused*/) -> bool {', '')
609 self.TestLint('[](int /*unused*/) -> bool {', '')
610 self.TestLint('auto f = [](MyStruct* /*unused*/)->int {', '')
611 self.TestLint('[](int) -> bool {', '')
612 self.TestLint('auto f = [](MyStruct*)->int {', '')
615 self.TestLint('int64_t{4096} * 1000 * 1000', '')
616 self.TestLint('size_t{4096} * 1000 * 1000', '')
617 self.TestLint('uint_fast16_t{4096} * 1000 * 1000', '')
620 self.TestMultiLineLint(
629 self.TestMultiLineLint(
638 self.TestMultiLineLint(
647 self.TestMultiLineLint(
662 def testRuntimeCasting(self): argument
667 self.TestLint('int* x = &static_cast<int*>(foo);', error_msg)
668 self.TestLint('int* x = &reinterpret_cast<int *>(foo);', error_msg)
669 self.TestLint('int* x = &(int*)foo;',
673 self.TestLint('BudgetBuckets&(BudgetWinHistory::*BucketFn)(void) const;',
675 self.TestLint('&(*func_ptr)(arg)', '')
676 self.TestLint('Compute(arg, &(*func_ptr)(i, j));', '')
683 self.TestLint('int* x = &down_cast<Obj*>(obj)->member_;', alt_error_msg)
684 self.TestLint('int* x = &down_cast<Obj*>(obj)[index];', alt_error_msg)
685 self.TestLint('int* x = &(down_cast<Obj*>(obj)->member_);', '')
686 self.TestLint('int* x = &(down_cast<Obj*>(obj)[index]);', '')
687 self.TestLint('int* x = &down_cast<Obj*>(obj)\n->member_;', alt_error_msg)
688 self.TestLint('int* x = &(down_cast<Obj*>(obj)\n->member_);', '')
691 self.TestLint('int* x = reinterpret_cast<int *>(&foo);', '')
695 self.TestLint('auto x = implicit_cast<string &(*)(int)>(&foo);', '')
697 def testRuntimeSelfinit(self): argument
698 self.TestLint(
702 self.TestLint(
706 self.TestLint(
709 self.TestLint(
714 def testCheckForUnnamedParams(self): argument
715 self.TestLint('virtual void Func(int*) const;', '')
716 self.TestLint('virtual void Func(int*);', '')
717 self.TestLint('void Method(char*) {', '')
718 self.TestLint('void Method(char*);', '')
719 self.TestLint('static void operator delete[](void*) throw();', '')
720 self.TestLint('int Method(int);', '')
722 self.TestLint('virtual void Func(int* p);', '')
723 self.TestLint('void operator delete(void* x) throw();', '')
724 self.TestLint('void Method(char* x) {', '')
725 self.TestLint('void Method(char* /*x*/) {', '')
726 self.TestLint('void Method(char* x);', '')
727 self.TestLint('typedef void (*Method)(int32 x);', '')
728 self.TestLint('static void operator delete[](void* x) throw();', '')
729 self.TestLint('static void operator delete[](void* /*x*/) throw();', '')
731 self.TestLint('X operator++(int);', '')
732 self.TestLint('X operator++(int) {', '')
733 self.TestLint('X operator--(int);', '')
734 self.TestLint('X operator--(int /*unused*/) {', '')
735 self.TestLint('MACRO(int);', '')
736 self.TestLint('MACRO(func(int));', '')
737 self.TestLint('MACRO(arg, func(int));', '')
739 self.TestLint('void (*func)(void*);', '')
740 self.TestLint('void Func((*func)(void*)) {}', '')
741 self.TestLint('template <void Func(void*)> void func();', '')
742 self.TestLint('virtual void f(int /*unused*/) {', '')
743 self.TestLint('void f(int /*unused*/) override {', '')
744 self.TestLint('void f(int /*unused*/) final {', '')
747 def testDeprecatedCast(self): argument
748 self.TestLint(
754 self.TestLint(
760 self.TestLint(
767 self.TestLint('int a = int();', '') # constructor
768 self.TestLint('X::X() : a(int()) {}', '') # default constructor
769 self.TestLint('operator bool();', '') # Conversion operator
770 self.TestLint('new int64(123);', '') # "new" operator on basic type
771 self.TestLint('new int64(123);', '') # "new" operator on basic type
772 self.TestLint('new const int(42);', '') # "new" on const-qualified type
773 self.TestLint('using a = bool(int arg);', '') # C++11 alias-declaration
774 self.TestLint('x = bit_cast<double(*)[3]>(y);', '') # array of array
775 self.TestLint('void F(const char(&src)[N]);', '') # array of references
778 self.TestLint(
783 self.TestLint('std::function<int(bool)>', '')
784 self.TestLint('std::function<const int(bool)>', '')
785 self.TestLint('std::function< int(bool) >', '')
786 self.TestLint('mfunction<int(bool)>', '')
788 error_collector = ErrorCollector(self.assert_)
796 self.assertEquals('', error_collector.Results())
799 self.TestLint('typedef bool(FunctionPointer)();', '')
800 self.TestLint('typedef bool(FunctionPointer)(int param);', '')
801 self.TestLint('typedef bool(MyClass::*MemberFunctionPointer)();', '')
802 self.TestLint('typedef bool(MyClass::* MemberFunctionPointer)();', '')
803 self.TestLint('typedef bool(MyClass::*MemberFunctionPointer)() const;', '')
804 self.TestLint('void Function(bool(FunctionPointerArg)());', '')
805 self.TestLint('void Function(bool(FunctionPointerArg)()) {}', '')
806 self.TestLint('typedef set<int64, bool(*)(int64, int64)> SortedIdSet', '')
807 self.TestLint(
813 def testMockMethod(self): argument
814 self.TestLint(
817 self.TestLint(
820 self.TestLint(
823 self.TestLint(
827 error_collector = ErrorCollector(self.assert_)
840 self.assertEquals(
846 self.assertEquals(
855 def testMockCallback(self): argument
856 self.TestLint(
859 self.TestLint(
864 def testIncludeFilenameFalseError(self): argument
865 self.TestLint(
868 self.TestLint(
875 def testTypedefForPointerToFunction(self): argument
876 self.TestLint(
879 self.TestLint(
882 self.TestLint(
885 self.TestLint(
889 def testIncludeWhatYouUseNoImplementationFiles(self): argument
891 self.assertEquals('Add #include <vector> for vector<>'
893 self.PerformIncludeWhatYouUse(code, 'foo.h'))
894 self.assertEquals('',
895 self.PerformIncludeWhatYouUse(code, 'foo.cc'))
897 def testIncludeWhatYouUse(self): argument
898 self.TestIncludeWhatYouUse(
903 self.TestIncludeWhatYouUse(
909 self.TestIncludeWhatYouUse(
915 self.TestIncludeWhatYouUse(
921 self.TestIncludeWhatYouUse(
927 self.TestIncludeWhatYouUse(
932 self.TestIncludeWhatYouUse(
937 self.TestIncludeWhatYouUse(
942 self.TestIncludeWhatYouUse(
948 self.TestIncludeWhatYouUse(
954 self.TestIncludeWhatYouUse(
960 self.TestIncludeWhatYouUse(
966 self.TestIncludeWhatYouUse(
971 self.TestIncludeWhatYouUse(
977 self.TestIncludeWhatYouUse(
982 self.TestIncludeWhatYouUse(
985 self.TestIncludeWhatYouUse(
988 self.TestIncludeWhatYouUse(
991 self.TestIncludeWhatYouUse(
996 self.TestIncludeWhatYouUse(
1002 self.TestIncludeWhatYouUse(
1008 self.TestIncludeWhatYouUse(
1013 self.TestIncludeWhatYouUse(
1019 self.TestIncludeWhatYouUse(
1025 self.TestIncludeWhatYouUse(
1031 self.TestIncludeWhatYouUse(
1036 self.TestIncludeWhatYouUse(
1043 self.TestIncludeWhatYouUse(
1049 self.TestIncludeWhatYouUse(
1054 self.TestIncludeWhatYouUse(
1060 self.TestIncludeWhatYouUse(
1066 self.TestIncludeWhatYouUse(
1072 self.TestIncludeWhatYouUse(
1082 message = self.PerformIncludeWhatYouUse(
1086 self.assertEquals(message, '')
1089 message = self.PerformIncludeWhatYouUse(
1094 self.assertEquals(message, '')
1099 message = self.PerformIncludeWhatYouUse(
1104 self.assertEquals(message, 'Add #include <set> for set<> '
1108 message = self.PerformIncludeWhatYouUse(
1112 self.assertEquals(message, '')
1116 message = self.PerformIncludeWhatYouUse(
1121 self.assertEquals(message, 'Add #include <set> for set<> '
1124 def testFilesBelongToSameModule(self): argument
1126 self.assertEquals((True, ''), f('a.cc', 'a.h'))
1127 self.assertEquals((True, ''), f('base/google.cc', 'base/google.h'))
1128 self.assertEquals((True, ''), f('base/google_test.cc', 'base/google.h'))
1129 self.assertEquals((True, ''),
1131 self.assertEquals((True, ''),
1134 self.assertEquals((True, 'xxx/yyy/'),
1137 self.assertEquals((True, 'xxx/yyy/'),
1140 self.assertEquals((True, ''),
1142 self.assertEquals((True, '/home/build/google3/'),
1145 self.assertEquals((False, ''),
1147 self.assertEquals((False, ''), f('a.cc', 'b.h'))
1149 def testCleanseLine(self): argument
1150 self.assertEquals('int foo = 0;',
1152 self.assertEquals('int o = 0;',
1154 self.assertEquals('foo(int a, int b);',
1156 self.assertEqual('f(a, b);',
1158 self.assertEqual('f(a, b);',
1160 self.assertEqual('f(a, b);',
1162 self.assertEqual('f(a, b, c);',
1164 self.assertEqual('f(a, b, c);',
1167 def testRawStrings(self): argument
1168 self.TestMultiLineLint(
1177 self.TestMultiLineLint(
1186 self.TestMultiLineLint(
1192 self.TestMultiLineLint(
1211 self.TestMultiLineLint(
1223 self.TestMultiLineLint(
1232 def testMultiLineComments(self): argument
1234 self.TestMultiLineLint(
1242 self.TestMultiLineLint(
1247 self.TestMultiLineLint(r""" /* multi-line comment""",
1250 self.TestMultiLineLint(r""" // /* comment, but not multi-line""", '')
1251 self.TestMultiLineLint(r"""/**********
1253 self.TestMultiLineLint(r"""/**
1257 self.TestMultiLineLint(r"""/*!
1262 def testMultilineStrings(self): argument
1271 error_collector = ErrorCollector(self.assert_)
1276 self.assertEquals(
1281 def testExplicitSingleArgumentConstructors(self): argument
1287 self.TestMultiLineLint(
1295 self.TestMultiLineLint(
1304 self.TestMultiLineLint(
1312 self.TestMultiLineLint(
1320 self.TestMultiLineLint(
1328 self.TestMultiLineLint(
1336 self.TestMultiLineLint(
1343 self.TestMultiLineLint(
1351 self.TestMultiLineLint(
1357 self.TestMultiLineLint(
1364 self.TestMultiLineLint(
1370 self.TestMultiLineLint(
1377 self.TestMultiLineLint(
1383 self.TestMultiLineLint(
1389 self.TestMultiLineLint(
1395 self.TestMultiLineLint(
1402 self.TestMultiLineLint(
1410 self.TestMultiLineLint(
1418 self.TestMultiLineLint(
1426 self.TestMultiLineLint(
1435 self.TestMultiLineLint(
1444 self.TestMultiLineLint(
1452 self.TestMultiLineLint(
1460 self.TestMultiLineLint(
1468 self.TestMultiLineLint(
1474 self.TestMultiLineLint(
1482 self.TestMultiLineLint(
1491 self.TestMultiLineLint(
1500 self.TestMultiLineLint(
1508 self.TestMultiLineLint(
1515 self.TestMultiLineLint(
1522 self.TestMultiLineLint(
1530 self.TestMultiLineLint(
1537 self.TestMultiLineLint(
1544 self.TestMultiLineLint(
1551 self.TestMultiLineLint(
1559 self.TestMultiLineLint(
1567 self.TestMultiLineLint(
1571 self.TestMultiLineLint(
1577 self.TestMultiLineLint(
1583 self.TestMultiLineLint(
1590 self.TestMultiLineLint(
1597 self.TestMultiLineLint(
1604 error_collector = ErrorCollector(self.assert_)
1615 self.assertEquals(
1619 self.assertEquals(
1624 self.assertEquals(
1631 def testSlashStarCommentOnSingleLine(self): argument
1632 self.TestMultiLineLint(
1635 self.TestMultiLineLint(
1638 self.TestMultiLineLint(
1642 self.TestMultiLineLint(
1646 self.TestMultiLineLint(
1656 def testSuspiciousUsageOfIf(self): argument
1657 self.TestLint(
1660 self.TestLint(
1667 def testSuspiciousUsageOfMemset(self): argument
1669 self.TestLint(
1674 self.TestLint(
1678 self.TestLint(
1685 self.TestLint(
1688 self.TestLint(
1691 self.TestLint(
1694 self.TestLint(
1697 self.TestLint(
1701 def testRedundantVirtual(self): argument
1702 self.TestLint('virtual void F()', '')
1703 self.TestLint('virtual void F();', '')
1704 self.TestLint('virtual void F() {}', '')
1710 self.TestLint('virtual int F() %s' % virt_specifier, error_message)
1711 self.TestLint('virtual int F() %s;' % virt_specifier, error_message)
1712 self.TestLint('virtual int F() %s {' % virt_specifier, error_message)
1714 error_collector = ErrorCollector(self.assert_)
1727 self.assertEquals(
1732 self.TestLint('int F() override final', error_message)
1733 self.TestLint('int F() override final;', error_message)
1734 self.TestLint('int F() override final {}', error_message)
1735 self.TestLint('int F() final override', error_message)
1736 self.TestLint('int F() final override;', error_message)
1737 self.TestLint('int F() final override {}', error_message)
1739 error_collector = ErrorCollector(self.assert_)
1753 self.assertEquals('', error_collector.Results())
1755 self.TestLint('void Finalize(AnnotationProto *final) override;', '')
1757 def testCheckDeprecated(self): argument
1758 self.TestLanguageRulesCheck('foo_test.cc', '#include <iostream>', '')
1759 self.TestLanguageRulesCheck('foo_unittest.cc', '#include <iostream>', '')
1761 def testCheckPosixThreading(self): argument
1762 self.TestLint('var = sctime_r()', '')
1763 self.TestLint('var = strtok_r()', '')
1764 self.TestLint('var = strtok_r(foo, ba, r)', '')
1765 self.TestLint('var = brand()', '')
1766 self.TestLint('_rand()', '')
1767 self.TestLint('.rand()', '')
1768 self.TestLint('->rand()', '')
1769 self.TestLint('ACMRandom rand(seed)', '')
1770 self.TestLint('ISAACRandom rand()', '')
1771 self.TestLint('var = rand()',
1775 self.TestLint('var = strtok(str, delim)',
1781 def testVlogMisuse(self): argument
1782 self.TestLint('VLOG(1)', '')
1783 self.TestLint('VLOG(99)', '')
1784 self.TestLint('LOG(ERROR)', '')
1785 self.TestLint('LOG(INFO)', '')
1786 self.TestLint('LOG(WARNING)', '')
1787 self.TestLint('LOG(FATAL)', '')
1788 self.TestLint('LOG(DFATAL)', '')
1789 self.TestLint('VLOG(SOMETHINGWEIRD)', '')
1790 self.TestLint('MYOWNVLOG(ERROR)', '')
1794 self.TestLint('VLOG(ERROR)', errmsg)
1795 self.TestLint('VLOG(INFO)', errmsg)
1796 self.TestLint('VLOG(WARNING)', errmsg)
1797 self.TestLint('VLOG(FATAL)', errmsg)
1798 self.TestLint('VLOG(DFATAL)', errmsg)
1799 self.TestLint(' VLOG(ERROR)', errmsg)
1800 self.TestLint(' VLOG(INFO)', errmsg)
1801 self.TestLint(' VLOG(WARNING)', errmsg)
1802 self.TestLint(' VLOG(FATAL)', errmsg)
1803 self.TestLint(' VLOG(DFATAL)', errmsg)
1807 def testFormatStrings(self): argument
1808 self.TestLint('printf("foo")', '')
1809 self.TestLint('printf("foo: %s", foo)', '')
1810 self.TestLint('DocidForPrintf(docid)', '') # Should not trigger.
1811 self.TestLint('printf(format, value)', '') # Should not trigger.
1812 self.TestLint('printf(__VA_ARGS__)', '') # Should not trigger.
1813 self.TestLint('printf(format.c_str(), value)', '') # Should not trigger.
1814 self.TestLint('printf(format(index).c_str(), value)', '')
1815 self.TestLint(
1819 self.TestLint(
1824 self.TestLint(
1829 self.TestLint(
1836 def testIllegalOperatorOverloading(self): argument
1839 self.TestLint('void operator=(const Myclass&)', '')
1840 self.TestLint('void operator&(int a, int b)', '') # binary operator& ok
1841 self.TestLint('void operator&() { }', errmsg)
1842 self.TestLint('void operator & ( ) { }',
1846 def testConstStringReferenceMembers(self): argument
1864 self.TestLint('void f(const string&)', '')
1865 self.TestLint('const string& f(const string& a, const string& b)', '')
1866 self.TestLint('typedef const string& A;', '')
1869 self.TestLint(decl + ' = b;', '')
1870 self.TestLint(decl + ' =', '')
1875 self.TestLint(decl + ';', errmsg)
1878 def testVariableLengthArrayDetection(self): argument
1883 self.TestLint('int a[any_old_variable];', errmsg)
1884 self.TestLint('int doublesize[some_var * 2];', errmsg)
1885 self.TestLint('int a[afunction()];', errmsg)
1886 self.TestLint('int a[function(kMaxFooBars)];', errmsg)
1887 self.TestLint('bool a_list[items_->size()];', errmsg)
1888 self.TestLint('namespace::Type buffer[len+1];', errmsg)
1890 self.TestLint('int a[64];', '')
1891 self.TestLint('int a[0xFF];', '')
1892 self.TestLint('int first[256], second[256];', '')
1893 self.TestLint('int array_name[kCompileTimeConstant];', '')
1894 self.TestLint('char buf[somenamespace::kBufSize];', '')
1895 self.TestLint('int array_name[ALL_CAPS];', '')
1896 self.TestLint('AClass array1[foo::bar::ALL_CAPS];', '')
1897 self.TestLint('int a[kMaxStrLen + 1];', '')
1898 self.TestLint('int a[sizeof(foo)];', '')
1899 self.TestLint('int a[sizeof(*foo)];', '')
1900 self.TestLint('int a[sizeof foo];', '')
1901 self.TestLint('int a[sizeof(struct Foo)];', '')
1902 self.TestLint('int a[128 - sizeof(const bar)];', '')
1903 self.TestLint('int a[(sizeof(foo) * 4)];', '')
1904 self.TestLint('int a[(arraysize(fixed_size_array)/2) << 1];', '')
1905 self.TestLint('delete a[some_var];', '')
1906 self.TestLint('return a[some_var];', '')
1910 def testDisallowMacrosAtEnd(self): argument
1914 error_collector = ErrorCollector(self.assert_)
1925 self.assertEquals(
1930 error_collector = ErrorCollector(self.assert_)
1944 self.assertEquals(
1949 error_collector = ErrorCollector(self.assert_)
1981 self.assertEquals('', error_collector.Results())
1984 def testBraces(self): argument
1987 self.TestLint('int a[3] = { 1, 2, 3 };', '')
1988 self.TestLint(
1993 self.TestMultiLineLint(
1998 self.TestMultiLineLint(
2002 self.TestMultiLineLint(
2009 def testCheckCheck(self): argument
2010 self.TestLint('CHECK(x == 42);',
2013 self.TestLint('CHECK(x != 42);',
2016 self.TestLint('CHECK(x >= 42);',
2019 self.TestLint('CHECK(x > 42);',
2022 self.TestLint('CHECK(x <= 42);',
2025 self.TestLint('CHECK(x < 42);',
2029 self.TestLint('DCHECK(x == 42);',
2032 self.TestLint('DCHECK(x != 42);',
2035 self.TestLint('DCHECK(x >= 42);',
2038 self.TestLint('DCHECK(x > 42);',
2041 self.TestLint('DCHECK(x <= 42);',
2044 self.TestLint('DCHECK(x < 42);',
2048 self.TestLint(
2052 self.TestLint(
2056 self.TestLint(
2061 self.TestLint(
2065 self.TestLint(
2069 self.TestLint(
2073 self.TestLint(
2077 self.TestLint(
2082 self.TestLint('CHECK(x<42);',
2087 self.TestLint('CHECK(x>42);',
2093 self.TestLint('using some::namespace::operator<<;', '')
2094 self.TestLint('using some::namespace::operator>>;', '')
2096 self.TestLint('CHECK(x->y == 42);',
2100 self.TestLint(
2104 self.TestLint(
2112 self.TestLint('CHECK(4\'2 == x);',
2116 def testCheckCheckFalsePositives(self): argument
2117 self.TestLint('CHECK(some_iterator == obj.end());', '')
2118 self.TestLint('EXPECT_TRUE(some_iterator == obj.end());', '')
2119 self.TestLint('EXPECT_FALSE(some_iterator == obj.end());', '')
2120 self.TestLint('CHECK(some_pointer != NULL);', '')
2121 self.TestLint('EXPECT_TRUE(some_pointer != NULL);', '')
2122 self.TestLint('EXPECT_FALSE(some_pointer != NULL);', '')
2124 self.TestLint('CHECK(CreateTestFile(dir, (1 << 20)));', '')
2125 self.TestLint('CHECK(CreateTestFile(dir, (1 >> 20)));', '')
2127 self.TestLint('CHECK(x ^ (y < 42));', '')
2128 self.TestLint('CHECK((x > 42) ^ (x < 54));', '')
2129 self.TestLint('CHECK(a && b < 42);', '')
2130 self.TestLint('CHECK(42 < a && a < b);', '')
2131 self.TestLint('SOFT_CHECK(x > 42);', '')
2133 self.TestMultiLineLint(
2147 self.TestLint('CHECK(x < 42) << "Custom error message";', '')
2150 def testCheckAltTokens(self): argument
2151 self.TestLint('true or true',
2154 self.TestLint('true and true',
2157 self.TestLint('if (not true)',
2160 self.TestLint('1 bitor 1',
2163 self.TestLint('1 xor 1',
2166 self.TestLint('1 bitand 1',
2169 self.TestLint('x = compl 1',
2172 self.TestLint('x and_eq y',
2175 self.TestLint('x or_eq y',
2178 self.TestLint('x xor_eq y',
2181 self.TestLint('x not_eq y',
2184 self.TestLint('line_continuation or',
2187 self.TestLint('if(true and(parentheses',
2191 self.TestLint('#include "base/false-and-false.h"', '')
2192 self.TestLint('#error false or false', '')
2193 self.TestLint('false nor false', '')
2194 self.TestLint('false nand false', '')
2197 def testNonConstReference(self): argument
2203 self.TestLint('bool operator>(Foo& s, Foo& f);',
2206 self.TestLint('bool operator+(Foo& s, Foo& f);',
2209 self.TestLint('int len(Foo& s);', operand_error_message % 'Foo& s')
2211 self.TestLint('stream& operator>>(stream& s, Foo& f);', '')
2212 self.TestLint('stream& operator<<(stream& s, Foo& f);', '')
2213 self.TestLint('void swap(Bar& a, Bar& b);', '')
2214 self.TestLint('ostream& LogFunc(ostream& s);', '')
2215 self.TestLint('ostringstream& LogFunc(ostringstream& s);', '')
2216 self.TestLint('istream& LogFunc(istream& s);', '')
2217 self.TestLint('istringstream& LogFunc(istringstream& s);', '')
2219 self.TestLint('int& g();', '')
2221 self.TestLint('void foo(const struct tm& tm);', '')
2223 self.TestLint('void foo(const typename tm& tm);', '')
2225 self.TestLint('void foo(const Bar* const& p) {', '')
2226 self.TestLint('void foo(Bar const* const& p) {', '')
2227 self.TestLint('void foo(Bar* const& p) {', '')
2229 self.TestLint('void foo(const std::vector<std::string>& v);', '')
2231 self.TestLint('void foo(Bar*& p);',
2233 self.TestLint('void foo(const Bar*& p);',
2235 self.TestLint('void foo(Bar const*& p);',
2237 self.TestLint('void foo(struct Bar*& p);',
2239 self.TestLint('void foo(const struct Bar*& p);',
2241 self.TestLint('void foo(struct Bar const*& p);',
2244 self.TestLint('void foo(std::vector<int>& p);',
2247 self.TestLint('return &something;', '')
2248 self.TestLint('if (condition) {return &something; }', '')
2249 self.TestLint('if (condition) return &something;', '')
2250 self.TestLint('if (condition) address = &something;', '')
2251 self.TestLint('if (condition) result = lhs&rhs;', '')
2252 self.TestLint('if (condition) result = lhs & rhs;', '')
2253 self.TestLint('a = (b+c) * sizeof &f;', '')
2254 self.TestLint('a = MySize(b) * sizeof &f;', '')
2256 self.TestLint('for (const string& s : c)', '')
2257 self.TestLint('for (auto& r : c)', '')
2258 self.TestLint('for (typename Type& a : b)', '')
2260 self.TestLint('T& operator=(const T& t);', '')
2261 self.TestLint('int g() { return (a & b); }', '')
2262 self.TestLint('T& r = (T&)*(vp());', '')
2263 self.TestLint('T& r = v', '')
2264 self.TestLint('static_assert((kBits & kMask) == 0, "text");', '')
2265 self.TestLint('COMPILE_ASSERT((kBits & kMask) == 0, text);', '')
2268 self.TestLint('void Func(const vector <int> &const_x, '
2273 self.TestLint('void Func(X& x);', operand_error_message % 'X& x')
2274 self.TestLint('void Func(X& x) {}', operand_error_message % 'X& x')
2275 self.TestLint('void Func(X& x) override;', '')
2276 self.TestLint('void Func(X& x) override {', '')
2277 self.TestLint('void Func(X& x) const override;', '')
2278 self.TestLint('void Func(X& x) const override {', '')
2281 self.TestLint('void NS::Func(X& x) {', '')
2282 error_collector = ErrorCollector(self.assert_)
2290 self.assertEquals(
2296 error_collector = ErrorCollector(self.assert_)
2336 self.assertEquals('', error_collector.Results())
2339 error_collector = ErrorCollector(self.assert_)
2358 self.assertEquals(
2365 error_collector = ErrorCollector(self.assert_)
2378 self.assertEquals('', error_collector.Results())
2380 def testBraceAtBeginOfLine(self): argument
2381 self.TestLint('{',
2385 error_collector = ErrorCollector(self.assert_)
2407 self.assertEquals(1, error_collector.Results().count(
2411 self.TestMultiLineLint(
2419 def testMismatchingSpacesInParens(self): argument
2420 self.TestLint('if (foo ) {', 'Mismatching spaces inside () in if'
2422 self.TestLint('switch ( foo) {', 'Mismatching spaces inside () in switch'
2424 self.TestLint('for (foo; ba; bar ) {', 'Mismatching spaces inside () in for'
2426 self.TestLint('for (; foo; bar) {', '')
2427 self.TestLint('for ( ; foo; bar) {', '')
2428 self.TestLint('for ( ; foo; bar ) {', '')
2429 self.TestLint('for (foo; bar; ) {', '')
2430 self.TestLint('while ( foo ) {', 'Should have zero or one spaces inside'
2433 def testSpacingForFncall(self): argument
2434 self.TestLint('if (foo) {', '')
2435 self.TestLint('for (foo; bar; baz) {', '')
2436 self.TestLint('for (;;) {', '')
2438 self.TestLint('Something* p = new (place) Something();', '')
2440 self.TestLint('for (foo; baz;) {', '')
2441 self.TestLint('for (foo;bar;baz) {', 'Missing space after ;'
2444 self.TestLint('if (condition) {return &something; }',
2447 self.TestLint('DoSth();\\', '')
2449 self.TestLint('abc;// this is abc',
2452 self.TestLint('while (foo) {', '')
2453 self.TestLint('switch (foo) {', '')
2454 self.TestLint('foo( bar)', 'Extra space after ( in function call'
2456 self.TestLint('foo( // comment', '')
2457 self.TestLint('foo( // comment',
2460 self.TestLint('foobar( \\', '')
2461 self.TestLint('foobar( \\', '')
2462 self.TestLint('( a + b)', 'Extra space after ('
2464 self.TestLint('((a+b))', '')
2465 self.TestLint('foo (foo)', 'Extra space before ( in function call'
2468 self.TestLint('asm volatile ("")', '')
2469 self.TestLint('__asm__ __volatile__ ("")', '')
2470 self.TestLint('} catch (const Foo& ex) {', '')
2471 self.TestLint('case (42):', '')
2472 self.TestLint('typedef foo (*foo)(foo)', '')
2473 self.TestLint('typedef foo (*foo12bar_)(foo)', '')
2474 self.TestLint('typedef foo (Foo::*bar)(foo)', '')
2475 self.TestLint('using foo = type (Foo::*bar)(foo)', '')
2476 self.TestLint('using foo = type (Foo::*bar)(', '')
2477 self.TestLint('using foo = type (Foo::*)(', '')
2478 self.TestLint('foo (Foo::*bar)(', '')
2479 self.TestLint('foo (x::y::*z)(', '')
2480 self.TestLint('foo (Foo::bar)(',
2483 self.TestLint('foo (*bar)(', '')
2484 self.TestLint('typedef foo (Foo::*bar)(', '')
2485 self.TestLint('(foo)(bar)', '')
2486 self.TestLint('Foo (*foo)(bar)', '')
2487 self.TestLint('Foo (*foo)(Bar bar,', '')
2488 self.TestLint('char (*p)[sizeof(foo)] = &foo', '')
2489 self.TestLint('char (&ref)[sizeof(foo)] = &foo', '')
2490 self.TestLint('const char32 (*table[])[6];', '')
2495 self.TestLint('sizeof(foo)', '')
2496 self.TestLint('sizeof foo', '')
2497 self.TestLint('sizeof (foo)', '')
2499 def testSpacingBeforeBraces(self): argument
2500 self.TestLint('if (foo){', 'Missing space before {'
2502 self.TestLint('for{', 'Missing space before {'
2504 self.TestLint('for {', '')
2505 self.TestLint('EXPECT_DEBUG_DEATH({', '')
2506 self.TestLint('std::is_convertible<A, B>{}', '')
2507 self.TestLint('blah{32}', 'Missing space before {'
2509 self.TestLint('int8_t{3}', '')
2510 self.TestLint('int16_t{3}', '')
2511 self.TestLint('int32_t{3}', '')
2512 self.TestLint('uint64_t{12345}', '')
2513 self.TestLint('constexpr int64_t kBatchGapMicros ='
2515 self.TestLint('MoveOnly(int i1, int i2) : ip1{new int{i1}}, '
2519 def testSemiColonAfterBraces(self): argument
2520 self.TestLint('if (cond) { func(); };',
2522 self.TestLint('void Func() {};',
2524 self.TestLint('void Func() const {};',
2526 self.TestLint('class X {};', '')
2531 self.TestLint(keyword + align + typename + ' {}' + identifier + ';',
2534 self.TestLint('class X : public Y {};', '')
2535 self.TestLint('class X : public MACRO() {};', '')
2536 self.TestLint('class X : public decltype(expr) {};', '')
2537 self.TestLint('DEFINE_FACADE(PCQueue::Watcher, PCQueue) {};', '')
2538 self.TestLint('VCLASS(XfaTest, XfaContextTest) {};', '')
2539 self.TestLint('class STUBBY_CLASS(H, E) {};', '')
2540 self.TestLint('class STUBBY2_CLASS(H, E) {};', '')
2541 self.TestLint('TEST(TestCase, TestName) {};',
2543 self.TestLint('TEST_F(TestCase, TestName) {};',
2546 self.TestLint('file_tocs_[i] = (FileToc) {a, b, c};', '')
2547 self.TestMultiLineLint('class X : public Y,\npublic Z {};', '')
2549 def testLambda(self): argument
2550 self.TestLint('auto x = []() {};', '')
2551 self.TestLint('return []() {};', '')
2552 self.TestMultiLineLint('auto x = []() {\n};\n', '')
2553 self.TestLint('int operator[](int x) {};',
2556 self.TestMultiLineLint('auto x = [&a,\nb]() {};', '')
2557 self.TestMultiLineLint('auto x = [&a,\nb]\n() {};', '')
2558 self.TestMultiLineLint('auto x = [&a,\n'
2568 self.TestLint('table_to_children[&*table].push_back(dependent);', '')
2570 def testBraceInitializerList(self): argument
2571 self.TestLint('MyStruct p = {1, 2};', '')
2572 self.TestLint('MyStruct p{1, 2};', '')
2573 self.TestLint('vector<int> p = {1, 2};', '')
2574 self.TestLint('vector<int> p{1, 2};', '')
2575 self.TestLint('x = vector<int>{1, 2};', '')
2576 self.TestLint('x = (struct in_addr){ 0 };', '')
2577 self.TestLint('Func(vector<int>{1, 2})', '')
2578 self.TestLint('Func((struct in_addr){ 0 })', '')
2579 self.TestLint('Func(vector<int>{1, 2}, 3)', '')
2580 self.TestLint('Func((struct in_addr){ 0 }, 3)', '')
2581 self.TestLint('LOG(INFO) << char{7};', '')
2582 self.TestLint('LOG(INFO) << char{7} << "!";', '')
2583 self.TestLint('int p[2] = {1, 2};', '')
2584 self.TestLint('return {1, 2};', '')
2585 self.TestLint('std::unique_ptr<Foo> foo{new Foo{}};', '')
2586 self.TestLint('auto foo = std::unique_ptr<Foo>{new Foo{}};', '')
2587 self.TestLint('static_assert(Max7String{}.IsValid(), "");', '')
2588 self.TestLint('map_of_pairs[{1, 2}] = 3;', '')
2589 self.TestLint('ItemView{has_offer() ? new Offer{offer()} : nullptr', '')
2590 self.TestLint('template <class T, EnableIf<::std::is_const<T>{}> = 0>', '')
2592 self.TestMultiLineLint('std::unique_ptr<Foo> foo{\n'
2595 self.TestMultiLineLint('std::unique_ptr<Foo> foo{\n'
2600 self.TestMultiLineLint('if (true) {\n'
2604 self.TestMultiLineLint('MyClass::MyClass()\n'
2608 self.TestLint('const pair<string, string> kCL' +
2612 self.TestMultiLineLint('const pair<string, string> kCL' +
2617 self.TestMultiLineLint('const pair<string, string> kCL' +
2624 def testSpacingAroundElse(self): argument
2625 self.TestLint('}else {', 'Missing space before else'
2627 self.TestLint('} else{', 'Missing space before {'
2629 self.TestLint('} else {', '')
2630 self.TestLint('} else if (foo) {', '')
2632 def testSpacingWithInitializerLists(self): argument
2633 self.TestLint('int v[1][3] = {{1, 2, 3}};', '')
2634 self.TestLint('int v[1][1] = {{0}};', '')
2636 def testSpacingForBinaryOps(self): argument
2637 self.TestLint('if (foo||bar) {', 'Missing spaces around ||'
2639 self.TestLint('if (foo<=bar) {', 'Missing spaces around <='
2641 self.TestLint('if (foo<bar) {', 'Missing spaces around <'
2643 self.TestLint('if (foo>bar) {', 'Missing spaces around >'
2645 self.TestLint('if (foo<bar->baz) {', 'Missing spaces around <'
2647 self.TestLint('if (foo<bar->bar) {', 'Missing spaces around <'
2649 self.TestLint('template<typename T = double>', '')
2650 self.TestLint('std::unique_ptr<No<Spaces>>', '')
2651 self.TestLint('typedef hash_map<Foo, Bar>', '')
2652 self.TestLint('10<<20', '')
2653 self.TestLint('10<<a',
2655 self.TestLint('a<<20',
2657 self.TestLint('a<<b',
2659 self.TestLint('10LL<<20', '')
2660 self.TestLint('10ULL<<20', '')
2661 self.TestLint('a>>b',
2663 self.TestLint('10>>b',
2665 self.TestLint('LOG(ERROR)<<*foo',
2667 self.TestLint('LOG(ERROR)<<&foo',
2669 self.TestLint('StringCoder<vector<string>>::ToString()', '')
2670 self.TestLint('map<pair<int, int>, map<int, int>>::iterator', '')
2671 self.TestLint('func<int, pair<int, pair<int, int>>>()', '')
2672 self.TestLint('MACRO1(list<list<int>>)', '')
2673 self.TestLint('MACRO2(list<list<int>>, 42)', '')
2674 self.TestLint('void DoFoo(const set<vector<string>>& arg1);', '')
2675 self.TestLint('void SetFoo(set<vector<string>>* arg1);', '')
2676 self.TestLint('foo = new set<vector<string>>;', '')
2677 self.TestLint('reinterpret_cast<set<vector<string>>*>(a);', '')
2678 self.TestLint('MACRO(<<)', '')
2679 self.TestLint('MACRO(<<, arg)', '')
2680 self.TestLint('MACRO(<<=)', '')
2681 self.TestLint('MACRO(<<=, arg)', '')
2683 self.TestLint('using Vector3<T>::operator==;', '')
2684 self.TestLint('using Vector3<T>::operator!=;', '')
2686 def testSpacingBeforeLastSemicolon(self): argument
2687 self.TestLint('call_function() ;',
2691 self.TestLint('while (true) ;',
2695 self.TestLint('default:;',
2698 self.TestLint(' ;',
2702 self.TestLint('for (int i = 0; ;', '')
2704 def testEmptyBlockBody(self): argument
2705 self.TestLint('while (true);',
2708 self.TestLint('if (true);',
2711 self.TestLint('while (true)', '')
2712 self.TestLint('while (true) continue;', '')
2713 self.TestLint('for (;;);',
2716 self.TestLint('for (;;)', '')
2717 self.TestLint('for (;;) continue;', '')
2718 self.TestLint('for (;;) func();', '')
2719 self.TestLint('if (test) {}',
2722 self.TestLint('if (test) func();', '')
2723 self.TestLint('if (test) {} else {}', '')
2724 self.TestMultiLineLint("""while (true &&
2728 self.TestMultiLineLint("""do {
2731 self.TestMultiLineLint("""#define MACRO \\
2735 self.TestMultiLineLint("""do {
2740 self.TestMultiLineLint("""if (test) {
2744 self.TestMultiLineLint("""if (test,
2749 self.TestMultiLineLint("""if (test)
2751 self.TestLint('if (test) { hello; }', '')
2752 self.TestLint('if (test({})) { hello; }', '')
2753 self.TestMultiLineLint("""if (test) {
2756 self.TestMultiLineLint("""if (test) {
2760 self.TestMultiLineLint("""if (test) { // comment
2762 self.TestMultiLineLint("""if (test) {
2765 self.TestMultiLineLint("""if (func(p1,
2770 self.TestMultiLineLint("""if (func({}, p1)) {
2774 def testSpacingForRangeBasedFor(self): argument
2776 self.TestLint('for (int i : numbers) {', '')
2779 self.TestLint('for (int i: numbers) {',
2783 self.TestLint('for (int i :numbers) {',
2787 self.TestLint('for (int i:numbers) {',
2792 self.TestLint('for (std::size_t i : sizes) {}', '')
2794 self.TestLint('for (std::size_t i: sizes) {}',
2800 def testStaticOrGlobalSTLStrings(self): argument
2809 self.TestLint('string foo;',
2811 self.TestLint('string kFoo = "hello"; // English',
2813 self.TestLint('static string foo;',
2815 self.TestLint('static const string foo;',
2817 self.TestLint('static const std::string foo;',
2819 self.TestLint('string Foo::bar;',
2822 self.TestLint('std::string foo;',
2824 self.TestLint('std::string kFoo = "hello"; // English',
2826 self.TestLint('static std::string foo;',
2828 self.TestLint('static const std::string foo;',
2830 self.TestLint('std::string Foo::bar;',
2833 self.TestLint('::std::string foo;',
2835 self.TestLint('::std::string kFoo = "hello"; // English',
2837 self.TestLint('static ::std::string foo;',
2839 self.TestLint('static const ::std::string foo;',
2841 self.TestLint('::std::string Foo::bar;',
2844 self.TestLint('string* pointer', '')
2845 self.TestLint('string *pointer', '')
2846 self.TestLint('string* pointer = Func();', '')
2847 self.TestLint('string *pointer = Func();', '')
2848 self.TestLint('const string* pointer', '')
2849 self.TestLint('const string *pointer', '')
2850 self.TestLint('const string* pointer = Func();', '')
2851 self.TestLint('const string *pointer = Func();', '')
2852 self.TestLint('string const* pointer', '')
2853 self.TestLint('string const *pointer', '')
2854 self.TestLint('string const* pointer = Func();', '')
2855 self.TestLint('string const *pointer = Func();', '')
2856 self.TestLint('string* const pointer', '')
2857 self.TestLint('string *const pointer', '')
2858 self.TestLint('string* const pointer = Func();', '')
2859 self.TestLint('string *const pointer = Func();', '')
2860 self.TestLint('string Foo::bar() {}', '')
2861 self.TestLint('string Foo::operator*() {}', '')
2863 self.TestLint('string foo("foobar");', nonconst_error_msg)
2865 self.TestLint(' string foo', '')
2867 self.TestLint('string EmptyString() { return ""; }', '')
2868 self.TestLint('string EmptyString () { return ""; }', '')
2869 self.TestLint('string const& FileInfo::Pathname() const;', '')
2870 self.TestLint('string const &FileInfo::Pathname() const;', '')
2871 self.TestLint('string VeryLongNameFunctionSometimesEndsWith(\n'
2873 self.TestLint('template<>\n'
2876 self.TestLint('template<>\n'
2881 self.TestLint('string Class<Type>::Method() const {\n'
2884 self.TestLint('string Class<Type>::Method(\n'
2890 error_collector = ErrorCollector(self.assert_)
2913 self.assertEquals(error_collector.Results(),
2920 def testNoSpacesInFunctionCalls(self): argument
2921 self.TestLint('TellStory(1, 3);',
2923 self.TestLint('TellStory(1, 3 );',
2926 self.TestLint('TellStory(1 /* wolf */, 3 /* pigs */);',
2928 self.TestMultiLineLint("""TellStory(1, 3
2932 self.TestMultiLineLint("""TellStory(Wolves(1),
2937 self.TestMultiLineLint("""TellStory(1,
2942 def testToDoComments(self): argument
2951 self.TestLint('// TODOfix this',
2953 self.TestLint('// TODO(ljenkins)fix this',
2955 self.TestLint('// TODO fix this',
2957 self.TestLint('// TODO fix this', missing_username)
2958 self.TestLint('// TODO: fix this', missing_username)
2959 self.TestLint('//TODO(ljenkins): Fix this',
2962 self.TestLint('// TODO(ljenkins):Fix this', end_space)
2963 self.TestLint('// TODO(ljenkins):', '')
2964 self.TestLint('// TODO(ljenkins): fix this', '')
2965 self.TestLint('// TODO(ljenkins): Fix this', '')
2966 self.TestLint('#if 1 // TEST_URLTODOCID_WHICH_HAS_THAT_WORD_IN_IT_H_', '')
2967 self.TestLint('// See also similar TODO above', '')
2968 self.TestLint(r'EXPECT_EQ("\\", '
2972 def testTwoSpacesBetweenCodeAndComments(self): argument
2973 self.TestLint('} // namespace foo',
2976 self.TestLint('}// namespace foo',
2979 self.TestLint('printf("foo"); // Outside quotes.',
2982 self.TestLint('int i = 0; // Having two spaces is fine.', '')
2983 self.TestLint('int i = 0; // Having three spaces is OK.', '')
2984 self.TestLint('// Top level comment', '')
2985 self.TestLint(' // Line starts with two spaces.', '')
2986 self.TestMultiLineLint('void foo() {\n'
2989 self.TestMultiLineLint('void foo() {\n'
2994 self.TestMultiLineLint(' foo();\n'
2997 self.TestMultiLineLint('vector<int> my_elements = {// first\n'
2999 self.TestMultiLineLint('vector<int> my_elements = {// my_elements is ..\n'
3003 self.TestLint('if (foo) { // not a pure scope; comment is too close!',
3006 self.TestLint('printf("// In quotes.")', '')
3007 self.TestLint('printf("\\"%s // In quotes.")', '')
3008 self.TestLint('printf("%s", "// In quotes.")', '')
3010 def testSpaceAfterCommentMarker(self): argument
3011 self.TestLint('//', '')
3012 self.TestLint('//x', 'Should have a space between // and comment'
3014 self.TestLint('// x', '')
3015 self.TestLint('///', '')
3016 self.TestLint('/// x', '')
3017 self.TestLint('//!', '')
3018 self.TestLint('//----', '')
3019 self.TestLint('//====', '')
3020 self.TestLint('//////', '')
3021 self.TestLint('////// x', '')
3022 self.TestLint('///< x', '') # After-member Doxygen comment
3023 self.TestLint('//!< x', '') # After-member Doxygen comment
3024 self.TestLint('////x', 'Should have a space between // and comment'
3026 self.TestLint('//}', '')
3027 self.TestLint('//}x', 'Should have a space between // and comment'
3029 self.TestLint('//!<x', 'Should have a space between // and comment'
3031 self.TestLint('///<x', 'Should have a space between // and comment'
3039 def testLinePrecededByEmptyOrCommentLines(self): argument
3040 def DoTest(self, lines): argument
3041 error_collector = ErrorCollector(self.assert_)
3044 self.assertEquals(
3050 DoTest(self, ['using namespace foo;'])
3051 DoTest(self, ['', '', '', 'using namespace foo;'])
3052 DoTest(self, ['// hello', 'using namespace foo;'])
3054 def testNewlineAtEOF(self): argument
3055 def DoTest(self, data, is_missing_eof): argument
3056 error_collector = ErrorCollector(self.assert_)
3060 self.assertEquals(
3066 DoTest(self, '// Newline\n// at EOF\n', False)
3067 DoTest(self, '// No newline\n// at EOF', True)
3069 def testInvalidUtf8(self): argument
3070 def DoTest(self, raw_bytes, has_invalid_utf8): argument
3071 error_collector = ErrorCollector(self.assert_)
3077 self.assertEquals(
3084 DoTest(self, 'Hello world\n', False)
3085 DoTest(self, '\xe9\x8e\xbd\n', False)
3086 DoTest(self, '\xe9x\x8e\xbd\n', True)
3089 DoTest(self, '\xef\xbf\xbd\n', True)
3091 def testBadCharacters(self): argument
3093 error_collector = ErrorCollector(self.assert_)
3097 self.assertEquals(
3103 error_collector = ErrorCollector(self.assert_)
3109 self.assertEquals(
3115 def testIsBlankLine(self): argument
3116 self.assert_(cpplint.IsBlankLine(''))
3117 self.assert_(cpplint.IsBlankLine(' '))
3118 self.assert_(cpplint.IsBlankLine(' \t\r\n'))
3119 self.assert_(not cpplint.IsBlankLine('int a;'))
3120 self.assert_(not cpplint.IsBlankLine('{'))
3122 def testBlankLinesCheck(self): argument
3123 self.TestBlankLinesCheck(['{\n', '\n', '\n', '}\n'], 1, 1)
3124 self.TestBlankLinesCheck([' if (foo) {\n', '\n', ' }\n'], 1, 1)
3125 self.TestBlankLinesCheck(
3127 self.TestBlankLinesCheck(['\n', 'run("{");\n', '\n'], 0, 0)
3128 self.TestBlankLinesCheck(['\n', ' if (foo) { return 0; }\n', '\n'], 0, 0)
3129 self.TestBlankLinesCheck(
3131 self.TestBlankLinesCheck(
3133 self.TestBlankLinesCheck(
3135 self.TestBlankLinesCheck(
3138 def testAllowBlankLineBeforeClosingNamespace(self): argument
3139 error_collector = ErrorCollector(self.assert_)
3159 self.assertEquals(0, error_collector.Results().count(
3163 def testAllowBlankLineBeforeIfElseChain(self): argument
3164 error_collector = ErrorCollector(self.assert_)
3176 self.assertEquals(1, error_collector.Results().count(
3180 def testAllowBlankLineAfterExtern(self): argument
3181 error_collector = ErrorCollector(self.assert_)
3189 self.assertEquals(0, error_collector.Results().count(
3192 self.assertEquals(0, error_collector.Results().count(
3196 def testBlankLineBeforeSectionKeyword(self): argument
3197 error_collector = ErrorCollector(self.assert_)
3225 self.assertEquals(2, error_collector.Results().count(
3228 self.assertEquals(1, error_collector.Results().count(
3232 def testNoBlankLineAfterSectionKeyword(self): argument
3233 error_collector = ErrorCollector(self.assert_)
3246 self.assertEquals(1, error_collector.Results().count(
3249 self.assertEquals(1, error_collector.Results().count(
3252 self.assertEquals(1, error_collector.Results().count(
3256 def testAllowBlankLinesInRawStrings(self): argument
3257 error_collector = ErrorCollector(self.assert_)
3267 self.assertEquals('', error_collector.Results())
3269 def testElseOnSameLineAsClosingBraces(self): argument
3270 error_collector = ErrorCollector(self.assert_)
3280 self.assertEquals(2, error_collector.Results().count(
3284 error_collector = ErrorCollector(self.assert_)
3294 self.assertEquals(1, error_collector.Results().count(
3298 error_collector = ErrorCollector(self.assert_)
3305 self.assertEquals(0, error_collector.Results().count(
3309 def testMultipleStatementsOnSameLine(self): argument
3310 error_collector = ErrorCollector(self.assert_)
3318 self.assertEquals(0, error_collector.Results().count(
3328 def testEndOfNamespaceComments(self): argument
3329 error_collector = ErrorCollector(self.assert_)
3372 self.assertEquals(1, error_collector.Results().count(
3375 self.assertEquals(1, error_collector.Results().count(
3378 self.assertEquals(1, error_collector.Results().count(
3381 self.assertEquals(3, error_collector.Results().count(
3384 self.assertEquals(2, error_collector.Results().count(
3388 self.assertEquals(1, error_collector.Results().count(
3391 self.assertEquals(0, error_collector.Results().count(
3395 def testElseClauseNotOnSameLineAsElse(self): argument
3396 self.TestLint(' else DoSomethingElse();',
3399 self.TestLint(' else ifDoSomethingElse();',
3402 self.TestLint(' } else if (blah) {', '')
3403 self.TestLint(' variable_ends_in_else = true;', '')
3405 def testComma(self): argument
3406 self.TestLint('a = f(1,2);',
3408 self.TestLint('int tmp=a,a=b,b=tmp;',
3411 self.TestLint('f(a, /* name */ b);', '')
3412 self.TestLint('f(a, /* name */b);', '')
3413 self.TestLint('f(a, /* name */-1);', '')
3414 self.TestLint('f(a, /* name */"1");', '')
3415 self.TestLint('f(1, /* empty macro arg */, 2)', '')
3416 self.TestLint('f(1,, 2)', '')
3417 self.TestLint('operator,()', '')
3418 self.TestLint('operator,(a,b)',
3421 def testEqualsOperatorSpacing(self): argument
3422 self.TestLint('int tmp= a;',
3424 self.TestLint('int tmp =a;',
3426 self.TestLint('int tmp=a;',
3428 self.TestLint('int tmp= 7;',
3430 self.TestLint('int tmp =7;',
3432 self.TestLint('int tmp=7;',
3434 self.TestLint('int* tmp=*p;',
3436 self.TestLint('int* tmp= *p;',
3438 self.TestMultiLineLint(
3443 self.TestLint('bool result = a>=42;',
3445 self.TestLint('bool result = a<=42;',
3447 self.TestLint('bool result = a==42;',
3449 self.TestLint('auto result = a!=42;',
3451 self.TestLint('int a = b!=c;',
3453 self.TestLint('a&=42;', '')
3454 self.TestLint('a|=42;', '')
3455 self.TestLint('a^=42;', '')
3456 self.TestLint('a+=42;', '')
3457 self.TestLint('a*=42;', '')
3458 self.TestLint('a/=42;', '')
3459 self.TestLint('a%=42;', '')
3460 self.TestLint('a>>=5;', '')
3461 self.TestLint('a<<=5;', '')
3463 def testShiftOperatorSpacing(self): argument
3464 self.TestLint('a<<b',
3466 self.TestLint('a>>b',
3468 self.TestLint('1<<20', '')
3469 self.TestLint('1024>>10', '')
3470 self.TestLint('Kernel<<<1, 2>>>()', '')
3472 def testIndent(self): argument
3473 self.TestLint('static int noindent;', '')
3474 self.TestLint(' int two_space_indent;', '')
3475 self.TestLint(' int four_space_indent;', '')
3476 self.TestLint(' int one_space_indent;',
3479 self.TestLint(' int three_space_indent;',
3482 self.TestLint(' char* one_space_indent = "public:";',
3485 self.TestLint(' public:', '')
3486 self.TestLint(' protected:', '')
3487 self.TestLint(' private:', '')
3488 self.TestLint(' protected: \\', '')
3489 self.TestLint(' public: \\', '')
3490 self.TestLint(' private: \\', '')
3491 self.TestMultiLineLint(
3499 self.TestMultiLineLint(
3504 self.TestMultiLineLint(
3509 self.TestMultiLineLint(
3514 def testSectionIndent(self): argument
3515 self.TestMultiLineLint(
3523 self.TestMultiLineLint(
3534 self.TestMultiLineLint(
3540 self.TestMultiLineLint(
3546 self.TestMultiLineLint(
3557 self.TestMultiLineLint(
3567 self.TestMultiLineLint(
3576 self.TestMultiLineLint(
3583 self.TestMultiLineLint(
3593 def testConditionals(self): argument
3594 self.TestMultiLineLint(
3601 self.TestMultiLineLint(
3607 self.TestMultiLineLint(
3616 self.TestMultiLineLint(
3622 self.TestMultiLineLint(
3631 self.TestMultiLineLint(
3640 self.TestMultiLineLint(
3649 self.TestMultiLineLint(
3658 self.TestMultiLineLint(
3667 self.TestMultiLineLint(
3675 self.TestMultiLineLint(
3681 self.TestMultiLineLint(
3689 self.TestMultiLineLint(
3695 self.TestMultiLineLint(
3703 self.TestMultiLineLint(
3712 self.TestMultiLineLint(
3719 self.TestMultiLineLint(
3726 self.TestMultiLineLint(
3734 self.TestMultiLineLint(
3744 self.TestMultiLineLint(
3753 self.TestMultiLineLint(
3760 self.TestMultiLineLint(
3764 self.TestMultiLineLint(
3773 self.TestMultiLineLint(
3784 def testTab(self): argument
3785 self.TestLint('\tint a;',
3787 self.TestLint('int a = 5;\t\t// set a to 5',
3790 def testParseArguments(self): argument
3804 self.assertRaises(SystemExit, cpplint.ParseArguments, [])
3805 self.assertRaises(SystemExit, cpplint.ParseArguments, ['--badopt'])
3806 self.assertRaises(SystemExit, cpplint.ParseArguments, ['--help'])
3807 self.assertRaises(SystemExit, cpplint.ParseArguments, ['--v=0'])
3808 self.assertRaises(SystemExit, cpplint.ParseArguments, ['--filter='])
3810 self.assertRaises(SystemExit, cpplint.ParseArguments, ['--filter=foo'])
3811 self.assertRaises(SystemExit, cpplint.ParseArguments,
3813 self.assertRaises(SystemExit, cpplint.ParseArguments, ['--headers'])
3815 self.assertEquals(['foo.cc'], cpplint.ParseArguments(['foo.cc']))
3816 self.assertEquals(old_output_format, cpplint._cpplint_state.output_format)
3817 self.assertEquals(old_verbose_level, cpplint._cpplint_state.verbose_level)
3819 self.assertEquals(['foo.cc'],
3821 self.assertEquals(1, cpplint._cpplint_state.verbose_level)
3822 self.assertEquals(['foo.h'],
3824 self.assertEquals(3, cpplint._cpplint_state.verbose_level)
3825 self.assertEquals(['foo.cpp'],
3827 self.assertEquals(5, cpplint._cpplint_state.verbose_level)
3828 self.assertRaises(ValueError,
3831 self.assertEquals(['foo.cc'],
3833 self.assertEquals('emacs', cpplint._cpplint_state.output_format)
3834 self.assertEquals(['foo.h'],
3836 self.assertEquals('vs7', cpplint._cpplint_state.output_format)
3837 self.assertRaises(SystemExit,
3841 self.assertEquals(['foo.h'],
3843 self.assertEquals(['-', '+whitespace', '-whitespace/indent'],
3846 self.assertEquals(['foo.cc', 'foo.h'],
3849 self.assertEqual(['foo.h'],
3851 self.assertEqual(120, cpplint._line_length)
3853 self.assertEqual(['foo.h'],
3855 self.assertEqual(set(['hpp', 'cpp']), cpplint._valid_extensions)
3857 self.assertEqual(set(['h']), cpplint._hpp_headers) # Default value
3858 self.assertEqual(['foo.h'],
3860 self.assertEqual(set(['hpp', 'h']), cpplint._hpp_headers)
3861 self.assertEqual(set(['hpp', 'h', 'cpp']), cpplint._valid_extensions)
3873 def testLineLength(self): argument
3877 self.TestLint(
3880 self.TestLint(
3885 self.TestLint(
3888 self.TestLint(
3895 def testFilter(self): argument
3899 self.TestLint(
3903 self.TestLint('int a = (int)1.0;', '')
3904 self.TestLint(' weird opening space', '')
3908 def testDefaultFilter(self): argument
3915 self.TestLint('// Hello there ', '')
3917 self.TestLint(
3921 self.TestLint(' weird opening space', '')
3926 def testDuplicateHeader(self): argument
3927 error_collector = ErrorCollector(self.assert_)
3940 self.assertEquals(
3945 def testUnnamedNamespacesInHeaders(self): argument
3946 self.TestLanguageRulesCheck(
3952 self.TestLanguageRulesCheck('foo.h', 'namespace { \\', '')
3954 self.TestLanguageRulesCheck('foo.h', 'namespace foo {', '')
3955 self.TestLanguageRulesCheck('foo.h', 'namespace foonamespace {', '')
3956 self.TestLanguageRulesCheck('foo.cc', 'namespace {', '')
3957 self.TestLanguageRulesCheck('foo.cc', 'namespace foo {', '')
3959 def testBuildClass(self): argument
3963 self.TestMultiLineLint(
3968 self.TestMultiLineLint(
3973 self.TestMultiLineLint(
3976 self.TestMultiLineLint(
3981 self.TestMultiLineLint(
3989 self.TestMultiLineLint(
4000 self.TestMultiLineLint(
4005 def testBuildEndComment(self): argument
4008 self.TestMultiLineLint(
4014 def testBuildForwardDecl(self): argument
4017 self.TestLint('class Foo::Goo;',
4022 def GetBuildHeaderGuardPreprocessorSymbol(self, file_path): argument
4024 error_collector = ErrorCollector(self.assert_)
4034 def testBuildHeaderGuard(self): argument
4036 expected_guard = self.GetBuildHeaderGuardPreprocessorSymbol(file_path)
4037 self.assertTrue(re.search('MYDIR_FOO_H_$', expected_guard))
4040 error_collector = ErrorCollector(self.assert_)
4042 self.assertEquals(
4050 error_collector = ErrorCollector(self.assert_)
4055 self.assertEquals([], error_collector.ResultList())
4058 error_collector = ErrorCollector(self.assert_)
4061 self.assertEquals(
4069 error_collector = ErrorCollector(self.assert_)
4072 self.assertEquals(
4080 error_collector = ErrorCollector(self.assert_)
4085 self.assertEquals(
4093 error_collector = ErrorCollector(self.assert_)
4099 self.assertEquals(
4107 error_collector = ErrorCollector(self.assert_)
4113 self.assertEquals(
4121 error_collector = ErrorCollector(self.assert_)
4127 self.assertEquals(
4135 error_collector = ErrorCollector(self.assert_)
4143 self.fail('Unexpected error: %s' % line)
4146 error_collector = ErrorCollector(self.assert_)
4154 self.fail('Unexpected error: %s' % line)
4160 error_collector = ErrorCollector(self.assert_)
4166 self.assertEquals(
4176 error_collector = ErrorCollector(self.assert_)
4182 self.assertEquals(
4188 self.assertEquals(
4196 error_collector = ErrorCollector(self.assert_)
4202 self.assertEquals(
4208 self.assertEquals(
4217 error_collector = ErrorCollector(self.assert_)
4221 self.assertEquals(
4228 def testBuildHeaderGuardWithRoot(self): argument
4243 self.assertEquals('CPPLINT_CPPLINT_TEST_HEADER_H_',
4253 self.assertEquals('CPPLINT_TEST_HEADER_H_',
4261 self.assertEquals('CPPLINT_TEST_HEADER_H_',
4267 self.assertEquals('CPPLINT_TEST_HEADER_H_',
4275 self.assertEquals('CPPLINT_TEST_HEADER_H_',
4280 self.assertEquals('CPPLINT_CPPLINT_TEST_HEADER_H_',
4293 self.assertIsNotNone(styleguide_parent_path)
4297 self.assertEquals('%sCPPLINT_CPPLINT_TEST_HEADER_H_' %(expected_prefix),
4308 self.assertEquals('CPPLINT_CPPLINT_TEST_HEADER_H_',
4314 self.assertEquals('%sCPPLINT_CPPLINT_TEST_HEADER_H_' %(expected_prefix),
4322 def testPathSplitToList(self): argument
4323 self.assertEquals([''],
4326 self.assertEquals(['.'],
4329 self.assertEquals(['..'],
4332 self.assertEquals(['..', 'a', 'b'],
4335 self.assertEquals(['a', 'b', 'c', 'd'],
4338 def testBuildInclude(self): argument
4340 self.TestLint('#include "foo.h"',
4343 self.TestLint('#include "Python.h"', '')
4344 self.TestLint('#include "lua.h"', '')
4346 def testBuildPrintfFormat(self): argument
4347 error_collector = ErrorCollector(self.assert_)
4355 self.assertEquals(
4361 error_collector = ErrorCollector(self.assert_)
4370 self.assertEquals('', error_collector.Results())
4372 def testRuntimePrintfFormat(self): argument
4373 self.TestLint(
4378 self.TestLint(
4383 self.TestLint(
4388 self.TestLint(
4393 self.TestLint(
4398 self.TestLint(
4403 def TestLintLogCodeOnError(self, code, expected_message): argument
4405 result = self.PerformSingleLineLint(code)
4407 self.fail('For code: "%s"\nGot: "%s"\nExpected: "%s"'
4410 def testBuildStorageClass(self): argument
4423 self.TestLint('const int static foo = 5;',
4426 self.TestLint('char static foo;',
4429 self.TestLint('double const static foo = 2.0;',
4432 self.TestLint('uint64 typedef unsigned_long_long;',
4435 self.TestLint('int register foo = 0;',
4460 self.TestLintLogCodeOnError(
4465 self.TestLintLogCodeOnError(
4469 def testLegalCopyright(self): argument
4480 error_collector = ErrorCollector(self.assert_)
4482 self.assertEquals(
4486 error_collector = ErrorCollector(self.assert_)
4491 self.assertEquals(
4496 error_collector = ErrorCollector(self.assert_)
4500 self.fail('Unexpected error: %s' % message)
4502 error_collector = ErrorCollector(self.assert_)
4509 self.fail('Unexpected error: %s' % message)
4511 def testInvalidIncrement(self): argument
4512 self.TestLint('*count++;',
4516 def testSnprintfSize(self): argument
4517 self.TestLint('vsnprintf(NULL, 0, format)', '')
4518 self.TestLint('snprintf(fisk, 1, format)',
4523 def Helper(self, package, extension, lines, count): argument
4538 collector = ErrorCollector(self.assert_)
4541 self.assertEquals(count, len(error_list), error_list)
4543 def TestCxx11Feature(self, code, expected_error): argument
4545 collector = ErrorCollector(self.assert_)
4549 self.assertEquals(expected_error, collector.Results())
4551 def testBlockedHeaders(self): argument
4552 self.TestCxx11Feature('#include <tr1/regex>',
4555 self.TestCxx11Feature('#include <mutex>',
4559 def testBlockedClasses(self): argument
4560 self.TestCxx11Feature('std::alignment_of<T>',
4566 self.TestCxx11Feature('std::alignment_offer', '')
4567 self.TestCxx11Feature('mystd::alignment_of', '')
4568 self.TestCxx11Feature('std::binomial_distribution', '')
4570 def testBlockedFunctions(self): argument
4571 self.TestCxx11Feature('std::alignment_of<int>',
4581 self.TestCxx11Feature('static_pointer_cast<Base>(my_shared_ptr)', '')
4582 self.TestCxx11Feature('std::declval<T>()', '')
4584 def testExplicitMakePair(self): argument
4585 self.TestLint('make_pair', '')
4586 self.TestLint('make_pair(42, 42)', '')
4587 self.TestLint('make_pair<',
4592 self.TestLint('make_pair <',
4597 self.TestLint('my_make_pair<int, int>', '')
4601 def TestCxx14Feature(self, code, expected_error): argument
4603 collector = ErrorCollector(self.assert_)
4607 self.assertEquals(expected_error, collector.Results())
4609 def testBlockedHeaders(self): argument
4610 self.TestCxx14Feature('#include <scoped_allocator>',
4613 self.TestCxx14Feature('#include <shared_mutex>',
4620 def testInit(self): argument
4628 self.assertEquals(lines, clean_lines.raw_lines)
4629 self.assertEquals(5, clean_lines.NumLines())
4631 self.assertEquals(['Line 1',
4638 self.assertEquals(['Line 1',
4645 def testInitEmpty(self): argument
4647 self.assertEquals([], clean_lines.raw_lines)
4648 self.assertEquals(0, clean_lines.NumLines())
4650 def testCollapseStrings(self): argument
4652 self.assertEquals('""', collapse('""')) # "" (empty)
4653 self.assertEquals('"""', collapse('"""')) # """ (bad)
4654 self.assertEquals('""', collapse('"xyz"')) # "xyz" (string)
4655 self.assertEquals('""', collapse('"\\\""')) # "\"" (string)
4656 self.assertEquals('""', collapse('"\'"')) # "'" (string)
4657 self.assertEquals('"\"', collapse('"\"')) # "\" (bad)
4658 self.assertEquals('""', collapse('"\\\\"')) # "\\" (string)
4659 self.assertEquals('"', collapse('"\\\\\\"')) # "\\\" (bad)
4660 self.assertEquals('""', collapse('"\\\\\\\\"')) # "\\\\" (string)
4662 self.assertEquals('\'\'', collapse('\'\'')) # '' (empty)
4663 self.assertEquals('\'\'', collapse('\'a\'')) # 'a' (char)
4664 self.assertEquals('\'\'', collapse('\'\\\'\'')) # '\'' (char)
4665 self.assertEquals('\'', collapse('\'\\\'')) # '\' (bad)
4666 self.assertEquals('', collapse('\\012')) # '\012' (char)
4667 self.assertEquals('', collapse('\\xfF0')) # '\xfF0' (char)
4668 self.assertEquals('', collapse('\\n')) # '\n' (char)
4669 self.assertEquals(r'\#', collapse('\\#')) # '\#' (bad)
4671 self.assertEquals('"" + ""', collapse('"\'" + "\'"'))
4672 self.assertEquals("'', ''", collapse("'\"', '\"'"))
4673 self.assertEquals('""[0b10]', collapse('"a\'b"[0b1\'0]'))
4675 self.assertEquals('42', collapse("4'2"))
4676 self.assertEquals('0b0101', collapse("0b0'1'0'1"))
4677 self.assertEquals('1048576', collapse("1'048'576"))
4678 self.assertEquals('0X100000', collapse("0X10'0000"))
4679 self.assertEquals('0004000000', collapse("0'004'000'000"))
4680 self.assertEquals('1.602176565e-19', collapse("1.602'176'565e-19"))
4681 self.assertEquals('\'\' + 0xffff', collapse("'i' + 0xf'f'f'f"))
4682 self.assertEquals('sizeof\'\' == 1', collapse("sizeof'x' == 1"))
4683 self.assertEquals('0x.03p100', collapse('0x.0\'3p1\'0\'0'))
4684 self.assertEquals('123.45', collapse('1\'23.4\'5'))
4686 self.assertEquals('StringReplace(body, "", "");',
4688 self.assertEquals('\'\' ""',
4694 def setUp(self): argument
4695 CpplintTestBase.setUp(self)
4696 self.include_state = cpplint._IncludeState()
4699 def testCheckNextIncludeOrder_OtherThenCpp(self): argument
4700 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4702 self.assertEqual('Found C++ system header after other header',
4703 self.include_state.CheckNextIncludeOrder(
4706 def testCheckNextIncludeOrder_CppThenC(self): argument
4707 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4709 self.assertEqual('Found C system header after C++ system header',
4710 self.include_state.CheckNextIncludeOrder(
4713 def testCheckNextIncludeOrder_LikelyThenCpp(self): argument
4714 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4716 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4719 def testCheckNextIncludeOrder_PossibleThenCpp(self): argument
4720 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4722 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4725 def testCheckNextIncludeOrder_CppThenLikely(self): argument
4726 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4729 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4732 def testCheckNextIncludeOrder_CppThenPossible(self): argument
4733 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4735 self.assertEqual('', self.include_state.CheckNextIncludeOrder(
4738 def testClassifyInclude(self): argument
4741 self.assertEqual(cpplint._C_SYS_HEADER,
4745 self.assertEqual(cpplint._CPP_SYS_HEADER,
4749 self.assertEqual(cpplint._CPP_SYS_HEADER,
4753 self.assertEqual(cpplint._OTHER_HEADER,
4758 self.assertEqual(cpplint._LIKELY_MY_HEADER,
4762 self.assertEqual(cpplint._LIKELY_MY_HEADER,
4766 self.assertEqual(cpplint._POSSIBLE_MY_HEADER,
4770 self.assertEqual(cpplint._OTHER_HEADER,
4775 def testTryDropCommonSuffixes(self): argument
4776 self.assertEqual('foo/foo', cpplint._DropCommonSuffixes('foo/foo-inl.h'))
4777 self.assertEqual('foo/bar/foo',
4779 self.assertEqual('foo/foo', cpplint._DropCommonSuffixes('foo/foo.cc'))
4780 self.assertEqual('foo/foo_unusualinternal',
4782 self.assertEqual('',
4784 self.assertEqual('test',
4787 def testRegression(self): argument
4798 self.TestLanguageRulesCheck('foo/foo.cc', Format(['"foo/foo.h"']), '')
4799 self.TestLanguageRulesCheck('foo/foo.cc', Format(['<stdio.h>']), '')
4800 self.TestLanguageRulesCheck('foo/foo.cc', Format(['<string>']), '')
4801 self.TestLanguageRulesCheck('foo/foo.cc', Format(['"foo/foo-inl.h"']), '')
4802 self.TestLanguageRulesCheck('foo/foo.cc', Format(['"bar/bar-inl.h"']), '')
4803 self.TestLanguageRulesCheck('foo/foo.cc', Format(['"bar/bar.h"']), '')
4806 self.TestLanguageRulesCheck('foo/foo.cc',
4817 self.TestLanguageRulesCheck(
4823 self.TestLanguageRulesCheck(
4828 self.TestLanguageRulesCheck(
4840 self.TestLanguageRulesCheck('foo/foo.cc',
4843 self.TestLanguageRulesCheck('foo/foo.cc',
4847 self.TestLanguageRulesCheck('foo/internal/foo.cc',
4852 self.TestLanguageRulesCheck('foo/internal/foo.cc',
4856 self.TestLanguageRulesCheck('foo/foo.cc',
4865 self.TestLanguageRulesCheck('foo/foo.cc',
4872 self.TestLanguageRulesCheck('a/a.cc',
4882 self.TestLanguageRulesCheck('a/a.cc',
4891 self.TestLanguageRulesCheck(
4899 self.TestLanguageRulesCheck(
4907 self.TestLanguageRulesCheck(
4919 self.TestLanguageRulesCheck('foo/foo.cc',
4926 def setUp(self): argument
4928 self.old_normal_trigger = cpplint._FunctionState._NORMAL_TRIGGER
4929 self.old_test_trigger = cpplint._FunctionState._TEST_TRIGGER
4934 def tearDown(self): argument
4935 cpplint._FunctionState._NORMAL_TRIGGER = self.old_normal_trigger
4936 cpplint._FunctionState._TEST_TRIGGER = self.old_test_trigger
4938 def TestFunctionLengthsCheck(self, code, expected_message): argument
4945 self.assertEquals(expected_message,
4946 self.PerformFunctionLengthsCheck(code))
4948 def TriggerLines(self, error_level): argument
4959 def TestLines(self, error_level): argument
4970 def TestFunctionLengthCheckDefinition(self, lines, error_level): argument
4977 trigger_level = self.TriggerLines(cpplint._VerboseLevel())
4978 self.TestFunctionLengthsCheck(
4979 'void test(int x)' + self.FunctionBody(lines),
4986 def TestFunctionLengthCheckDefinitionOK(self, lines): argument
4992 self.TestFunctionLengthsCheck(
4993 'void test(int x)' + self.FunctionBody(lines),
4996 def TestFunctionLengthCheckAtErrorLevel(self, error_level): argument
5002 self.TestFunctionLengthCheckDefinition(self.TriggerLines(error_level),
5005 def TestFunctionLengthCheckBelowErrorLevel(self, error_level): argument
5011 self.TestFunctionLengthCheckDefinition(self.TriggerLines(error_level)-1,
5014 def TestFunctionLengthCheckAboveErrorLevel(self, error_level): argument
5020 self.TestFunctionLengthCheckDefinition(self.TriggerLines(error_level)+1,
5023 def FunctionBody(self, number_of_lines): argument
5026 def FunctionBodyWithBlankLines(self, number_of_lines): argument
5029 def FunctionBodyWithNoLints(self, number_of_lines): argument
5034 def testFunctionLengthCheckDeclaration(self): argument
5035 self.TestFunctionLengthsCheck(
5039 def testFunctionLengthCheckDeclarationWithBlockFollowing(self): argument
5040 self.TestFunctionLengthsCheck(
5042 + self.FunctionBody(66)), # Not a function definition
5045 def testFunctionLengthCheckClassDefinition(self): argument
5046 self.TestFunctionLengthsCheck( # Not a function definition
5047 'class Test' + self.FunctionBody(66) + ';',
5050 def testFunctionLengthCheckTrivial(self): argument
5051 self.TestFunctionLengthsCheck(
5055 def testFunctionLengthCheckEmpty(self): argument
5056 self.TestFunctionLengthsCheck(
5060 def testFunctionLengthCheckDefinitionBelowSeverity0(self): argument
5062 self.TestFunctionLengthCheckDefinitionOK(self.TriggerLines(0)-1)
5065 def testFunctionLengthCheckDefinitionAtSeverity0(self): argument
5067 self.TestFunctionLengthCheckDefinitionOK(self.TriggerLines(0))
5070 def testFunctionLengthCheckDefinitionAboveSeverity0(self): argument
5072 self.TestFunctionLengthCheckAboveErrorLevel(0)
5075 def testFunctionLengthCheckDefinitionBelowSeverity1v0(self): argument
5077 self.TestFunctionLengthCheckBelowErrorLevel(1)
5080 def testFunctionLengthCheckDefinitionAtSeverity1v0(self): argument
5082 self.TestFunctionLengthCheckAtErrorLevel(1)
5085 def testFunctionLengthCheckDefinitionBelowSeverity1(self): argument
5086 self.TestFunctionLengthCheckDefinitionOK(self.TriggerLines(1)-1)
5088 def testFunctionLengthCheckDefinitionAtSeverity1(self): argument
5089 self.TestFunctionLengthCheckDefinitionOK(self.TriggerLines(1))
5091 def testFunctionLengthCheckDefinitionAboveSeverity1(self): argument
5092 self.TestFunctionLengthCheckAboveErrorLevel(1)
5094 def testFunctionLengthCheckDefinitionSeverity1PlusBlanks(self): argument
5096 error_lines = self.TriggerLines(error_level) + 1
5097 trigger_level = self.TriggerLines(cpplint._VerboseLevel())
5098 self.TestFunctionLengthsCheck(
5099 'void test_blanks(int x)' + self.FunctionBody(error_lines),
5106 def testFunctionLengthCheckComplexDefinitionSeverity1(self): argument
5108 error_lines = self.TriggerLines(error_level) + 1
5109 trigger_level = self.TriggerLines(cpplint._VerboseLevel())
5110 self.TestFunctionLengthsCheck(
5113 + self.FunctionBody(error_lines)),
5121 def testFunctionLengthCheckDefinitionSeverity1ForTest(self): argument
5123 error_lines = self.TestLines(error_level) + 1
5124 trigger_level = self.TestLines(cpplint._VerboseLevel())
5125 self.TestFunctionLengthsCheck(
5126 'TEST_F(Test, Mutator)' + self.FunctionBody(error_lines),
5133 def testFunctionLengthCheckDefinitionSeverity1ForSplitLineTest(self): argument
5135 error_lines = self.TestLines(error_level) + 1
5136 trigger_level = self.TestLines(cpplint._VerboseLevel())
5137 self.TestFunctionLengthsCheck(
5140 + self.FunctionBody(error_lines)),
5148 def testFunctionLengthCheckDefinitionSeverity1ForBadTestDoesntBreak(self): argument
5150 error_lines = self.TestLines(error_level) + 1
5151 trigger_level = self.TestLines(cpplint._VerboseLevel())
5152 self.TestFunctionLengthsCheck(
5154 + self.FunctionBody(error_lines)),
5161 def testFunctionLengthCheckDefinitionSeverity1WithEmbeddedNoLints(self): argument
5163 error_lines = self.TriggerLines(error_level)+1
5164 trigger_level = self.TriggerLines(cpplint._VerboseLevel())
5165 self.TestFunctionLengthsCheck(
5166 'void test(int x)' + self.FunctionBodyWithNoLints(error_lines),
5173 def testFunctionLengthCheckDefinitionSeverity1WithNoLint(self): argument
5174 self.TestFunctionLengthsCheck(
5175 ('void test(int x)' + self.FunctionBody(self.TriggerLines(1))
5179 def testFunctionLengthCheckDefinitionBelowSeverity2(self): argument
5180 self.TestFunctionLengthCheckBelowErrorLevel(2)
5182 def testFunctionLengthCheckDefinitionSeverity2(self): argument
5183 self.TestFunctionLengthCheckAtErrorLevel(2)
5185 def testFunctionLengthCheckDefinitionAboveSeverity2(self): argument
5186 self.TestFunctionLengthCheckAboveErrorLevel(2)
5188 def testFunctionLengthCheckDefinitionBelowSeverity3(self): argument
5189 self.TestFunctionLengthCheckBelowErrorLevel(3)
5191 def testFunctionLengthCheckDefinitionSeverity3(self): argument
5192 self.TestFunctionLengthCheckAtErrorLevel(3)
5194 def testFunctionLengthCheckDefinitionAboveSeverity3(self): argument
5195 self.TestFunctionLengthCheckAboveErrorLevel(3)
5197 def testFunctionLengthCheckDefinitionBelowSeverity4(self): argument
5198 self.TestFunctionLengthCheckBelowErrorLevel(4)
5200 def testFunctionLengthCheckDefinitionSeverity4(self): argument
5201 self.TestFunctionLengthCheckAtErrorLevel(4)
5203 def testFunctionLengthCheckDefinitionAboveSeverity4(self): argument
5204 self.TestFunctionLengthCheckAboveErrorLevel(4)
5206 def testFunctionLengthCheckDefinitionBelowSeverity5(self): argument
5207 self.TestFunctionLengthCheckBelowErrorLevel(5)
5209 def testFunctionLengthCheckDefinitionAtSeverity5(self): argument
5210 self.TestFunctionLengthCheckAtErrorLevel(5)
5212 def testFunctionLengthCheckDefinitionAboveSeverity5(self): argument
5213 self.TestFunctionLengthCheckAboveErrorLevel(5)
5215 def testFunctionLengthCheckDefinitionHugeLines(self): argument
5217 self.TestFunctionLengthCheckDefinition(self.TriggerLines(10), 5)
5219 def testFunctionLengthNotDeterminable(self): argument
5221 self.TestFunctionLengthsCheck(
5226 self.TestFunctionLengthsCheck(
5230 self.TestFunctionLengthsCheck(
5235 def testFunctionLengthCheckWithNamespace(self): argument
5237 self.TestFunctionLengthsCheck(
5278 def setUp(self): argument
5279 self.lines = cpplint.CleansedLines(
5305 def testCloseExpression(self): argument
5322 (_, line, column) = cpplint.CloseExpression(self.lines, p[0], p[1])
5323 self.assertEquals((p[2], p[3]), (line, column))
5325 def testReverseCloseExpression(self): argument
5342 (_, line, column) = cpplint.ReverseCloseExpression(self.lines, p[0], p[1])
5343 self.assertEquals((p[2], p[3]), (line, column))
5348 def setUp(self): argument
5349 self.nesting_state = cpplint.NestingState()
5350 self.error_collector = ErrorCollector(self.assert_)
5352 def UpdateWithLines(self, lines): argument
5355 self.nesting_state.Update('test.cc',
5356 clean_lines, line, self.error_collector)
5358 def testEmpty(self): argument
5359 self.UpdateWithLines([])
5360 self.assertEquals(self.nesting_state.stack, [])
5362 def testNamespace(self): argument
5363 self.UpdateWithLines(['namespace {'])
5364 self.assertEquals(len(self.nesting_state.stack), 1)
5365 self.assertTrue(isinstance(self.nesting_state.stack[0],
5367 self.assertTrue(self.nesting_state.stack[0].seen_open_brace)
5368 self.assertEquals(self.nesting_state.stack[0].name, '')
5370 self.UpdateWithLines(['namespace outer { namespace inner'])
5371 self.assertEquals(len(self.nesting_state.stack), 3)
5372 self.assertTrue(self.nesting_state.stack[0].seen_open_brace)
5373 self.assertTrue(self.nesting_state.stack[1].seen_open_brace)
5374 self.assertFalse(self.nesting_state.stack[2].seen_open_brace)
5375 self.assertEquals(self.nesting_state.stack[0].name, '')
5376 self.assertEquals(self.nesting_state.stack[1].name, 'outer')
5377 self.assertEquals(self.nesting_state.stack[2].name, 'inner')
5379 self.UpdateWithLines(['{'])
5380 self.assertTrue(self.nesting_state.stack[2].seen_open_brace)
5382 self.UpdateWithLines(['}', '}}'])
5383 self.assertEquals(len(self.nesting_state.stack), 0)
5385 def testClass(self): argument
5386 self.UpdateWithLines(['class A {'])
5387 self.assertEquals(len(self.nesting_state.stack), 1)
5388 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5389 self.assertEquals(self.nesting_state.stack[0].name, 'A')
5390 self.assertFalse(self.nesting_state.stack[0].is_derived)
5391 self.assertEquals(self.nesting_state.stack[0].class_indent, 0)
5393 self.UpdateWithLines(['};',
5395 self.assertEquals(len(self.nesting_state.stack), 1)
5396 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5397 self.assertEquals(self.nesting_state.stack[0].name, 'B')
5398 self.assertTrue(self.nesting_state.stack[0].is_derived)
5400 self.UpdateWithLines(['};',
5403 self.assertEquals(len(self.nesting_state.stack), 1)
5404 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5405 self.assertEquals(self.nesting_state.stack[0].name, 'C')
5406 self.assertTrue(self.nesting_state.stack[0].is_derived)
5408 self.UpdateWithLines(['};',
5410 self.assertEquals(len(self.nesting_state.stack), 0)
5412 self.UpdateWithLines(['class D {', ' class E {'])
5413 self.assertEquals(len(self.nesting_state.stack), 2)
5414 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5415 self.assertEquals(self.nesting_state.stack[0].name, 'D')
5416 self.assertFalse(self.nesting_state.stack[0].is_derived)
5417 self.assertTrue(isinstance(self.nesting_state.stack[1], cpplint._ClassInfo))
5418 self.assertEquals(self.nesting_state.stack[1].name, 'E')
5419 self.assertFalse(self.nesting_state.stack[1].is_derived)
5420 self.assertEquals(self.nesting_state.stack[1].class_indent, 2)
5421 self.assertEquals(self.nesting_state.InnermostClass().name, 'E')
5423 self.UpdateWithLines(['}', '}'])
5424 self.assertEquals(len(self.nesting_state.stack), 0)
5426 def testClassAccess(self): argument
5427 self.UpdateWithLines(['class A {'])
5428 self.assertEquals(len(self.nesting_state.stack), 1)
5429 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5430 self.assertEquals(self.nesting_state.stack[0].access, 'private')
5432 self.UpdateWithLines([' public:'])
5433 self.assertEquals(self.nesting_state.stack[0].access, 'public')
5434 self.UpdateWithLines([' protracted:'])
5435 self.assertEquals(self.nesting_state.stack[0].access, 'public')
5436 self.UpdateWithLines([' protected:'])
5437 self.assertEquals(self.nesting_state.stack[0].access, 'protected')
5438 self.UpdateWithLines([' private:'])
5439 self.assertEquals(self.nesting_state.stack[0].access, 'private')
5441 self.UpdateWithLines([' struct B {'])
5442 self.assertEquals(len(self.nesting_state.stack), 2)
5443 self.assertTrue(isinstance(self.nesting_state.stack[1], cpplint._ClassInfo))
5444 self.assertEquals(self.nesting_state.stack[1].access, 'public')
5445 self.assertEquals(self.nesting_state.stack[0].access, 'private')
5447 self.UpdateWithLines([' protected :'])
5448 self.assertEquals(self.nesting_state.stack[1].access, 'protected')
5449 self.assertEquals(self.nesting_state.stack[0].access, 'private')
5451 self.UpdateWithLines([' }', '}'])
5452 self.assertEquals(len(self.nesting_state.stack), 0)
5454 def testStruct(self): argument
5455 self.UpdateWithLines(['struct A {'])
5456 self.assertEquals(len(self.nesting_state.stack), 1)
5457 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5458 self.assertEquals(self.nesting_state.stack[0].name, 'A')
5459 self.assertFalse(self.nesting_state.stack[0].is_derived)
5461 self.UpdateWithLines(['}',
5463 self.assertEquals(len(self.nesting_state.stack), 1)
5464 self.assertFalse(isinstance(self.nesting_state.stack[0],
5467 self.UpdateWithLines(['}'])
5468 self.assertEquals(len(self.nesting_state.stack), 0)
5470 def testPreprocessor(self): argument
5471 self.assertEquals(len(self.nesting_state.pp_stack), 0)
5472 self.UpdateWithLines(['#if MACRO1'])
5473 self.assertEquals(len(self.nesting_state.pp_stack), 1)
5474 self.UpdateWithLines(['#endif'])
5475 self.assertEquals(len(self.nesting_state.pp_stack), 0)
5477 self.UpdateWithLines(['#ifdef MACRO2'])
5478 self.assertEquals(len(self.nesting_state.pp_stack), 1)
5479 self.UpdateWithLines(['#else'])
5480 self.assertEquals(len(self.nesting_state.pp_stack), 1)
5481 self.UpdateWithLines(['#ifdef MACRO3'])
5482 self.assertEquals(len(self.nesting_state.pp_stack), 2)
5483 self.UpdateWithLines(['#elif MACRO4'])
5484 self.assertEquals(len(self.nesting_state.pp_stack), 2)
5485 self.UpdateWithLines(['#endif'])
5486 self.assertEquals(len(self.nesting_state.pp_stack), 1)
5487 self.UpdateWithLines(['#endif'])
5488 self.assertEquals(len(self.nesting_state.pp_stack), 0)
5490 self.UpdateWithLines(['#ifdef MACRO5',
5497 self.assertEquals(len(self.nesting_state.pp_stack), 0)
5498 self.assertEquals(len(self.nesting_state.stack), 1)
5499 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5500 self.assertEquals(self.nesting_state.stack[0].name, 'A')
5501 self.UpdateWithLines(['};'])
5502 self.assertEquals(len(self.nesting_state.stack), 0)
5504 self.UpdateWithLines(['class D',
5506 self.assertEquals(len(self.nesting_state.pp_stack), 1)
5507 self.assertEquals(len(self.nesting_state.stack), 1)
5508 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5509 self.assertEquals(self.nesting_state.stack[0].name, 'D')
5510 self.assertFalse(self.nesting_state.stack[0].is_derived)
5512 self.UpdateWithLines(['#elif MACRO8',
5514 self.assertEquals(len(self.nesting_state.stack), 1)
5515 self.assertEquals(self.nesting_state.stack[0].name, 'D')
5516 self.assertTrue(self.nesting_state.stack[0].is_derived)
5517 self.assertFalse(self.nesting_state.stack[0].seen_open_brace)
5519 self.UpdateWithLines(['#else',
5521 self.assertEquals(len(self.nesting_state.stack), 1)
5522 self.assertEquals(self.nesting_state.stack[0].name, 'D')
5523 self.assertFalse(self.nesting_state.stack[0].is_derived)
5524 self.assertTrue(self.nesting_state.stack[0].seen_open_brace)
5526 self.UpdateWithLines(['#endif'])
5527 self.assertEquals(len(self.nesting_state.pp_stack), 0)
5528 self.assertEquals(len(self.nesting_state.stack), 1)
5529 self.assertEquals(self.nesting_state.stack[0].name, 'D')
5530 self.assertFalse(self.nesting_state.stack[0].is_derived)
5531 self.assertFalse(self.nesting_state.stack[0].seen_open_brace)
5533 self.UpdateWithLines([';'])
5534 self.assertEquals(len(self.nesting_state.stack), 0)
5536 def testTemplate(self): argument
5537 self.UpdateWithLines(['template <T,',
5539 self.assertEquals(len(self.nesting_state.stack), 0)
5540 self.UpdateWithLines(['class A {'])
5541 self.assertEquals(len(self.nesting_state.stack), 1)
5542 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5543 self.assertEquals(self.nesting_state.stack[0].name, 'A')
5545 self.UpdateWithLines(['};',
5549 self.assertEquals(len(self.nesting_state.stack), 1)
5550 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5551 self.assertEquals(self.nesting_state.stack[0].name, 'C')
5552 self.UpdateWithLines([';'])
5553 self.assertEquals(len(self.nesting_state.stack), 0)
5555 self.UpdateWithLines(['class D : public Tmpl<E>'])
5556 self.assertEquals(len(self.nesting_state.stack), 1)
5557 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5558 self.assertEquals(self.nesting_state.stack[0].name, 'D')
5560 self.UpdateWithLines(['{', '};'])
5561 self.assertEquals(len(self.nesting_state.stack), 0)
5563 self.UpdateWithLines(['template <class F,',
5568 self.assertEquals(len(self.nesting_state.stack), 1)
5569 self.assertFalse(isinstance(self.nesting_state.stack[0],
5571 self.UpdateWithLines(['}',
5573 self.assertEquals(len(self.nesting_state.stack), 1)
5574 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5575 self.assertEquals(self.nesting_state.stack[0].name, 'K')
5577 def testTemplateInnerClass(self): argument
5578 self.UpdateWithLines(['class A {',
5580 self.assertEquals(len(self.nesting_state.stack), 1)
5581 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5583 self.UpdateWithLines([' template <class B>',
5586 self.assertEquals(len(self.nesting_state.stack), 2)
5587 self.assertTrue(isinstance(self.nesting_state.stack[1], cpplint._ClassInfo))
5589 def testArguments(self): argument
5590 self.UpdateWithLines(['class A {'])
5591 self.assertEquals(len(self.nesting_state.stack), 1)
5592 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5593 self.assertEquals(self.nesting_state.stack[0].name, 'A')
5594 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 0)
5596 self.UpdateWithLines([' void Func(',
5598 self.assertEquals(len(self.nesting_state.stack), 1)
5599 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5600 self.UpdateWithLines([' struct X *arg2);'])
5601 self.assertEquals(len(self.nesting_state.stack), 1)
5602 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 0)
5604 self.UpdateWithLines(['};'])
5605 self.assertEquals(len(self.nesting_state.stack), 0)
5607 self.UpdateWithLines(['struct B {'])
5608 self.assertEquals(len(self.nesting_state.stack), 1)
5609 self.assertTrue(isinstance(self.nesting_state.stack[0], cpplint._ClassInfo))
5610 self.assertEquals(self.nesting_state.stack[0].name, 'B')
5612 self.UpdateWithLines(['#ifdef MACRO',
5615 self.assertEquals(len(self.nesting_state.stack), 1)
5616 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5617 self.UpdateWithLines(['#else'])
5619 self.assertEquals(len(self.nesting_state.stack), 1)
5620 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 0)
5621 self.UpdateWithLines([' void Func(',
5623 self.assertEquals(len(self.nesting_state.stack), 1)
5624 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5626 self.UpdateWithLines(['#endif'])
5627 self.assertEquals(len(self.nesting_state.stack), 1)
5628 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5629 self.UpdateWithLines([' struct X *arg2);'])
5630 self.assertEquals(len(self.nesting_state.stack), 1)
5631 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 0)
5633 self.UpdateWithLines(['};'])
5634 self.assertEquals(len(self.nesting_state.stack), 0)
5636 def testInlineAssembly(self): argument
5637 self.UpdateWithLines(['void CopyRow_SSE2(const uint8* src, uint8* dst,',
5639 self.assertEquals(len(self.nesting_state.stack), 1)
5640 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 0)
5641 self.assertEquals(self.nesting_state.stack[-1].inline_asm, cpplint._NO_ASM)
5643 self.UpdateWithLines([' asm volatile ('])
5644 self.assertEquals(len(self.nesting_state.stack), 1)
5645 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5646 self.assertEquals(self.nesting_state.stack[-1].inline_asm,
5649 self.UpdateWithLines([' "sub %0,%1 \\n"',
5663 self.assertEquals(len(self.nesting_state.stack), 1)
5664 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5665 self.assertEquals(self.nesting_state.stack[-1].inline_asm,
5668 self.UpdateWithLines(['#if defined(__SSE2__)',
5670 self.assertEquals(len(self.nesting_state.stack), 1)
5671 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5672 self.assertEquals(self.nesting_state.stack[-1].inline_asm,
5675 self.UpdateWithLines(['#endif'])
5676 self.assertEquals(len(self.nesting_state.stack), 1)
5677 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 1)
5678 self.assertEquals(self.nesting_state.stack[-1].inline_asm,
5681 self.UpdateWithLines([' );'])
5682 self.assertEquals(len(self.nesting_state.stack), 1)
5683 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 0)
5684 self.assertEquals(self.nesting_state.stack[-1].inline_asm, cpplint._END_ASM)
5686 self.UpdateWithLines(['__asm {'])
5687 self.assertEquals(len(self.nesting_state.stack), 2)
5688 self.assertEquals(self.nesting_state.stack[-1].open_parentheses, 0)
5689 self.assertEquals(self.nesting_state.stack[-1].inline_asm,
5692 self.UpdateWithLines(['}'])
5693 self.assertEquals(len(self.nesting_state.stack), 1)
5695 self.UpdateWithLines(['}'])
5696 self.assertEquals(len(self.nesting_state.stack), 0)
5701 def setUp(self): argument
5702 self.this_dir_path = os.path.dirname(os.path.abspath(__file__))
5703 self.python_executable = sys.executable or 'python'
5704 self.cpplint_test_h = os.path.join(self.this_dir_path,
5707 def _runCppLint(self, *args): argument
5708 cpplint_abspath = os.path.join(self.this_dir_path, 'cpplint.py')
5710 cmd_line = [self.python_executable, cpplint_abspath] + \
5712 [ self.cpplint_test_h ]
5724 def testNonQuietWithErrors(self): argument
5726 (return_code, output) = self._runCppLint()
5727 self.assertEquals(1, return_code)
5729 self.assertIn("[legal/copyright]", output)
5730 self.assertIn("[build/header_guard]", output)
5732 self.assertIn("Done processing", output)
5733 self.assertIn("Total errors found:", output)
5735 def testQuietWithErrors(self): argument
5737 (return_code, output) = self._runCppLint('--quiet')
5738 self.assertEquals(1, return_code)
5739 self.assertIn("[legal/copyright]", output)
5740 self.assertIn("[build/header_guard]", output)
5742 self.assertIn("Done processing", output)
5743 self.assertIn("Total errors found:", output)
5745 def testNonQuietWithoutErrors(self): argument
5747 (return_code, output) = self._runCppLint('--filter=' +
5750 self.assertEquals(0, return_code, output)
5752 self.assertNotIn("[legal/copyright]", output)
5753 self.assertNotIn("[build/header_guard]", output)
5756 self.assertIn("Done processing", output)
5757 self.assertIn("Total errors found:", output)
5759 def testQuietWithoutErrors(self): argument
5761 (return_code, output) = self._runCppLint('--quiet',
5765 self.assertEquals(0, return_code, output)
5767 self.assertNotIn("[legal/copyright]", output)
5768 self.assertNotIn("[build/header_guard]", output)
5771 self.assertNotIn("Done processing", output)
5772 self.assertNotIn("Total errors found:", output)
5774 self.assertEquals("", output)