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

tools/purify/chrome_tests.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.
 
 # chrome_tests.py
 
 ''' Runs various chrome tests through purify_test.py
 '''
 
@@ skipping 30 matching lines @@
 
     if test not in self._test_list:
       raise TestNotFound("Unknown test: %s" % test)
 
     self._options = options
     self._args = args
     self._test = test
 
     script_dir = google.path_utils.ScriptDir()
     utility = google.platform_utils.PlatformUtility(script_dir)
+
     # Compute the top of the tree (the "source dir") from the script dir (where
     # this script lives).  We assume that the script dir is in tools/purify
     # relative to the top of the tree.
     self._source_dir = os.path.dirname(os.path.dirname(script_dir))
+
     # since this path is used for string matching, make sure it's always
     # an absolute Windows-style path
     self._source_dir = utility.GetAbsolutePath(self._source_dir)
+
+    self._report_dir = options.report_dir
+    if not self._report_dir:
+      if not options.buildbot:
+        self._report_dir = os.path.join(script_dir, "latest")
+      else:
+        # On the buildbot, we archive to a specific location on chrome-web
+        # with a directory based on the test name and the current svn revision.
+        # NOTE: These modules are located in trunk/tools/buildbot, which is not
+        # in the default config.  You'll need to check this out and add 
+        # scripts/* to your PYTHONPATH to test outside of the buildbot.
+        import slave_utils
+        import chromium_config
+        chrome_web_dir = chromium_config.Archive.purify_test_result_archive
+        current_version = str(slave_utils.SubversionRevision(self._source_dir))
+        # This line is how the buildbot master figures out our directory.
+        print "last change:", current_version
+        self._report_dir = os.path.join(chrome_web_dir, test,current_version)
+    if not os.path.exists(self._report_dir):
+      os.makedirs(self._report_dir)
+
     purify_test = os.path.join(script_dir, "purify_test.py")
     self._command_preamble = ["python.exe", purify_test, "--echo_to_stdout", 
                               "--source_dir=%s" % (self._source_dir),
+                              "--report_dir=%s" % (self._report_dir),
                               "--save_cache"]
 
   def _DefaultCommand(self, module, exe=None):
     '''Generates the default command array that most tests will use.'''
     module_dir = os.path.join(self._source_dir, module)
     if module == "chrome":
       # unfortunately, not all modules have the same directory structure
       self._data_dir = os.path.join(module_dir, "test", "data", "purify")
     else:
       self._data_dir = os.path.join(module_dir, "data", "purify")
+
     if not self._options.build_dir:
       dir_chrome = os.path.join(self._source_dir, "chrome", "Release")
       dir_module = os.path.join(module_dir, "Release")
       if exe:
         exe_chrome = os.path.join(dir_chrome, exe)
         exe_module = os.path.join(dir_module, exe)
         if os.path.isfile(exe_chrome) and not os.path.isfile(exe_module):
           self._options.build_dir = dir_chrome
         elif os.path.isfile(exe_module) and not os.path.isfile(exe_chrome):
           self._options.build_dir = dir_module
@@ skipping 209 matching lines @@
     if not self._options.no_reinstrument:
       instrumentation_error = self.InstrumentDll()
       if instrumentation_error:
         return instrumentation_error
     return self.ScriptedTest("chrome", "chrome.exe", "ui_tests", 
                              ["ui_tests.exe",
                               "--single-process",
                               "--ui-test-timeout=180000",
                               "--ui-test-action-timeout=80000",
                               "--ui-test-action-max-timeout=180000",
-                              "--ui-test-sleep-timeout=40000"],
-                             multi=True)
+                              "--ui-test-sleep-timeout=40000"],
+                              multi=True)
 
 
 def _main(argv):
   parser = optparse.OptionParser("usage: %prog -b <dir> -t <test> "
                                  "[-t <test> ...]")
   parser.disable_interspersed_args()
   parser.add_option("-b", "--build_dir",
                     help="the location of the output of the compiler output")
   parser.add_option("-t", "--test", action="append",
                     help="which test to run")
   parser.add_option("", "--baseline", action="store_true", default=False,
                     help="generate baseline data instead of validating")
   parser.add_option("", "--gtest_filter",
                     help="additional arguments to --gtest_filter")
   parser.add_option("-v", "--verbose", action="store_true", default=False,
                     help="verbose output - enable debug log messages")
   parser.add_option("", "--no-reinstrument", action="store_true", default=False,
                     help="Don't force a re-instrumentation for ui_tests")
   parser.add_option("", "--run-singly", action="store_true", default=False,
                     help="run tests independently of each other so that they "
                          "don't interfere with each other and so that errors " 
                          "can be accurately attributed to their source");
+  parser.add_option("", "--report_dir",
+                    help="path where report files are saved")
+  parser.add_option("", "--buildbot", action="store_true", default=False,
+                    help="whether we're being run in a buildbot environment")
   options, args = parser.parse_args()
 
   if options.verbose:
     google.logging_utils.config_root(logging.DEBUG)
   else:
     google.logging_utils.config_root()
 
   if not options.test or not len(options.test):
     parser.error("--test not specified")
 
   for t in options.test:
     tests = ChromeTests(options, args, t)
     ret = tests.Run()
     if ret: return ret
   return 0
 
 
 if __name__ == "__main__":
   ret = _main(sys.argv)
   sys.exit(ret)