Presubmit tests: allow 100columns limit for .java files.

tests/presubmit_unittest.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Unit tests for presubmit_support.py and presubmit_canned_checks.py."""
 
 # pylint: disable=E1101,E1103
 
 import logging
@@ skipping 1480 matching lines @@
         'foo2', description2, self.fake_root_dir, None, 0, 0, None)
     input_api2 = self.MockInputApi(change2, committing)
     self.mox.ReplayAll()
 
     results1 = check(input_api1, presubmit.OutputApi)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
-  def ContentTest(self, check, content1, content2, error_type):
+  def ContentTest(self, check, content1, content1_path, content2,
+                  content2_path, error_type):
     """Runs a test of a content-checking rule.
 
       Args:
         check: the check to run.
         content1: content which is expected to pass the check.
+        content1_path: file path for content1.
         content2: content which is expected to fail the check.
+        content2_path: file path for content2.
         error_type: the type of the error expected for content2.
     """
     change1 = presubmit.Change(
         'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     input_api1.AffectedFiles(
         include_deletes=False,
         file_filter=mox.IgnoreArg()).AndReturn([affected_file])
+    affected_file.LocalPath().AndReturn(content1_path)
     affected_file.NewContents().AndReturn([
-        'ahoy',
+        'afoo',
         content1,
-        'hay',
-        'yer',
-        'ya'])
+        'bfoo',
+        'cfoo',
+        'dfoo'])
 
     change2 = presubmit.Change(
         'foo2', 'foo2\n', self.fake_root_dir, None, 0, 0, None)
     input_api2 = self.MockInputApi(change2, False)
 
     input_api2.AffectedFiles(
         include_deletes=False,
         file_filter=mox.IgnoreArg()).AndReturn([affected_file])
+    affected_file.LocalPath().AndReturn(content2_path)
     affected_file.NewContents().AndReturn([
-        'ahoy',
+        'dfoo',
         content2,
-        'hay',
-        'yer',
-        'ya'])
+        'efoo',
+        'ffoo',
+        'gfoo'])
     # It falls back to ChangedContents when there is a failure. This is an
     # optimization since NewContents() is much faster to execute than
     # ChangedContents().
     affected_file.ChangedContents().AndReturn([
         (42, content2),
-        (43, 'yer'),
-        (23, 'ya')])
+        (43, 'hfoo'),
+        (23, 'ifoo')])
     affected_file.LocalPath().AndReturn('foo.cc')
 
     self.mox.ReplayAll()
 
     results1 = check(input_api1, presubmit.OutputApi, None)
     self.assertEquals(results1, [])
     results2 = check(input_api2, presubmit.OutputApi, None)
     self.assertEquals(len(results2), 1)
     self.assertEquals(results2[0].__class__, error_type)
 
@@ skipping 102 matching lines @@
 
   def testCannedCheckDoNotSubmitInDescription(self):
     self.DescriptionTest(presubmit_canned_checks.CheckDoNotSubmitInDescription,
                          'Foo\nDO NOTSUBMIT', 'Foo\nDO NOT ' + 'SUBMIT',
                          presubmit.OutputApi.PresubmitError,
                          False)
 
   def testCannedCheckDoNotSubmitInFiles(self):
     self.ContentTest(
         lambda x,y,z: presubmit_canned_checks.CheckDoNotSubmitInFiles(x, y),
-        'DO NOTSUBMIT', 'DO NOT ' + 'SUBMIT',
+        'DO NOTSUBMIT', None, 'DO NOT ' + 'SUBMIT', None,
         presubmit.OutputApi.PresubmitError)
 
   def testCheckChangeHasNoStrayWhitespace(self):
     self.ContentTest(
         lambda x,y,z:
             presubmit_canned_checks.CheckChangeHasNoStrayWhitespace(x, y),
-        'Foo', 'Foo ',
+        'Foo', None, 'Foo ', None,
         presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckChangeHasOnlyOneEol(self):
     self.ReadFileTest(presubmit_canned_checks.CheckChangeHasOnlyOneEol,
                       "Hey!\nHo!\n", "Hey!\nHo!\n\n",
                       presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckChangeHasNoCR(self):
     self.ReadFileTest(presubmit_canned_checks.CheckChangeHasNoCR,
                       "Hey!\nHo!\n", "Hey!\r\nHo!\r\n",
                       presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckChangeHasNoCrAndHasOnlyOneEol(self):
     self.ReadFileTest(
         presubmit_canned_checks.CheckChangeHasNoCrAndHasOnlyOneEol,
         "Hey!\nHo!\n", "Hey!\nHo!\n\n",
         presubmit.OutputApi.PresubmitPromptWarning)
     self.mox.VerifyAll()
     self.ReadFileTest(
         presubmit_canned_checks.CheckChangeHasNoCrAndHasOnlyOneEol,
         "Hey!\nHo!\n", "Hey!\r\nHo!\r\n",
         presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckChangeTodoHasOwner(self):
     self.ContentTest(presubmit_canned_checks.CheckChangeTodoHasOwner,
-                     "TODO(foo): bar", "TODO: bar",
+                     "TODO(foo): bar", None, "TODO: bar", None,
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckChangeHasNoTabs(self):
     self.ContentTest(presubmit_canned_checks.CheckChangeHasNoTabs,
-                     'blah blah', 'blah\tblah',
+                     'blah blah', None, 'blah\tblah', None,
                      presubmit.OutputApi.PresubmitPromptWarning)
 
     # Make sure makefiles are ignored.
     change1 = presubmit.Change(
         'foo1', 'foo1\n', self.fake_root_dir, None, 0, 0, None)
     input_api1 = self.MockInputApi(change1, False)
     affected_file1 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file1.LocalPath().AndReturn('foo.cc')
     affected_file2 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file2.LocalPath().AndReturn('foo/Makefile')
     affected_file3 = self.mox.CreateMock(presubmit.SvnAffectedFile)
     affected_file3.LocalPath().AndReturn('makefile')
     # Only this one will trigger.
     affected_file4 = self.mox.CreateMock(presubmit.SvnAffectedFile)
+    affected_file1.LocalPath().AndReturn('foo.cc')
+    affected_file1.NewContents().AndReturn(['yo, '])
     affected_file4.LocalPath().AndReturn('makefile.foo')
-    affected_file1.NewContents().AndReturn(['yo, '])
+    affected_file4.LocalPath().AndReturn('makefile.foo')
     affected_file4.NewContents().AndReturn(['ye\t'])
     affected_file4.ChangedContents().AndReturn([(46, 'ye\t')])
     affected_file4.LocalPath().AndReturn('makefile.foo')
     affected_files = (affected_file1, affected_file2,
                       affected_file3, affected_file4)
 
     def test(file_filter, include_deletes):
       self.assertFalse(include_deletes)
       for x in affected_files:
         if file_filter(x):
           yield x
     # Override the mock of these functions.
     input_api1.FilterSourceFile = lambda x: x
     input_api1.AffectedFiles = test
     self.mox.ReplayAll()
 
     results1 = presubmit_canned_checks.CheckChangeHasNoTabs(input_api1,
         presubmit.OutputApi, None)
     self.assertEquals(len(results1), 1)
     self.assertEquals(results1[0].__class__,
         presubmit.OutputApi.PresubmitPromptWarning)
     self.assertEquals(results1[0]._long_text,
         'makefile.foo, line 46')
 
   def testCannedCheckLongLines(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
-    self.ContentTest(check, '0123456789', '01234567890',
+    self.ContentTest(check, '0123456789', None, '01234567890', None,
+                     presubmit.OutputApi.PresubmitPromptWarning)
+
+  def testCannedCheckJavaLongLines(self):
+    check = lambda x, y, _: presubmit_canned_checks.CheckLongLines(x, y)
+    self.ContentTest(check, 'A ' * 50, 'foo.java', 'A ' * 50 + 'B', 'foo.java',
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckLongLinesLF(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
-    self.ContentTest(check, '012345678\n', '0123456789\n',
+    self.ContentTest(check, '012345678\n', None, '0123456789\n', None,
                      presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckLongLinesMacro(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
     self.ContentTest(
         check,
         # Put a space in so it doesn't trigger long symbols. Allow 1/3 more.
         '#if 56 89 12 45',
+        None,
         '#if 56 89 12 456',
+        None,
         presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckLongLinesHttp(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
     self.ContentTest(
         check,
         ' http:// 0 23 5',
+        None,
         ' http:// 0 23 56',
+        None,
         presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCannedCheckLongLinesLongSymbol(self):
     check = lambda x, y, z: presubmit_canned_checks.CheckLongLines(x, y, 10, z)
     self.ContentTest(
         check,
         ' TUP5D_LoNG_SY ',
+        None,
         ' TUP5D_LoNG_SY5 ',
+        None,
         presubmit.OutputApi.PresubmitPromptWarning)
 
   def testCheckChangeSvnEolStyleCommit(self):
     # Test CheckSvnProperty at the same time.
     self.SvnPropertyTest(presubmit_canned_checks.CheckChangeSvnEolStyle,
                          'svn:eol-style', 'LF', '', True,
                          presubmit.OutputApi.PresubmitError, True)
 
   def testCheckChangeSvnEolStyleUpload(self):
     self.SvnPropertyTest(presubmit_canned_checks.CheckChangeSvnEolStyle,
@@ skipping 462 matching lines @@
 
   def testPanProjectChecks(self):
     # Make sure it accepts both list and tuples.
     change = presubmit.Change(
         'foo1', 'description1', self.fake_root_dir, None, 0, 0, None)
     input_api = self.MockInputApi(change, False)
     affected_file = self.mox.CreateMock(presubmit.SvnAffectedFile)
     for _ in range(3):
       input_api.AffectedFiles(file_filter=mox.IgnoreArg(), include_deletes=False
           ).AndReturn([affected_file])
+      affected_file.LocalPath()
       affected_file.NewContents().AndReturn('Hey!\nHo!\nHey!\nHo!\n\n')
     affected_file.ChangedContents().AndReturn([
         (0, 'Hey!\n'),
         (1, 'Ho!\n'),
         (2, 'Hey!\n'),
         (3, 'Ho!\n'),
         (4, '\n')])
     for _ in range(5):
       affected_file.LocalPath().AndReturn('hello.py')
     input_api.AffectedSourceFiles(mox.IgnoreArg()).AndReturn([affected_file])
@@ skipping 13 matching lines @@
         owners_check=True)
     self.assertEqual(1, len(results))
     self.assertEqual(
         'Found line ending with white spaces in:', results[0]._message)
     self.checkstdout('')
 
 
 if __name__ == '__main__':
   import unittest
   unittest.main()