Allow purify scripts to take a --report_dir argument which specifies where th...

tools/purify/purify_test.py

 #!/bin/env python
 # Copyright (c) 2006-2008 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.
 
 # purify_test.py
 
 '''Runs an exe  through Purify and verifies that Purify was
 able to successfully instrument and run it.  The original purpose was 
 to be able to identify when a change to our code breaks our ability to Purify 
@@ skipping 41 matching lines @@
                            "(used for output filenames)")
     self._parser.add_option("", "--source_dir",
                             help="path to top of source tree for this build"
                                  "(used to normalize source paths in baseline)")
     self._parser.add_option("", "--exe",
                             help="The actual exe to instrument which is "
                                  "different than the program being run.  This "
                                  "is useful when the exe you want to purify is "
                                  "run by another script or program.")
     self._parser.add_option("", "--data_dir",
-                            help="path to where purify data files live")
+                            help="path where global purify data files live")
+    self._parser.add_option("", "--report_dir",
+                            help="path where report files are saved")
 
   def ParseArgv(self):
     if common.Rational.ParseArgv(self):
       if self._options.exe:
         self._exe = self._options.exe;
         if not os.path.isfile(self._exe):
           logging.error("file doesn't exist " + self._exe)
           return False
         self._exe_dir = common.FixPath(os.path.abspath(os.path.dirname(self._exe)))
       self._echo_to_stdout = self._options.echo_to_stdout
       self._baseline = self._options.baseline
       self._name = self._options.name
       if not self._name:
         self._name = os.path.basename(self._exe)
+      self._report_dir = self._options.report_dir
+      if not self._report_dir:
+        self._report_dir = os.path.join(script_dir, "latest")
       # _out_file can be set in common.Rational.ParseArgv
       if not self._out_file:
-        self._out_file = os.path.join(self._latest_dir, "%s.txt" % self._name)
+        self._out_file = os.path.join(self._report_dir, "%s.txt" % self._name)
       self._source_dir = self._options.source_dir
       self._data_dir = self._options.data_dir
       if not self._data_dir:
         self._data_dir = os.path.join(script_dir, "data")
       return True
     return False
 
   def _PurifyCommand(self):
     cmd = [common.PURIFY_PATH, "/CacheDir=" + self._cache_dir]
     return cmd
 
   def Setup(self):
     script_dir = google.path_utils.ScriptDir()
-    self._latest_dir = os.path.join(script_dir, "latest")
     if common.Rational.Setup(self):
       if self._instrument_only:
         return True
       pft_file = os.path.join(script_dir, "data", "filters.pft")
       shutil.copyfile(pft_file, self._exe.replace(".exe", "_exe.pft"))
       string_list = [
           "[Purify]",
           "option -cache-dir=\"%s\"" % (self._cache_dir),
           "option -save-text-data=\"%s\"" % (common.FixPath(self._out_file)),
           # Change the recorded stack depth to be much larger than the default.
@@ skipping 78 matching lines @@
     # determine if the run was valid.
     return True
 
   def Analyze(self):
     out_files = self._ExistingOutputFiles()
     if not len(out_files):
       logging.info("no output files matching %s" % self._out_file)
       return -1
     pa = purify_analyze.PurifyAnalyze(out_files, self._echo_to_stdout,
                                       self._name, self._source_dir,
-                                      self._data_dir)
+                                      self._data_dir, self._report_dir)
     if not pa.ReadFile():
       # even though there was a fatal error during Purify, it's still useful
       # to see the normalized output
       pa.PrintSummary()
       if self._baseline:
         logging.warning("baseline not generated due to fatal error")
       else:
         logging.warning("baseline comparison skipped due to fatal error")
       return -1
     if self._baseline:
       pa.PrintSummary(False)
       if pa.SaveResults():
         return 0
       return -1
     else:
       retcode = pa.CompareResults()
       if retcode != 0:
-        pa.SaveResults(self._latest_dir)
+        pa.SaveResults(self._report_dir)
       pa.PrintSummary()
       # with more than one output file, it's also important to emit the bug
       # report which includes info on the arguments that generated each stack
       if len(out_files) > 1:
         pa.PrintBugReport()
       return retcode
 
   def Cleanup(self):
     common.Rational.Cleanup(self);
     if self._instrument_only:
@@ skipping 16 matching lines @@
     if os.path.isfile(pft_file):
       os.remove(pft_file)
 
 
 if __name__ == "__main__":
   rational = Purify()
   retcode = rational.Run()
   sys.exit(retcode)