[swarming] Enforce test runner to use v8 base dir as cwd.

tools/run-tests.py

 #!/usr/bin/env python
 #
 # Copyright 2012 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
@@ skipping 33 matching lines @@
 from testrunner.local import execution
 from testrunner.local import progress
 from testrunner.local import testsuite
 from testrunner.local.testsuite import ALL_VARIANTS
 from testrunner.local import utils
 from testrunner.local import verbose
 from testrunner.network import network_execution
 from testrunner.objects import context
 
 
+# Base dir of the v8 checkout to be used as cwd.
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
 ARCH_GUESS = utils.DefaultArch()
 
 # Map of test name synonyms to lists of test suites. Should be ordered by
 # expected runtimes (suites with slow test cases first). These groups are
 # invoked in seperate steps on the bots.
 TEST_MAP = {
   "default": [
     "mjsunit",
     "cctest",
     "message",
@@ skipping 424 matching lines @@
   count = 0
   shard = []
   for test in tests:
     if count % shard_count == shard_run - 1:
       shard.append(test)
     count += 1
   return shard
 
 
 def Main():
+  # Use the v8 root as cwd as some test cases use "load" with relative paths.
+  os.chdir(BASE_DIR)
+
   parser = BuildOptions()
   (options, args) = parser.parse_args()
   if not ProcessOptions(options):
     parser.print_help()
     return 1
 
   exit_code = 0
-  workspace = os.path.abspath(join(os.path.dirname(sys.argv[0]), ".."))
   if not options.no_presubmit:
     print ">>> running presubmit tests"
     exit_code = subprocess.call(
-        [sys.executable, join(workspace, "tools", "presubmit.py")])
+        [sys.executable, join(BASE_DIR, "tools", "presubmit.py")])
 
-  suite_paths = utils.GetSuitePaths(join(workspace, "test"))
+  suite_paths = utils.GetSuitePaths(join(BASE_DIR, "test"))
 
   # Use default tests if no test configuration was provided at the cmd line.
   if len(args) == 0:
     args = ["default"]
 
   # Expand arguments with grouped tests. The args should reflect the list of
   # suites as otherwise filters would break.
   def ExpandTestGroups(name):
     if name in TEST_MAP:
       return [suite for suite in TEST_MAP[arg]]
     else:
       return [name]
   args = reduce(lambda x, y: x + y,
          [ExpandTestGroups(arg) for arg in args],
          [])
 
   args_suites = OrderedDict() # Used as set
   for arg in args:
     args_suites[arg.split('/')[0]] = True
   suite_paths = [ s for s in args_suites if s in suite_paths ]
 
   suites = []
   for root in suite_paths:
     suite = testsuite.TestSuite.LoadTestSuite(
-        os.path.join(workspace, "test", root))
+        os.path.join(BASE_DIR, "test", root))
     if suite:
       suites.append(suite)
 
   if options.download_data or options.download_data_only:
     for s in suites:
       s.DownloadData()
 
   if options.download_data_only:
     return exit_code
 
   for (arch, mode) in options.arch_and_mode:
     try:
-      code = Execute(arch, mode, args, options, suites, workspace)
+      code = Execute(arch, mode, args, options, suites)
     except KeyboardInterrupt:
       return 2
     exit_code = exit_code or code
   return exit_code
 
 
-def Execute(arch, mode, args, options, suites, workspace):
+def Execute(arch, mode, args, options, suites):
   print(">>> Running tests for %s.%s" % (arch, mode))
 
   shell_dir = options.shell_dir
   if not shell_dir:
     if options.buildbot:
       # TODO(machenbach): Get rid of different output folder location on
       # buildbot. Currently this is capitalized Release and Debug.
-      shell_dir = os.path.join(workspace, options.outdir, mode)
+      shell_dir = os.path.join(BASE_DIR, options.outdir, mode)
       mode = BuildbotToV8Mode(mode)
     else:
       shell_dir = os.path.join(
-          workspace,
+          BASE_DIR,
           options.outdir,
           "%s.%s" % (arch, MODES[mode]["output_folder"]),
       )
-  shell_dir = os.path.relpath(shell_dir)
   if not os.path.exists(shell_dir):
       raise Exception('Could not find shell_dir: "%s"' % shell_dir)
 
   # Populate context object.
   mode_flags = MODES[mode]["flags"]
   timeout = options.timeout
   if timeout == -1:
     # Simulators are slow, therefore allow a longer default timeout.
     if arch in SLOW_ARCHS:
       timeout = 2 * TIMEOUT_DEFAULT;
@@ skipping 123 matching lines @@
       run_networked = False
     elif len(peers) == 1:
       print("No other peers on the network; running tests locally.")
       run_networked = False
     elif num_tests <= 100:
       print("Less than 100 tests, running them locally.")
       run_networked = False
 
   if run_networked:
     runner = network_execution.NetworkedRunner(suites, progress_indicator,
-                                               ctx, peers, workspace)
+                                               ctx, peers, BASE_DIR)
   else:
     runner = execution.Runner(suites, progress_indicator, ctx)
 
   exit_code = runner.Run(options.j)
   overall_duration = time.time() - start_time
 
   if options.time:
     verbose.PrintTestDurations(suites, overall_duration)
 
   if num_tests == 0:
     print("Warning: no tests were run!")
 
   return exit_code
 
 
 if __name__ == "__main__":
   sys.exit(Main())