Fix svn delete handling (again).

tests/patch_test.py

 #!/usr/bin/env python
 # Copyright (c) 2011 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 patch.py."""
 
 import logging
 import os
 import posixpath
@@ skipping 11 matching lines @@
   def _check_patch(self,
       p,
       filename,
       diff,
       source_filename=None,
       is_binary=False,
       is_delete=False,
       is_git_diff=False,
       is_new=False,
       patchlevel=0,
-      svn_properties=None):
+      svn_properties=None,
+      nb_hunks=None):
     svn_properties = svn_properties or []
     self.assertEquals(p.filename, filename)
     self.assertEquals(p.source_filename, source_filename)
     self.assertEquals(p.is_binary, is_binary)
     self.assertEquals(p.is_delete, is_delete)
     if hasattr(p, 'is_git_diff'):
       self.assertEquals(p.is_git_diff, is_git_diff)
     self.assertEquals(p.is_new, is_new)
     if hasattr(p, 'patchlevel'):
       self.assertEquals(p.patchlevel, patchlevel)
     if diff:
       if is_binary:
         self.assertEquals(p.get(), diff)
       else:
         self.assertEquals(p.get(True), diff)
-    if hasattr(p, 'svn_properties'):
-      self.assertEquals(p.svn_properties, svn_properties)
+    if hasattr(p, 'hunks'):
+      self.assertEquals(len(p.hunks), nb_hunks)
+    else:
+      self.assertEquals(None, nb_hunks)
 
   def testFilePatchDelete(self):
     p = patch.FilePatchDelete('foo', False)
     self._check_patch(p, 'foo', None, is_delete=True)
 
   def testFilePatchDeleteBin(self):
     p = patch.FilePatchDelete('foo', True)
     self._check_patch(p, 'foo', None, is_delete=True, is_binary=True)
 
   def testFilePatchBinary(self):
     p = patch.FilePatchBinary('foo', 'data', [], is_new=False)
     self._check_patch(p, 'foo', 'data', is_binary=True)
 
   def testFilePatchBinaryNew(self):
     p = patch.FilePatchBinary('foo', 'data', [], is_new=True)
     self._check_patch(p, 'foo', 'data', is_binary=True, is_new=True)
 
   def testFilePatchDiff(self):
     p = patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, [])
-    self._check_patch(p, 'chrome/file.cc', RAW.PATCH)
+    self._check_patch(p, 'chrome/file.cc', RAW.PATCH, nb_hunks=1)
 
   def testFilePatchDiffHeaderMode(self):
     p = patch.FilePatchDiff('git_cl/git-cl', GIT.MODE_EXE, [])
     self._check_patch(
         p, 'git_cl/git-cl', GIT.MODE_EXE, is_git_diff=True, patchlevel=1,
-        svn_properties=[('svn:executable', '*')])
+        svn_properties=[('svn:executable', '*')], nb_hunks=0)
 
   def testFilePatchDiffHeaderModeIndex(self):
     p = patch.FilePatchDiff('git_cl/git-cl', GIT.MODE_EXE_JUNK, [])
     self._check_patch(
         p, 'git_cl/git-cl', GIT.MODE_EXE_JUNK, is_git_diff=True, patchlevel=1,
-        svn_properties=[('svn:executable', '*')])
+        svn_properties=[('svn:executable', '*')], nb_hunks=0)
 
   def testFilePatchDiffSvnNew(self):
     # The code path is different for git and svn.
     p = patch.FilePatchDiff('foo', RAW.NEW, [])
-    self._check_patch(p, 'foo', RAW.NEW, is_new=True)
+    self._check_patch(p, 'foo', RAW.NEW, is_new=True, nb_hunks=1)
 
   def testFilePatchDiffGitNew(self):
     # The code path is different for git and svn.
     p = patch.FilePatchDiff('foo', GIT.NEW, [])
     self._check_patch(
-        p, 'foo', GIT.NEW, is_new=True, is_git_diff=True, patchlevel=1)
+        p, 'foo', GIT.NEW, is_new=True, is_git_diff=True, patchlevel=1,
+        nb_hunks=1)
 
-  def testValidSvn(self):
+  def testSvn(self):
     # Should not throw.
     p = patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, [])
     lines = RAW.PATCH.splitlines(True)
     header = ''.join(lines[:4])
     hunks = ''.join(lines[4:])
     self.assertEquals(header, p.diff_header)
     self.assertEquals(hunks, p.diff_hunks)
     self.assertEquals(RAW.PATCH, p.get(True))
     self.assertEquals(RAW.PATCH, p.get(False))
 
-  def testValidSvnNew(self):
+  def testSvnNew(self):
     p = patch.FilePatchDiff('chrome/file.cc', RAW.MINIMAL_NEW, [])
     self.assertEquals(RAW.MINIMAL_NEW, p.diff_header)
     self.assertEquals('', p.diff_hunks)
     self.assertEquals(RAW.MINIMAL_NEW, p.get(True))
     self.assertEquals(RAW.MINIMAL_NEW, p.get(False))
 
-  def testValidSvnDelete(self):
+  def testSvnDelete(self):
     p = patch.FilePatchDiff('chrome/file.cc', RAW.MINIMAL_DELETE, [])
     self.assertEquals(RAW.MINIMAL_DELETE, p.diff_header)
     self.assertEquals('', p.diff_hunks)
     self.assertEquals(RAW.MINIMAL_DELETE, p.get(True))
     self.assertEquals(RAW.MINIMAL_DELETE, p.get(False))
 
-  def testValidSvnRename(self):
+  def testSvnRename(self):
     p = patch.FilePatchDiff('file_b', RAW.MINIMAL_RENAME, [])
     self.assertEquals(RAW.MINIMAL_RENAME, p.diff_header)
     self.assertEquals('', p.diff_hunks)
     self.assertEquals(RAW.MINIMAL_RENAME, p.get(True))
     self.assertEquals('--- file_b\n+++ file_b\n', p.get(False))
 
   def testRelPath(self):
     patches = patch.PatchSet([
         patch.FilePatchDiff('pp', GIT.COPY, []),
         patch.FilePatchDiff(
@@ skipping 55 matching lines @@
     mangled_patch = RAW.PATCH.replace('chrome/', 'chrome\\')
     patches = patch.PatchSet([
         patch.FilePatchDiff('chrome\\file.cc', mangled_patch, []),
         patch.FilePatchDelete('other\\place\\foo', True),
     ])
     expected = ['chrome/file.cc', 'other/place/foo']
     self.assertEquals(expected, patches.filenames)
     self.assertEquals(RAW.PATCH, patches.patches[0].get(True))
     self.assertEquals(RAW.PATCH, patches.patches[0].get(False))
 
+  def testTwoHunks(self):
+    name = 'chrome/app/generated_resources.grd'
+    p = patch.FilePatchDiff(name, RAW.TWO_HUNKS, [])
+    self._check_patch(p, name, RAW.TWO_HUNKS, nb_hunks=2)
+
+  def testGitThreeHunks(self):
+    p = patch.FilePatchDiff('presubmit_support.py', GIT.FOUR_HUNKS, [])
+    self._check_patch(
+        p, 'presubmit_support.py', GIT.FOUR_HUNKS, is_git_diff=True,
+        patchlevel=1,
+        nb_hunks=4)
+
   def testDelete(self):
     p = patch.FilePatchDiff('tools/clang_check/README.chromium', RAW.DELETE, [])
     self._check_patch(
-        p, 'tools/clang_check/README.chromium', RAW.DELETE, is_delete=True)
+        p, 'tools/clang_check/README.chromium', RAW.DELETE, is_delete=True,
+        nb_hunks=1)
+
+  def testDelete2(self):
+    name = 'browser/extensions/extension_sidebar_api.cc'
+    p = patch.FilePatchDiff(name, RAW.DELETE2, [])
+    self._check_patch(p, name, RAW.DELETE2, is_delete=True, nb_hunks=1)
 
   def testGitDelete(self):
     p = patch.FilePatchDiff('tools/clang_check/README.chromium', GIT.DELETE, [])
     self._check_patch(
         p, 'tools/clang_check/README.chromium', GIT.DELETE, is_delete=True,
-        is_git_diff=True, patchlevel=1)
+        is_git_diff=True, patchlevel=1, nb_hunks=1)
 
   def testGitRename(self):
     p = patch.FilePatchDiff('tools/run_local_server.sh', GIT.RENAME, [])
-    self._check_patch(p, 'tools/run_local_server.sh', GIT.RENAME,
-        is_git_diff=True, patchlevel=1,
-        source_filename='tools/run_local_server.PY', is_new=True)
+    self._check_patch(
+        p,
+        'tools/run_local_server.sh',
+        GIT.RENAME,
+        is_git_diff=True,
+        patchlevel=1,
+        source_filename='tools/run_local_server.PY',
+        is_new=True,
+        nb_hunks=0)
 
   def testGitRenamePartial(self):
     p = patch.FilePatchDiff(
         'chromeos/views/webui_menu_widget.h', GIT.RENAME_PARTIAL, [])
     self._check_patch(
-        p, 'chromeos/views/webui_menu_widget.h', GIT.RENAME_PARTIAL,
-        source_filename='chromeos/views/DOMui_menu_widget.h', is_git_diff=True,
-        patchlevel=1, is_new=True)
+        p,
+        'chromeos/views/webui_menu_widget.h',
+        GIT.RENAME_PARTIAL,
+        source_filename='chromeos/views/DOMui_menu_widget.h',
+        is_git_diff=True,
+        patchlevel=1,
+        is_new=True,
+        nb_hunks=1)
 
   def testGitCopy(self):
     p = patch.FilePatchDiff('pp', GIT.COPY, [])
-    self._check_patch(p, 'pp', GIT.COPY, is_git_diff=True, patchlevel=1,
-        source_filename='PRESUBMIT.py', is_new=True)
+    self._check_patch(
+        p, 'pp', GIT.COPY, is_git_diff=True, patchlevel=1,
+        source_filename='PRESUBMIT.py', is_new=True, nb_hunks=0)
 
   def testOnlyHeader(self):
     p = patch.FilePatchDiff('file_a', RAW.MINIMAL, [])
-    self._check_patch(p, 'file_a', RAW.MINIMAL)
+    self._check_patch(p, 'file_a', RAW.MINIMAL, nb_hunks=0)
 
   def testSmallest(self):
     p = patch.FilePatchDiff('file_a', RAW.NEW_NOT_NULL, [])
-    self._check_patch(p, 'file_a', RAW.NEW_NOT_NULL)
+    self._check_patch(p, 'file_a', RAW.NEW_NOT_NULL, is_new=True, nb_hunks=1)
 
   def testRenameOnlyHeader(self):
     p = patch.FilePatchDiff('file_b', RAW.MINIMAL_RENAME, [])
     self._check_patch(
-        p, 'file_b', RAW.MINIMAL_RENAME, source_filename='file_a', is_new=True)
+        p, 'file_b', RAW.MINIMAL_RENAME, source_filename='file_a', is_new=True,
+        nb_hunks=0)
 
   def testGitCopyPartial(self):
     p = patch.FilePatchDiff('wtf2', GIT.COPY_PARTIAL, [])
     self._check_patch(
         p, 'wtf2', GIT.COPY_PARTIAL, source_filename='wtf', is_git_diff=True,
-        patchlevel=1, is_new=True)
+        patchlevel=1, is_new=True, nb_hunks=1)
 
   def testGitCopyPartialAsSvn(self):
     p = patch.FilePatchDiff('wtf2', GIT.COPY_PARTIAL, [])
     # TODO(maruel): Improve processing.
     diff = (
         'diff --git a/wtf2 b/wtf22\n'
         'similarity index 98%\n'
         'copy from wtf2\n'
         'copy to wtf22\n'
         'index 79fbaf3..3560689 100755\n'
         '--- a/wtf2\n'
         '+++ b/wtf22\n'
         '@@ -1,4 +1,4 @@\n'
         '-#!/usr/bin/env python\n'
         '+#!/usr/bin/env python1.3\n'
         ' # Copyright (c) 2010 The Chromium Authors. All rights reserved.\n'
         ' # blah blah blah as\n'
         ' # found in the LICENSE file.\n')
     self.assertEquals(diff, p.get(False))
 
   def testGitNewExe(self):
     p = patch.FilePatchDiff('natsort_test.py', GIT.NEW_EXE, [])
     self._check_patch(
-        p, 'natsort_test.py', GIT.NEW_EXE, is_new=True, is_git_diff=True,
-        patchlevel=1, svn_properties=[('svn:executable', '*')])
+        p,
+        'natsort_test.py',
+        GIT.NEW_EXE,
+        is_new=True,
+        is_git_diff=True,
+        patchlevel=1,
+        svn_properties=[('svn:executable', '*')],
+        nb_hunks=1)
 
   def testGitNewMode(self):
     p = patch.FilePatchDiff('natsort_test.py', GIT.NEW_MODE, [])
     self._check_patch(
         p, 'natsort_test.py', GIT.NEW_MODE, is_new=True, is_git_diff=True,
-        patchlevel=1)
+        patchlevel=1, nb_hunks=1)
 
   def testPatchsetOrder(self):
     # Deletes must be last.
     # File renames/move/copy must be first.
     patches = [
         patch.FilePatchDiff('chrome/file.cc', RAW.PATCH, []),
         patch.FilePatchDiff(
             'tools\\clang_check/README.chromium', GIT.DELETE, []),
         patch.FilePatchDiff('tools/run_local_server.sh', GIT.RENAME, []),
         patch.FilePatchDiff(
@@ skipping 168 matching lines @@
       self.fail()
     except patch.UnsupportedPatchFormat:
       pass
 
 
 if __name__ == '__main__':
   logging.basicConfig(level=
       [logging.WARNING, logging.INFO, logging.DEBUG][
         min(2, sys.argv.count('-v'))])
   unittest.main()