Update cpplint.py to #150:...

cpplint/cpplint_unittest.py

 #!/usr/bin/python2.4
 # -*- coding: utf-8; -*-
 #
 # Copyright (c) 2009 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #    * Redistributions of source code must retain the above copyright
@@ skipping 28 matching lines @@
 import re
 import unittest
 import cpplint
 
 
 # This class works as an error collector and replaces cpplint.Error
 # function for the unit tests.  We also verify each category we see
 # is in cpplint._ERROR_CATEGORIES, to help keep that list up to date.
 class ErrorCollector:
   # These are a global list, covering all categories seen ever.
-  _ERROR_CATEGORIES = [x.strip()    # get rid of leading whitespace
-                       for x in cpplint._ERROR_CATEGORIES.split()]
+  _ERROR_CATEGORIES = cpplint._ERROR_CATEGORIES
   _SEEN_ERROR_CATEGORIES = {}
 
   def __init__(self, assert_fn):
     """assert_fn: a function to call when we notice a problem."""
     self._assert_fn = assert_fn
     self._errors = []
+    cpplint.ResetNolintSuppressions()
 
-  def __call__(self, unused_filename, unused_linenum,
+  def __call__(self, unused_filename, linenum,
                category, confidence, message):
     self._assert_fn(category in self._ERROR_CATEGORIES,
                     'Message "%s" has category "%s",'
                     ' which is not in _ERROR_CATEGORIES' % (message, category))
     self._SEEN_ERROR_CATEGORIES[category] = 1
-    if cpplint._ShouldPrintError(category, confidence):
+    if cpplint._ShouldPrintError(category, confidence, linenum):
       self._errors.append('%s  [%s] [%d]' % (message, category, confidence))
 
   def Results(self):
     if len(self._errors) < 2:
       return ''.join(self._errors)  # Most tests expect to have a string.
     else:
       return self._errors  # Let's give a list if there is more than one.
 
   def ResultList(self):
     return self._errors
@@ skipping 213 matching lines @@
         '//   https://g' + ('o' * 100) + 'gle.com/',
         '')
     self.TestLint(
         '//   https://g' + ('o' * 60) + 'gle.com/ and some comments',
         'Lines should be <= 80 characters long'
         '  [whitespace/line_length] [2]')
     self.TestLint(
         '// Read https://g' + ('o' * 60) + 'gle.com/' ,
         '')
 
+  # Test error suppression annotations.
+  def testErrorSuppression(self):
+    # Two errors on same line:
+    self.TestLint(
+        'long a = (int64) 65;',
+        ['Using C-style cast.  Use static_cast<int64>(...) instead'
+         '  [readability/casting] [4]',
+         'Use int16/int64/etc, rather than the C type long'
+         '  [runtime/int] [4]',
+         ])
+    # One category of error suppressed:
+    self.TestLint(
+        'long a = (int64) 65;  // NOLINT(runtime/int)',
+        'Using C-style cast.  Use static_cast<int64>(...) instead'
+        '  [readability/casting] [4]')
+    # All categories suppressed: (two aliases)
+    self.TestLint('long a = (int64) 65;  // NOLINT', '')
+    self.TestLint('long a = (int64) 65;  // NOLINT(*)', '')
+    # Malformed NOLINT directive:
+    self.TestLint(
+        'long a = 65;  // NOLINT(foo)',
+         ['Unknown NOLINT error category: foo'
+          '  [readability/nolint] [5]',
+          'Use int16/int64/etc, rather than the C type long  [runtime/int] [4]',
+          ])
+    # Irrelevant NOLINT directive has no effect:
+    self.TestLint(
+        'long a = 65;  // NOLINT(readability/casting)',
+         'Use int16/int64/etc, rather than the C type long'
+         '  [runtime/int] [4]')
+
+
   # Test Variable Declarations.
   def testVariableDeclarations(self):
     self.TestLint(
         'long a = 65;',
         'Use int16/int64/etc, rather than the C type long'
         '  [runtime/int] [4]')
     self.TestLint(
         'long double b = 65.0;',
         '')
     self.TestLint(
@@ skipping 263 matching lines @@
         '  [build/include_what_you_use] [4]')
     self.TestIncludeWhatYouUse(
         '''#include "base/foobar.h"
            bool foobar = min<int>(0,1);
         ''',
         'Add #include <algorithm> for min  [build/include_what_you_use] [4]')
     self.TestIncludeWhatYouUse(
         'void a(const string &foobar);',
         'Add #include <string> for string  [build/include_what_you_use] [4]')
     self.TestIncludeWhatYouUse(
+        'void a(const std::string &foobar);',
+        'Add #include <string> for string  [build/include_what_you_use] [4]')
+    self.TestIncludeWhatYouUse(
+        'void a(const my::string &foobar);',
+        '')  # Avoid false positives on strings in other namespaces.
+    self.TestIncludeWhatYouUse(
         '''#include "base/foobar.h"
            bool foobar = swap(0,1);
         ''',
         'Add #include <algorithm> for swap  [build/include_what_you_use] [4]')
     self.TestIncludeWhatYouUse(
         '''#include "base/foobar.h"
            bool foobar = transform(a.begin(), a.end(), b.start(), Foo);
         ''',
         'Add #include <algorithm> for transform  '
         '[build/include_what_you_use] [4]')
@@ skipping 1029 matching lines @@
     self.TestLint(' char* one_space_indent = "public:";',
                   'Weird number of spaces at line-start.  '
                   'Are you using a 2-space indent?  [whitespace/indent] [3]')
     self.TestLint(' public:', '')
     self.TestLint('  public:', '')
     self.TestLint('   public:', '')
 
   def testLabel(self):
     self.TestLint('public:',
                   'Labels should always be indented at least one space.  '
-                  'If this is a member-initializer list in a constructor, '
-                  'the colon should be on the line after the definition '
-                  'header.  [whitespace/labels] [4]')
+                  'If this is a member-initializer list in a constructor or '
+                  'the base class list in a class definition, the colon should '
+                  'be on the following line.  [whitespace/labels] [4]')
     self.TestLint('  public:', '')
     self.TestLint('   public:', '')
     self.TestLint(' public:', '')
     self.TestLint('  public:', '')
     self.TestLint('   public:', '')
 
   def testNotALabel(self):
     self.TestLint('MyVeryLongNamespace::MyVeryLongClassName::', '')
 
   def testTab(self):
@@ skipping 324 matching lines @@
             '#ifndef header guard has wrong style, please use: %s'
             '  [build/header_guard] [5]' % expected_guard),
         error_collector.ResultList())
     self.assertEquals(
         0,
         error_collector.ResultList().count(
             '#endif line should be "#endif  // %s"'
             '  [build/header_guard] [5]' % expected_guard),
         error_collector.ResultList())
 
+    # Special case for flymake
+    error_collector = ErrorCollector(self.assert_)
+    cpplint.ProcessFileData('mydir/foo_flymake.h',
+                            'h', [], error_collector)
+    self.assertEquals(
+        1,
+        error_collector.ResultList().count(
+            'No #ifndef header guard found, suggested CPP variable is: %s'
+            '  [build/header_guard] [5]' % expected_guard),
+        error_collector.ResultList())
 
   def testBuildInclude(self):
     # Test that include statements have slashes in them.
     self.TestLint('#include "foo.h"',
                   'Include the directory when naming .h files'
                   '  [build/include] [4]')
 
   def testBuildPrintfFormat(self):
     self.TestLint(
         r'printf("\%%d", value);',
@@ skipping 734 matching lines @@
               virtual void goo();
            };''',
         '')
 
     self.TestMultiLineLint(
         # Line-ending :
         '''class Goo :
            public Foo {
               virtual void goo();
            };''',
-        'Labels should always be indented at least one space.  If this is a '
-        'member-initializer list in a constructor, the colon should be on the '
-        'line after the definition header.  [whitespace/labels] [4]')
+        'Labels should always be indented at least one space.  '
+        'If this is a member-initializer list in a constructor or '
+        'the base class list in a class definition, the colon should '
+        'be on the following line.  [whitespace/labels] [4]')
 
   def testNoDestructorWhenVirtualNeeded(self):
     self.TestMultiLineLintRE(
         '''class Foo {
              virtual void foo();
            };''',
         'The class Foo probably needs a virtual destructor')
 
   def testDestructorNonVirtualWhenVirtualNeeded(self):
     self.TestMultiLineLintRE(
@@ skipping 57 matching lines @@
     self.TestMultiLineLint(
         '''class Foo
            {
             virtual void foo();
            };''',
         ['{ should almost always be at the end of the previous line  '
          '[whitespace/braces] [4]',
          'The class Foo probably needs a virtual destructor due to having '
          'virtual method(s), one declared at line 2.  [runtime/virtual] [4]'])
 
+  def testSnprintfSize(self):
+    self.TestLint('vsnprintf(NULL, 0, format)', '')
+    self.TestLint('snprintf(fisk, 1, format)',
+                  'If you can, use sizeof(fisk) instead of 1 as the 2nd arg '
+                  'to snprintf.  [runtime/printf] [3]')
+
+
 # pylint: disable-msg=C6409
 def setUp():
   """ Runs before all tests are executed.
   """
   # Enable all filters, so we don't miss anything that is off by default.
   cpplint._DEFAULT_FILTERS = []
   cpplint._cpplint_state.SetFilters('')
 
 
 # pylint: disable-msg=C6409
@@ skipping 18 matching lines @@
   # we're running the full test suite: if we only run one test,
   # obviously we're not going to see all the error categories.  So we
   # only run VerifyAllCategoriesAreSeen() when no commandline flags
   # are passed in.
   global _run_verifyallcategoriesseen
   _run_verifyallcategoriesseen = (len(sys.argv) == 1)
 
   setUp()
   unittest.main()
   tearDown()