Allow layout tests to be located both in src/webkit/data/layout_tests and...

webkit/tools/layout_tests/layout_package/path_utils.py

 # 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.
 
 """Some utility methods for getting paths used by run_webkit_tests.py.
 """
 
 import errno
 import os
 import platform_utils
 import subprocess
 import sys
 
 import google.path_utils
 
 
 class PathNotFound(Exception): pass
 
 # Save some paths here so we don't keep re-evaling.
 _webkit_root = None
 _layout_data_dir = None
+_layout_tests_dir = None
 # A map from platform description to directory list.
 _platform_results_dirs = {}
 
 # An instance of the PlatformUtility for use by methods mapped from there.
 _platform_util = None
 
 # TODO this should probably be moved into path_utils as ToUnixPath().
 def WinPathToUnix(path):
   """Convert a windows path to use unix-style path separators (a/b/c)."""
   return path.replace('\\', '/')
@@ skipping 12 matching lines @@
 def LayoutDataDir():
   """Gets the full path to the tests directory.  Raises PathNotFound if
   we're unable to find it."""
   global _layout_data_dir
   if _layout_data_dir:
     return _layout_data_dir
   _layout_data_dir = google.path_utils.FindUpward(WebKitRoot(), 'webkit',
                                                   'data', 'layout_tests')
   return _layout_data_dir
 
+def LayoutTestsDir(path = None):
+  """Returns the full path to the directory containing layout tests, based on
+  the supplied relative or absolute path to a layout tests. If the path contains
+  "LayoutTests" directory, locates this directory, assuming it's either in
+  in webkit/data/layout_tests or in third_party/WebKit."""
+
+  if path != None and path.find('LayoutTests') == -1:
+    return LayoutDataDir()
+
+  global _layout_tests_dir
+  if _layout_tests_dir:
+    return _layout_tests_dir
+
+  if os.path.exists(os.path.join(LayoutDataDir(), 'LayoutTests')):
+    _layout_tests_dir = LayoutDataDir()
+  else:
+    _layout_tests_dir = google.path_utils.FindUpward(
+        google.path_utils.ScriptDir(), 'third_party', 'WebKit')
+
+  return _layout_tests_dir
+
 def ChromiumPlatformResultsEnclosingDir():
   """Returns the full path to the directory containing Chromium platform
   result directories.
   """
   # TODO(pamg): Once we move platform/chromium-* into LayoutTests/platform/,
   # remove this and use PlatformResultsEnclosingDir() for everything.
   return os.path.join(LayoutDataDir(), 'platform')
 
 def WebKitPlatformResultsEnclosingDir():
   """Gets the full path to just above the platform results directory."""
-  return os.path.join(LayoutDataDir(), 'LayoutTests', 'platform')
+  return os.path.join(LayoutTestsDir(), 'LayoutTests', 'platform')
 
 def PlatformResultsEnclosingDir(platform):
   """Gets the path to just above the results directory for this platform."""
   if platform.startswith('chromium'):
     return ChromiumPlatformResultsEnclosingDir()
   return WebKitPlatformResultsEnclosingDir()
 
 def ExpectedFilename(filename, suffix, platform):
   """Given a test name, returns an absolute path to its expected results.
 
@@ skipping 118 matching lines @@
   platform_util = platform_utils.PlatformUtility('')
   # try output directory from either Xcode or chrome.sln
   full_path = platform_util.LayoutTestHelperBinaryPath(target)
   if not os.path.exists(full_path):
     raise PathNotFound('unable to find layout_test_helper at %s' % full_path)
   return full_path
 
 def RelativeTestFilename(filename):
   """Provide the filename of the test relative to the layout data
   directory as a unix style path (a/b/c)."""
-  return WinPathToUnix(filename[len(LayoutDataDir()) + 1:])
+  return WinPathToUnix(filename[len(LayoutTestsDir(filename)) + 1:])
 
 def GetPlatformUtil():
   """Returns a singleton instance of the PlatformUtility."""
   global _platform_util
   if not _platform_util:
     # Avoid circular import by delaying it.
     import layout_package.platform_utils
     _platform_util = (
         layout_package.platform_utils.PlatformUtility(WebKitRoot()))
   return _platform_util
 
 # Map platform specific path utility functions.  We do this as a convenience
 # so importing path_utils will get all path related functions even if they are
 # platform specific.
 def GetAbsolutePath(path):
   return GetPlatformUtil().GetAbsolutePath(path)
 
 def FilenameToUri(path):
   return GetPlatformUtil().FilenameToUri(path)
 
 def TestListPlatformDir():
   return GetPlatformUtil().TestListPlatformDir()
 
 def PlatformDir():
   return GetPlatformUtil().PlatformDir()
 
 def PlatformNewResultsDir():
   return GetPlatformUtil().PlatformNewResultsDir()