Fix purify scripts to output data into the correct directory when running lay...

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 43 matching lines @@
     # 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")
+        self._report_dir = os.path.join(script_dir, "latest", test)
       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)
+        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")
@@ skipping 17 matching lines @@
           self._options.build_dir = dir_chrome
         elif os.path.isdir(dir_module) and not os.path.isdir(dir_chrome):
           self._options.build_dir = dir_module
         elif os.stat(dir_module)[stat.ST_MTIME] > os.stat(dir_chrome)[stat.ST_MTIME]:
           self._options.build_dir = dir_module
         else:
           self._options.build_dir = dir_chrome
 
     cmd = list(self._command_preamble)
     cmd.append("--data_dir=%s" % self._data_dir)
+    cmd.append("--report_dir=%s" % self._report_dir)
     if self._options.baseline:
       cmd.append("--baseline")
     if self._options.verbose:
       cmd.append("--verbose")
     if exe:
       cmd.append(os.path.join(self._options.build_dir, exe))
     return cmd
 
   def Run(self):
     ''' Runs the test specified by command-line argument --test '''
@@ skipping 45 matching lines @@
       exe - the name of the exe (it's assumed to exist in build_dir)
       name - the name of this test (used to name output files)
       script - the driver program or script.  If it's python.exe, we use 
         search-path behavior to execute, otherwise we assume that it is in
         build_dir.
       multi - a boolean hint that the exe will be run multiple times, generating
         multiple output files (without this option, only the last run will be
         recorded and analyzed)
       cmd_args - extra arguments to pass to the purify_test.py script
     '''
+    if out_dir_extra:
+      self._report_dir = os.path.join(self._report_dir, out_dir_extra)
     cmd = self._DefaultCommand(module)
     exe = os.path.join(self._options.build_dir, exe)
     cmd.append("--exe=%s" % exe)
     cmd.append("--name=%s" % name)
     if multi:
-      out = os.path.join(google.path_utils.ScriptDir(),
-                         "latest")
       if out_dir_extra:
-        out = os.path.join(out, out_dir_extra)
-        if os.path.exists(out):
-          old_files = glob.glob(os.path.join(out, "*.txt"))
+        if os.path.exists(self._report_dir):
+          old_files = glob.glob(os.path.join(self._report_dir, "*.txt"))
           for f in old_files:
             os.remove(f)
         else:
-          os.makedirs(out)
-      out = os.path.join(out, "%s%%5d.txt" % name)
-      cmd.append("--out_file=%s" % out)
+          os.makedirs(self._report_dir)
+      out_file = os.path.join(self._report_dir, "%s%%5d.txt" % name)
+      cmd.append("--out_file=%s" % out_file)
     if cmd_args:
       cmd.extend(cmd_args)
     if script[0] != "python.exe" and not os.path.exists(script[0]):
       script[0] = os.path.join(self._options.build_dir, script[0])
     cmd.extend(script)
     self._ReadGtestFilterFile(name, cmd)
     return common.RunSubprocess(cmd, 0)
 
   def InstrumentDll(self):
     '''Does a blocking Purify instrumentation of chrome.dll.'''
@@ skipping 69 matching lines @@
         script_cmd.append("--test-list=%s" % self._args[0])
       else:
         script_cmd.extend(self._args)
     
     if run_all:
       ret = self.ScriptedTest("webkit", "test_shell.exe", "layout",
                               script_cmd, multi=True, cmd_args=["--timeout=0"])
       return ret
 
     # store each chunk in its own directory so that we can find the data later
-    chunk_dir = os.path.join("layout", "chunk_%05d" % chunk_num)
+    chunk_dir = os.path.join("chunk_%05d" % chunk_num)
     ret = self.ScriptedTest("webkit", "test_shell.exe", "layout",
                             script_cmd, multi=True, cmd_args=["--timeout=0"],
                             out_dir_extra=chunk_dir)
 
     # Wait until after the test runs to completion to write out the new chunk
     # number.  This way, if the bot is killed, we'll start running again from
     # the current chunk rather than skipping it.
     try:
       f = open(chunk_file, "w")
       chunk_num += 1
       f.write("%d" % chunk_num)
       f.close()
     except IOError, (errno, strerror):
       logging.error("error writing to file %s (%d, %s)" % (chunk_file, errno,
                     strerror))
     # Since we're running small chunks of the layout tests, it's important to
     # mark the ones that have errors in them.  These won't be visible in the
     # summary list for long, but will be useful for someone reviewing this bot.
-    return ret
+    #return ret
+    # For now, since a fair number of layout tests are still red, we'll use the
+    # magic orange indicator return code to avoid making the tree look red when
+    # nothing has changed.  When We get the layout tests into a stable green,
+    # this code should be undone.
+    # BUG=7516
+    if ret:
+      return -88
+    return 0
 
   def TestUI(self):
     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",
@@ skipping 41 matching lines @@
     tests = ChromeTests(options, args, t)
     ret = tests.Run()
     if ret: return ret
   return 0
 
 
 if __name__ == "__main__":
   ret = _main(sys.argv)
   sys.exit(ret)