Suppress error handling for test coverage in push and merge scripts.

tools/push-to-trunk/merge_to_branch.py

 #!/usr/bin/env python
 # Copyright 2014 the V8 project authors. 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
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
@@ skipping 39 matching lines @@
 }
 
 
 class Preparation(Step):
   MESSAGE = "Preparation."
 
   def RunStep(self):
     if os.path.exists(self.Config(ALREADY_MERGING_SENTINEL_FILE)):
       if self._options.force:
         os.remove(self.Config(ALREADY_MERGING_SENTINEL_FILE))
-      elif self._options.step == 0:
+      elif self._options.step == 0:  # pragma: no cover
         self.Die("A merge is already in progress")
     open(self.Config(ALREADY_MERGING_SENTINEL_FILE), "a").close()
 
     self.InitialEnvironmentChecks()
     if self._options.revert_bleeding_edge:
       self["merge_to_branch"] = "bleeding_edge"
     elif self._options.branch:
       self["merge_to_branch"] = self._options.branch
-    else:
+    else:  # pragma: no cover
       self.Die("Please specify a branch to merge to")
 
     self.CommonPrepare()
     self.PrepareBranch()
 
 
 class CreateBranch(Step):
   MESSAGE = "Create a fresh branch for the patch."
 
   def RunStep(self):
     self.GitCreateBranch(self.Config(BRANCHNAME),
                          "svn/%s" % self["merge_to_branch"])
 
 
 class SearchArchitecturePorts(Step):
   MESSAGE = "Search for corresponding architecture ports."
 
   def RunStep(self):
     self["full_revision_list"] = list(OrderedDict.fromkeys(
         self._options.revisions))
     port_revision_list = []
     for revision in self["full_revision_list"]:
       # Search for commits which matches the "Port rXXX" pattern.
       git_hashes = self.GitLog(reverse=True, format="%H",
                                grep="Port r%d" % int(revision),
                                branch="svn/bleeding_edge")
       for git_hash in git_hashes.splitlines():
         svn_revision = self.GitSVNFindSVNRev(git_hash, "svn/bleeding_edge")
-        if not svn_revision:
+        if not svn_revision:  # pragma: no cover
           self.Die("Cannot determine svn revision for %s" % git_hash)
         revision_title = self.GitLog(n=1, format="%s", git_hash=git_hash)
 
         # Is this revision included in the original revision list?
         if svn_revision in self["full_revision_list"]:
           print("Found port of r%s -> r%s (already included): %s"
                 % (revision, svn_revision, revision_title))
         else:
           print("Found port of r%s -> r%s: %s"
                 % (revision, svn_revision, revision_title))
           port_revision_list.append(svn_revision)
 
     # Do we find any port?
     if len(port_revision_list) > 0:
       if self.Confirm("Automatically add corresponding ports (%s)?"
                       % ", ".join(port_revision_list)):
         #: 'y': Add ports to revision list.
         self["full_revision_list"].extend(port_revision_list)
 
 
 class FindGitRevisions(Step):
   MESSAGE = "Find the git revisions associated with the patches."
 
   def RunStep(self):
     self["patch_commit_hashes"] = []
     for revision in self["full_revision_list"]:
       next_hash = self.GitSVNFindGitHash(revision, "svn/bleeding_edge")
-      if not next_hash:
+      if not next_hash:  # pragma: no cover
         self.Die("Cannot determine git hash for r%s" % revision)
       self["patch_commit_hashes"].append(next_hash)
 
     # Stringify: [123, 234] -> "r123, r234"
     self["revision_list"] = ", ".join(map(lambda s: "r%s" % s,
                                       self["full_revision_list"]))
 
-    if not self["revision_list"]:
+    if not self["revision_list"]:  # pragma: no cover
       self.Die("Revision list is empty.")
 
     if self._options.revert:
       if not self._options.revert_bleeding_edge:
         self["new_commit_msg"] = ("Rollback of %s in %s branch."
             % (self["revision_list"], self["merge_to_branch"]))
       else:
         self["new_commit_msg"] = "Revert %s." % self["revision_list"]
     else:
       self["new_commit_msg"] = ("Merged %s into %s branch."
@@ skipping 80 matching lines @@
 
 class PrepareSVN(Step):
   MESSAGE = "Determine svn commit revision."
 
   def RunStep(self):
     if self._options.revert_bleeding_edge:
       return
     self.GitSVNFetch()
     commit_hash = self.GitLog(n=1, format="%H", grep=self["new_commit_msg"],
                               branch="svn/%s" % self["merge_to_branch"])
-    if not commit_hash:
+    if not commit_hash:  # pragma: no cover
       self.Die("Unable to map git commit to svn revision.")
     self["svn_revision"] = self.GitSVNFindSVNRev(commit_hash)
     print "subversion revision number is r%s" % self["svn_revision"]
 
 
 class TagRevision(Step):
   MESSAGE = "Create the tag."
 
   def RunStep(self):
     if self._options.revert_bleeding_edge:
@@ skipping 74 matching lines @@
       IncrementVersion,
       CommitLocal,
       UploadStep,
       CommitRepository,
       PrepareSVN,
       TagRevision,
       CleanUp,
     ]
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
   sys.exit(MergeToBranch(CONFIG).Run())