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

tools/push-to-trunk/common_includes.py

 #!/usr/bin/env python
 # Copyright 2013 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 174 matching lines @@
   try:
     if pipe:
       return subprocess.check_output(cmd_line, shell=True)
     else:
       return subprocess.check_call(cmd_line, shell=True)
   except subprocess.CalledProcessError:
     return None
 
 
 # Wrapper for side effects.
-class SideEffectHandler(object):
+class SideEffectHandler(object):  # pragma: no cover
   def Call(self, fun, *args, **kwargs):
     return fun(*args, **kwargs)
 
   def Command(self, cmd, args="", prefix="", pipe=True):
     return Command(cmd, args, prefix, pipe)
 
   def ReadLine(self):
     return sys.stdin.readline().strip()
 
   def ReadURL(self, url, params=None):
@@ skipping 57 matching lines @@
     # Skip step if requirement is not met.
     if self._requires and not self._state.get(self._requires):
       return
 
     print ">>> Step %d: %s" % (self._number, self._text)
     self.RunStep()
 
     # Persist state.
     TextToFile(json.dumps(self._state), state_file)
 
-  def RunStep(self):
+  def RunStep(self):  # pragma: no cover
     raise NotImplementedError
 
   def Retry(self, cb, retry_on=None, wait_plan=None):
     """ Retry a function.
     Params:
       cb: The function to retry.
       retry_on: A callback that takes the result of the function and returns
                 True if the function should be retried. A function throwing an
                 exception is always retried.
       wait_plan: A list of waiting delays between retries in seconds. The
                  maximum number of retries is len(wait_plan).
     """
     retry_on = retry_on or (lambda x: False)
     wait_plan = list(wait_plan or [])
     wait_plan.reverse()
     while True:
       got_exception = False
       try:
         result = cb()
       except NoRetryException, e:
         raise e
       except Exception:
         got_exception = True
       if got_exception or retry_on(result):
-        if not wait_plan:
+        if not wait_plan:  # pragma: no cover
           raise Exception("Retried too often. Giving up.")
         wait_time = wait_plan.pop()
         print "Waiting for %f seconds." % wait_time
         self._side_effect_handler.Sleep(wait_time)
         print "Retrying..."
       else:
         return result
 
   def ReadLine(self, default=None):
     # Don't prompt in forced mode.
@@ skipping 27 matching lines @@
   def GetDate(self):
     return self._side_effect_handler.GetDate()
 
   def Die(self, msg=""):
     if msg != "":
       print "Error: %s" % msg
     print "Exiting"
     raise Exception(msg)
 
   def DieNoManualMode(self, msg=""):
-    if not self._options.manual:
+    if not self._options.manual:  # pragma: no cover
       msg = msg or "Only available in manual mode."
       self.Die(msg)
 
   def Confirm(self, msg):
     print "%s [Y/n] " % msg,
     answer = self.ReadLine(default="Y")
     return answer == "" or answer == "Y" or answer == "y"
 
   def DeleteBranch(self, name):
     for line in self.GitBranch().splitlines():
       if re.match(r".*\s+%s$" % name, line):
         msg = "Branch %s exists, do you want to delete it?" % name
         if self.Confirm(msg):
           self.GitDeleteBranch(name)
           print "Branch %s deleted." % name
         else:
           msg = "Can't continue. Please delete branch %s and try again." % name
           self.Die(msg)
 
   def InitialEnvironmentChecks(self):
     # Cancel if this is not a git checkout.
-    if not os.path.exists(self._config[DOT_GIT_LOCATION]):
+    if not os.path.exists(self._config[DOT_GIT_LOCATION]):  # pragma: no cover
       self.Die("This is not a git checkout, this script won't work for you.")
 
     # Cancel if EDITOR is unset or not executable.
     if (self._options.requires_editor and (not os.environ.get("EDITOR") or
-        Command("which", os.environ["EDITOR"]) is None)):
+        Command("which", os.environ["EDITOR"]) is None)):  # pragma: no cover
       self.Die("Please set your EDITOR environment variable, you'll need it.")
 
   def CommonPrepare(self):
     # Check for a clean workdir.
-    if not self.GitIsWorkdirClean():
+    if not self.GitIsWorkdirClean():  # pragma: no cover
       self.Die("Workspace is not clean. Please commit or undo your changes.")
 
     # Persist current branch.
     self["current_branch"] = self.GitCurrentBranch()
 
     # Fetch unfetched revisions.
     self.GitSVNFetch()
 
   def PrepareBranch(self):
     # Get ahold of a safe temporary branch and check it out.
@@ skipping 111 matching lines @@
 
   def _Description(self):
     return None
 
   def _PrepareOptions(self, parser):
     pass
 
   def _ProcessOptions(self, options):
     return True
 
-  def _Steps(self):
+  def _Steps(self):  # pragma: no cover
     raise Exception("Not implemented.")
 
   def MakeOptions(self, args=None):
     parser = argparse.ArgumentParser(description=self._Description())
     parser.add_argument("-a", "--author", default="",
                         help="The author email used for rietveld.")
     parser.add_argument("-r", "--reviewer", default="",
                         help="The account name to be used for reviews.")
     parser.add_argument("-s", "--step",
                       help="Specify the step where to start work. Default: 0.",
                       default=0, type=int)
 
     self._PrepareOptions(parser)
 
-    if args is None:
+    if args is None:  # pragma: no cover
       options = parser.parse_args()
     else:
       options = parser.parse_args(args)
 
     # Process common options.
-    if options.step < 0:
+    if options.step < 0:  # pragma: no cover
       print "Bad step number %d" % options.step
       parser.print_help()
       return None
 
     # Defaults for options, common to all scripts.
     options.manual = getattr(options, "manual", True)
     options.force = getattr(options, "force", False)
 
     # Derived options.
     options.requires_editor = not options.force
@@ skipping 19 matching lines @@
     steps = []
     for (number, step_class) in enumerate(step_classes):
       steps.append(MakeStep(step_class, number, self._state, self._config,
                             options, self._side_effect_handler))
     for step in steps[options.step:]:
       step.Run()
     return 0
 
   def Run(self, args=None):
     return self.RunSteps(self._Steps(), args)