Description redacted.

--
PiperOrigin-RevId: 141483567
MOS_MIGRATED_REVID=141483567

11 files changed, 205 insertions, 94 deletions

diff --git a/src/main/cpp/blaze.cc b/src/main/cpp/blaze.cc
index 4c7b40131d..d3b039e764 100644
--- a/src/main/cpp/blaze.cc
+++ b/src/main/cpp/blaze.cc
@@ -559,8 +559,8 @@ static string GetArgumentString(const vector<string>& argument_array) {
 }
 
 // Do a chdir into the workspace, and die if it fails.
-static void GoToWorkspace() {
-  if (WorkspaceLayout::InWorkspace(globals->workspace) &&
+static void GoToWorkspace(const WorkspaceLayout* workspace_layout) {
+  if (workspace_layout->InWorkspace(globals->workspace) &&
       !blaze_util::ChangeDirectory(globals->workspace)) {
     pdie(blaze_exit_code::INTERNAL_ERROR,
          "changing directory into %s failed", globals->workspace.c_str());
@@ -598,7 +598,8 @@ static void VerifyJavaVersionAndSetJvm() {
 
 // Starts the Blaze server.  Returns a readable fd connected to the server.
 // This is currently used only to detect liveness.
-static void StartServer(BlazeServerStartup** server_startup) {
+static void StartServer(const WorkspaceLayout* workspace_layout,
+                        BlazeServerStartup** server_startup) {
   vector<string> jvm_args_vector = GetArgumentArray();
   string argument_string = GetArgumentString(jvm_args_vector);
   string server_dir = globals->options->output_base + "/server";
@@ -618,7 +619,7 @@ static void StartServer(BlazeServerStartup** server_startup) {
                                         globals->extracted_binaries[0]);
   // Go to the workspace before we daemonize, so
   // we can still print errors to the terminal.
-  GoToWorkspace();
+  GoToWorkspace(workspace_layout);
 
   ExecuteDaemon(exe, jvm_args_vector, globals->jvm_log_file, server_dir,
                 server_startup);
@@ -629,7 +630,8 @@ static void StartServer(BlazeServerStartup** server_startup) {
 //
 // This function passes the commands array to the blaze process.
 // This array should start with a command ("build", "info", etc.).
-static void StartStandalone(BlazeServer* server) {
+static void StartStandalone(const WorkspaceLayout* workspace_layout,
+                            BlazeServer* server) {
   if (server->Connected()) {
     server->KillRunningServer();
   }
@@ -666,7 +668,7 @@ static void StartStandalone(BlazeServer* server) {
                          command_arguments.begin(),
                          command_arguments.end());
 
-  GoToWorkspace();
+  GoToWorkspace(workspace_layout);
 
   string exe = globals->options->GetExe(globals->jvm_path,
                                        globals->extracted_binaries[0]);
@@ -709,7 +711,8 @@ static int GetServerPid(const string &server_dir) {
 }
 
 // Starts up a new server and connects to it. Exits if it didn't work not.
-static void StartServerAndConnect(BlazeServer *server) {
+static void StartServerAndConnect(const WorkspaceLayout* workspace_layout,
+                                  BlazeServer *server) {
   string server_dir = globals->options->output_base + "/server";
 
   // The server dir has the socket, so we don't allow access by other
@@ -747,7 +750,7 @@ static void StartServerAndConnect(BlazeServer *server) {
                 globals->options->io_nice_level);
 
   BlazeServerStartup* server_startup;
-  StartServer(&server_startup);
+  StartServer(workspace_layout, &server_startup);
 
   // Give the server two minutes to start up. That's enough to connect with a
   // debugger.
@@ -1076,10 +1079,11 @@ static void CancelServer() {
 
 // Performs all I/O for a single client request to the server, and
 // shuts down the client (by exit or signal).
-static ATTRIBUTE_NORETURN void SendServerRequest(BlazeServer* server) {
+static ATTRIBUTE_NORETURN void SendServerRequest(
+    const WorkspaceLayout* workspace_layout, BlazeServer* server) {
   while (true) {
     if (!server->Connected()) {
-      StartServerAndConnect(server);
+      StartServerAndConnect(workspace_layout, server);
     }
 
     // Check for the case when the workspace directory deleted and then gets
@@ -1137,23 +1141,24 @@ static void ParseOptions(int argc, const char *argv[]) {
 }
 
 // Compute the globals globals->cwd and globals->workspace.
-static void ComputeWorkspace() {
+static void ComputeWorkspace(const WorkspaceLayout* workspace_layout) {
   globals->cwd = blaze_util::MakeCanonical(blaze_util::GetCwd().c_str());
   if (globals->cwd.empty()) {
     pdie(blaze_exit_code::LOCAL_ENVIRONMENTAL_ERROR,
          "blaze_util::MakeCanonical('%s') failed",
          blaze_util::GetCwd().c_str());
   }
-  globals->workspace = WorkspaceLayout::GetWorkspace(globals->cwd);
+  globals->workspace = workspace_layout->GetWorkspace(globals->cwd);
 }
 
 // Figure out the base directories based on embedded data, username, cwd, etc.
 // Sets globals->options->install_base, globals->options->output_base,
 // globals->lockfile, globals->jvm_log_file.
-static void ComputeBaseDirectories(const string &self_path) {
+static void ComputeBaseDirectories(const WorkspaceLayout* workspace_layout,
+                                   const string &self_path) {
   // Only start a server when in a workspace because otherwise we won't do more
   // than emit a help message.
-  if (!WorkspaceLayout::InWorkspace(globals->workspace)) {
+  if (!workspace_layout->InWorkspace(globals->workspace)) {
     globals->options->batch = true;
   }
 
@@ -1270,15 +1275,17 @@ static string CheckAndGetBinaryPath(const string& argv0) {
 // code to a file. In case the server becomes unresonsive or terminates
 // unexpectedly (in a way that isn't already handled), we can observe the file,
 // if it exists. (If it doesn't, then we know something went horribly wrong.)
-int Main(int argc, const char *argv[], OptionProcessor *option_processor,
+int Main(int argc, const char *argv[], WorkspaceLayout* workspace_layout,
+         OptionProcessor *option_processor,
          std::unique_ptr<blaze_util::LogHandler> log_handler) {
   // Logging must be set first to assure no log statements are missed.
   blaze_util::SetLogHandler(std::move(log_handler));
+
   globals = new GlobalVariables(option_processor);
   blaze::SetupStdStreams();
 
   // Must be done before command line parsing.
-  ComputeWorkspace();
+  ComputeWorkspace(workspace_layout);
   globals->binary_path = CheckAndGetBinaryPath(argv[0]);
   ParseOptions(argc, argv);
 
@@ -1288,7 +1295,7 @@ int Main(int argc, const char *argv[], OptionProcessor *option_processor,
   blaze::CreateSecureOutputRoot(globals->options->output_user_root);
 
   const string self_path = GetSelfPath();
-  ComputeBaseDirectories(self_path);
+  ComputeBaseDirectories(workspace_layout, self_path);
 
   blaze_server = static_cast<BlazeServer *>(new GrpcBlazeServer(
       globals->options->connect_timeout_secs));
@@ -1307,9 +1314,9 @@ int Main(int argc, const char *argv[], OptionProcessor *option_processor,
   if (globals->options->batch) {
     SetScheduling(globals->options->batch_cpu_scheduling,
                   globals->options->io_nice_level);
-    StartStandalone(blaze_server);
+    StartStandalone(workspace_layout, blaze_server);
   } else {
-    SendServerRequest(blaze_server);
+    SendServerRequest(workspace_layout, blaze_server);
   }
   return 0;
 }
diff --git a/src/main/cpp/blaze.h b/src/main/cpp/blaze.h
index 82a63bb38f..7e3636d610 100644
--- a/src/main/cpp/blaze.h
+++ b/src/main/cpp/blaze.h
@@ -15,11 +15,13 @@
 #define BAZEL_SRC_MAIN_CPP_BLAZE_H_
 
 #include "src/main/cpp/option_processor.h"
+#include "src/main/cpp/workspace_layout.h"
 #include "src/main/cpp/util/logging.h"
 
 namespace blaze {
 
-int Main(int argc, const char* argv[], OptionProcessor* option_processor,
+int Main(int argc, const char* argv[], WorkspaceLayout* workspace_layout,
+         OptionProcessor* option_processor,
          std::unique_ptr<blaze_util::LogHandler> log_handler);
 
 }  // namespace blaze
diff --git a/src/main/cpp/main.cc b/src/main/cpp/main.cc
index 2a1928704a..81a599ae36 100644
--- a/src/main/cpp/main.cc
+++ b/src/main/cpp/main.cc
@@ -17,11 +17,15 @@
 #include "src/main/cpp/blaze.h"
 #include "src/main/cpp/option_processor.h"
 #include "src/main/cpp/startup_options.h"
+#include "src/main/cpp/workspace_layout.h"
 
 int main(int argc, const char *argv[]) {
+  std::unique_ptr<blaze::WorkspaceLayout> workspace_layout(
+      new blaze::WorkspaceLayout());
   std::unique_ptr<blaze::StartupOptions> startup_options(
-      new blaze::StartupOptions());
-  return blaze::Main(argc, argv,
-                     new blaze::OptionProcessor(std::move(startup_options)),
+      new blaze::StartupOptions(workspace_layout.get()));
+  return blaze::Main(argc, argv, workspace_layout.get(),
+                     new blaze::OptionProcessor(workspace_layout.get(),
+                                                std::move(startup_options)),
                      nullptr /* TODO(b/32939567): Enable Bazel logging. */);
 }
diff --git a/src/main/cpp/option_processor.cc b/src/main/cpp/option_processor.cc
index f01d79ae75..55c9cfd40b 100644
--- a/src/main/cpp/option_processor.cc
+++ b/src/main/cpp/option_processor.cc
@@ -53,13 +53,15 @@ OptionProcessor::RcFile::RcFile(const string& filename, int index)
 
 blaze_exit_code::ExitCode OptionProcessor::RcFile::Parse(
     const string& workspace,
+    const WorkspaceLayout* workspace_layout,
     vector<RcFile*>* rcfiles,
     map<string, vector<RcOption> >* rcoptions,
     string* error) {
   list<string> initial_import_stack;
   initial_import_stack.push_back(filename_);
   return Parse(
-      workspace, filename_, index_, rcfiles, rcoptions, &initial_import_stack,
+      workspace, filename_, index_, workspace_layout,
+      rcfiles, rcoptions, &initial_import_stack,
       error);
 }
 
@@ -67,6 +69,7 @@ blaze_exit_code::ExitCode OptionProcessor::RcFile::Parse(
     const string& workspace,
     const string& filename_ref,
     const int index,
+    const WorkspaceLayout* workspace_layout,
     vector<RcFile*>* rcfiles,
     map<string, vector<RcOption> >* rcoptions,
     list<string>* import_stack,
@@ -113,9 +116,9 @@ blaze_exit_code::ExitCode OptionProcessor::RcFile::Parse(
 
     if (command == "import") {
       if (words.size() != 2
-          || (words[1].compare(0, WorkspaceLayout::WorkspacePrefixLength,
-                               WorkspaceLayout::WorkspacePrefix) == 0
-              && !WorkspaceLayout::WorkspaceRelativizeRcFilePath(
+          || (words[1].compare(0, workspace_layout->WorkspacePrefixLength,
+                               workspace_layout->WorkspacePrefix) == 0
+              && !workspace_layout->WorkspaceRelativizeRcFilePath(
                   workspace, &words[1]))) {
         blaze_util::StringPrintf(error,
             "Invalid import declaration in .blazerc file '%s': '%s'",
@@ -138,7 +141,7 @@ blaze_exit_code::ExitCode OptionProcessor::RcFile::Parse(
       import_stack->push_back(words[1]);
       blaze_exit_code::ExitCode parse_exit_code =
         RcFile::Parse(workspace, rcfiles->back()->Filename(),
-                      rcfiles->back()->Index(),
+                      rcfiles->back()->Index(), workspace_layout,
                       rcfiles, rcoptions, import_stack, error);
       if (parse_exit_code != blaze_exit_code::SUCCESS) {
         return parse_exit_code;
@@ -164,9 +167,11 @@ blaze_exit_code::ExitCode OptionProcessor::RcFile::Parse(
 }
 
 OptionProcessor::OptionProcessor(
-    std::unique_ptr<StartupOptions> default_startup_options) :
-    initialized_(false),
-    parsed_startup_options_(std::move(default_startup_options)) {
+    const WorkspaceLayout* workspace_layout,
+    std::unique_ptr<StartupOptions> default_startup_options)
+    : initialized_(false),
+      workspace_layout_(workspace_layout),
+      parsed_startup_options_(std::move(default_startup_options)) {
 }
 
 std::unique_ptr<CommandLine> OptionProcessor::SplitCommandLine(
@@ -319,14 +324,14 @@ blaze_exit_code::ExitCode OptionProcessor::ParseOptions(
   // Parse depot and user blazerc files.
   vector<string> candidate_blazerc_paths;
   if (use_master_blazerc) {
-    WorkspaceLayout::FindCandidateBlazercPaths(
+    workspace_layout_->FindCandidateBlazercPaths(
         workspace, cwd, cmdLine->path_to_binary, cmdLine->startup_args,
         &candidate_blazerc_paths);
   }
 
   string user_blazerc_path;
   blaze_exit_code::ExitCode find_blazerc_exit_code = FindUserBlazerc(
-      blazerc, WorkspaceLayout::RcBasename(), workspace, &user_blazerc_path,
+      blazerc, workspace_layout_->RcBasename(), workspace, &user_blazerc_path,
       error);
   if (find_blazerc_exit_code != blaze_exit_code::SUCCESS) {
     return find_blazerc_exit_code;
@@ -343,7 +348,8 @@ blaze_exit_code::ExitCode OptionProcessor::ParseOptions(
       blazercs_.push_back(
           new RcFile(candidate_blazerc_path, blazercs_.size()));
       blaze_exit_code::ExitCode parse_exit_code =
-          blazercs_.back()->Parse(workspace, &blazercs_, &rcoptions_, error);
+          blazercs_.back()->Parse(workspace, workspace_layout_, &blazercs_,
+                                  &rcoptions_, error);
       if (parse_exit_code != blaze_exit_code::SUCCESS) {
         return parse_exit_code;
       }
diff --git a/src/main/cpp/option_processor.h b/src/main/cpp/option_processor.h
index 1281e77ed7..fc6fb33e94 100644
--- a/src/main/cpp/option_processor.h
+++ b/src/main/cpp/option_processor.h
@@ -26,6 +26,8 @@
 
 namespace blaze {
 
+class WorkspaceLayout;
+
 struct CommandLine {
   const std::string path_to_binary;
   const std::vector<std::string> startup_args;
@@ -47,7 +49,8 @@ struct CommandLine {
 // to the server.
 class OptionProcessor {
  public:
-  OptionProcessor(std::unique_ptr<StartupOptions> default_startup_options);
+  OptionProcessor(const WorkspaceLayout* workspace_layout,
+                  std::unique_ptr<StartupOptions> default_startup_options);
 
   virtual ~OptionProcessor();
 
@@ -120,7 +123,8 @@ class OptionProcessor {
    public:
     RcFile(const std::string& filename, int index);
     blaze_exit_code::ExitCode Parse(
-        const std::string& workspace, std::vector<RcFile*>* rcfiles,
+        const std::string& workspace, const WorkspaceLayout* workspace_layout,
+        std::vector<RcFile*>* rcfiles,
         std::map<std::string, std::vector<RcOption> >* rcoptions,
         std::string* error);
     const std::string& Filename() const { return filename_; }
@@ -129,7 +133,8 @@ class OptionProcessor {
    private:
     static blaze_exit_code::ExitCode Parse(
         const std::string& workspace, const std::string& filename,
-        const int index, std::vector<RcFile*>* rcfiles,
+        const int index, const WorkspaceLayout* workspace_layout,
+        std::vector<RcFile*>* rcfiles,
         std::map<std::string, std::vector<RcOption> >* rcoptions,
         std::list<std::string>* import_stack, std::string* error);
 
@@ -147,6 +152,7 @@ class OptionProcessor {
   std::string command_;
   std::vector<std::string> command_arguments_;
   bool initialized_;
+  const WorkspaceLayout* workspace_layout_;
   std::unique_ptr<StartupOptions> parsed_startup_options_;
 };
 
diff --git a/src/main/cpp/startup_options.cc b/src/main/cpp/startup_options.cc
index 8bd9c3d3e7..d16eeef117 100644
--- a/src/main/cpp/startup_options.cc
+++ b/src/main/cpp/startup_options.cc
@@ -34,9 +34,11 @@ namespace blaze {
 using std::string;
 using std::vector;
 
-StartupOptions::StartupOptions() : StartupOptions("Bazel") {}
+StartupOptions::StartupOptions(const WorkspaceLayout* workspace_layout)
+    : StartupOptions("Bazel", workspace_layout) {}
 
-StartupOptions::StartupOptions(const string &product_name)
+StartupOptions::StartupOptions(const string &product_name,
+                               const WorkspaceLayout* workspace_layout)
     : product_name(product_name),
       deep_execroot(true),
       block_for_lock(true),
@@ -58,7 +60,7 @@ StartupOptions::StartupOptions(const string &product_name)
   if (testing) {
     output_root = MakeAbsolute(blaze::GetEnv("TEST_TMPDIR"));
   } else {
-    output_root = WorkspaceLayout::GetOutputRoot();
+    output_root = workspace_layout->GetOutputRoot();
   }
 
   const string product_name_lower = GetLowercaseProductName();
diff --git a/src/main/cpp/startup_options.h b/src/main/cpp/startup_options.h
index d9ebe27815..7020c04883 100644
--- a/src/main/cpp/startup_options.h
+++ b/src/main/cpp/startup_options.h
@@ -23,6 +23,8 @@
 
 namespace blaze {
 
+class WorkspaceLayout;
+
 // This class holds the parsed startup options for Blaze.
 // These options and their defaults must be kept in sync with those in
 // src/main/java/com/google/devtools/build/lib/runtime/BlazeServerStartupOptions.java.
@@ -35,7 +37,7 @@ namespace blaze {
 // names also don't conform to the style guide.
 class StartupOptions {
  public:
-  StartupOptions();
+  explicit StartupOptions(const WorkspaceLayout* workspace_layout);
   virtual ~StartupOptions();
 
   // Parses a single argument, either from the command line or from the .blazerc
@@ -210,7 +212,8 @@ class StartupOptions {
   // Constructor for subclasses only so that site-specific extensions of this
   // class can override the product name.  The product_name must be the
   // capitalized version of the name, as in "Bazel".
-  explicit StartupOptions(const std::string &product_name);
+  explicit StartupOptions(const std::string &product_name,
+                          const WorkspaceLayout* workspace_layout);
 
   // Holds the valid nullary startup options.
   std::vector<std::string> nullary_options;
diff --git a/src/main/cpp/workspace_layout.cc b/src/main/cpp/workspace_layout.cc
index d3f8efab84..1e22a1d16a 100644
--- a/src/main/cpp/workspace_layout.cc
+++ b/src/main/cpp/workspace_layout.cc
@@ -11,6 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 #include "src/main/cpp/workspace_layout.h"
 
 #include <assert.h>
@@ -26,16 +27,16 @@ using std::vector;
 
 static const char kWorkspaceMarker[] = "WORKSPACE";
 
-string WorkspaceLayout::GetOutputRoot() {
+string WorkspaceLayout::GetOutputRoot() const {
   return blaze::GetOutputRoot();
 }
 
-bool WorkspaceLayout::InWorkspace(const string &workspace) {
+bool WorkspaceLayout::InWorkspace(const string &workspace) const {
   return blaze_util::PathExists(
       blaze_util::JoinPath(workspace, kWorkspaceMarker));
 }
 
-string WorkspaceLayout::GetWorkspace(const string &cwd) {
+string WorkspaceLayout::GetWorkspace(const string &cwd) const {
   assert(!cwd.empty());
   string workspace = cwd;
 
@@ -48,15 +49,16 @@ string WorkspaceLayout::GetWorkspace(const string &cwd) {
   return "";
 }
 
-string WorkspaceLayout::RcBasename() {
+string WorkspaceLayout::RcBasename() const {
   return ".bazelrc";
 }
 
-static string FindDepotBlazerc(const string& workspace) {
+static string FindDepotBlazerc(const blaze::WorkspaceLayout* workspace_layout,
+                               const string& workspace) {
   // Package semantics are ignored here, but that's acceptable because
   // blaze.blazerc is a configuration file.
   vector<string> candidates;
-  WorkspaceLayout::WorkspaceRcFileSearchPath(&candidates);
+  workspace_layout->WorkspaceRcFileSearchPath(&candidates);
   for (const auto& candidate : candidates) {
     string blazerc = blaze_util::JoinPath(workspace, candidate);
     if (blaze_util::CanAccess(blazerc, true, false, false)) {
@@ -94,19 +96,20 @@ void WorkspaceLayout::FindCandidateBlazercPaths(
     const string& cwd,
     const string& path_to_binary,
     const vector<string>& startup_args,
-    std::vector<string>* result) {
-  result->push_back(FindDepotBlazerc(workspace));
+    std::vector<string>* result) const {
+  result->push_back(FindDepotBlazerc(this, workspace));
   result->push_back(FindAlongsideBinaryBlazerc(cwd, path_to_binary));
   result->push_back(FindSystemWideBlazerc());
 }
 
 void WorkspaceLayout::WorkspaceRcFileSearchPath(
-    vector<string>* candidates) {
+    vector<string>* candidates) const {
   candidates->push_back("tools/bazel.rc");
 }
 
 bool WorkspaceLayout::WorkspaceRelativizeRcFilePath(const string &workspace,
-                                                    string *path_fragment) {
+                                                    string *path_fragment)
+    const {
   // Strip off the "%workspace%/" prefix and prepend the true workspace path.
   // In theory this could use alternate search paths for blazerc files.
   path_fragment->assign(
diff --git a/src/main/cpp/workspace_layout.h b/src/main/cpp/workspace_layout.h
index 26034ca6e5..64c6a985f4 100644
--- a/src/main/cpp/workspace_layout.h
+++ b/src/main/cpp/workspace_layout.h
@@ -11,6 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
 #ifndef BAZEL_SRC_MAIN_CPP_WORKSPACE_LAYOUT_H_
 #define BAZEL_SRC_MAIN_CPP_WORKSPACE_LAYOUT_H_
 
@@ -20,19 +21,12 @@
 namespace blaze {
 
 // Provides methods to compute paths related to the workspace.
-//
-// All methods in this class ought to be static because we reference them as
-// if they were global, and we do so from very early startup stages.
-//
-// The reason this is a class and not a namespace is because of historical
-// reasons, as this was split out from the BlazeStartupOptions class.
-// TODO(bazel-team): Reconsider dropping the class in favor of free functions.
 class WorkspaceLayout {
  public:
-  WorkspaceLayout() = delete;
+  virtual ~WorkspaceLayout() = default;
 
   // Returns the directory to use for storing outputs.
-  static std::string GetOutputRoot();
+  virtual std::string GetOutputRoot() const;
 
   // Given the working directory, returns the nearest enclosing directory with a
   // WORKSPACE file in it.  If there is no such enclosing directory, returns "".
@@ -44,32 +38,33 @@ class WorkspaceLayout {
   //
   // The returned path is relative or absolute depending on whether cwd was
   // relative or absolute.
-  static std::string GetWorkspace(const std::string& cwd);
+  virtual std::string GetWorkspace(const std::string& cwd) const;
 
   // Returns if workspace is a valid build workspace.
-  static bool InWorkspace(const std::string& workspace);
+  virtual bool InWorkspace(const std::string& workspace) const;
 
   // Returns the basename for the rc file.
-  static std::string RcBasename();
+  virtual std::string RcBasename() const;
 
   // Returns the candidate pathnames for the RC files.
-  static void FindCandidateBlazercPaths(
+  virtual void FindCandidateBlazercPaths(
       const std::string& workspace,
       const std::string& cwd,
       const std::string& path_to_binary,
       const std::vector<std::string>& startup_args,
-      std::vector<std::string>* result);
+      std::vector<std::string>* result) const;
 
   // Returns the candidate pathnames for the RC file in the workspace,
   // the first readable one of which will be chosen.
   // It is ok if no usable candidate exists.
-  static void WorkspaceRcFileSearchPath(std::vector<std::string>* candidates);
+  virtual void WorkspaceRcFileSearchPath(std::vector<std::string>* candidates)
+      const;
 
   // Turn a %workspace%-relative import into its true name in the filesystem.
   // path_fragment is modified in place.
   // Unlike WorkspaceRcFileSearchPath, it is an error if no import file exists.
-  static bool WorkspaceRelativizeRcFilePath(const std::string& workspace,
-                                            std::string* path_fragment);
+  virtual bool WorkspaceRelativizeRcFilePath(const std::string& workspace,
+                                             std::string* path_fragment) const;
 
   static constexpr const char WorkspacePrefix[] = "%workspace%/";
   static const int WorkspacePrefixLength = sizeof WorkspacePrefix - 1;
diff --git a/src/test/cpp/startup_options_test.cc b/src/test/cpp/startup_options_test.cc
index 304282a326..ee064857c8 100644
--- a/src/test/cpp/startup_options_test.cc
+++ b/src/test/cpp/startup_options_test.cc
@@ -15,13 +15,14 @@
 #include <stdlib.h>
 
 #include "src/main/cpp/startup_options.h"
+#include "src/main/cpp/workspace_layout.h"
 #include "gtest/gtest.h"
 
 namespace blaze {
 
 class StartupOptionsTest : public ::testing::Test {
  protected:
-  StartupOptionsTest() = default;
+  StartupOptionsTest() : workspace_layout_(new WorkspaceLayout()) {}
   ~StartupOptionsTest() = default;
 
   void SetUp() override {
@@ -30,6 +31,8 @@ class StartupOptionsTest : public ::testing::Test {
     // Otherwise, we'll crash here, but this keeps our code simpler.
     old_home_ = getenv("HOME");
     old_test_tmpdir_ = getenv("TEST_TMPDIR");
+
+    ReinitStartupOptions();
   }
 
   void TearDown() override {
@@ -37,30 +40,40 @@ class StartupOptionsTest : public ::testing::Test {
     setenv("TEST_TMPDIR", old_test_tmpdir_.c_str(), 1);
   }
 
+  // Recreates startup_options_ after changes to the environment.
+  void ReinitStartupOptions() {
+    startup_options_.reset(new StartupOptions(workspace_layout_.get()));
+  }
+
+ private:
+  std::unique_ptr<WorkspaceLayout> workspace_layout_;
+
+ protected:
+  std::unique_ptr<StartupOptions> startup_options_;
+
  private:
   std::string old_home_;
   std::string old_test_tmpdir_;
 };
 
 TEST_F(StartupOptionsTest, ProductName) {
-  blaze::StartupOptions startup_options;
-  ASSERT_EQ("Bazel", startup_options.product_name);
+  ASSERT_EQ("Bazel", startup_options_->product_name);
 }
 
 TEST_F(StartupOptionsTest, OutputRootPreferTestTmpdirIfSet) {
   setenv("HOME", "/nonexistent/home", 1);
   setenv("TEST_TMPDIR", "/nonexistent/tmpdir", 1);
+  ReinitStartupOptions();
 
-  blaze::StartupOptions startup_options;
-  ASSERT_EQ("/nonexistent/tmpdir", startup_options.output_root);
+  ASSERT_EQ("/nonexistent/tmpdir", startup_options_->output_root);
 }
 
 TEST_F(StartupOptionsTest, OutputRootUseHomeDirectory) {
   setenv("HOME", "/nonexistent/home", 1);
   unsetenv("TEST_TMPDIR");
+  ReinitStartupOptions();
 
-  blaze::StartupOptions startup_options;
-  ASSERT_EQ("/nonexistent/home/.cache/bazel", startup_options.output_root);
+  ASSERT_EQ("/nonexistent/home/.cache/bazel", startup_options_->output_root);
 }
 
 TEST_F(StartupOptionsTest, OutputRootUseBuiltin) {
@@ -69,34 +82,32 @@ TEST_F(StartupOptionsTest, OutputRootUseBuiltin) {
   // that out is hard.
   setenv("HOME", "", 1);
   unsetenv("TEST_TMPDIR");
+  ReinitStartupOptions();
 
-  blaze::StartupOptions startup_options;
-  ASSERT_EQ("/tmp", startup_options.output_root);
+  ASSERT_EQ("/tmp", startup_options_->output_root);
 }
 
 TEST_F(StartupOptionsTest, IsNullaryTest) {
-  blaze::StartupOptions startup_options;
-  EXPECT_TRUE(startup_options.IsNullary("--master_bazelrc"));
-  EXPECT_TRUE(startup_options.IsNullary("--nomaster_bazelrc"));
-  EXPECT_FALSE(startup_options.IsNullary(""));
-  EXPECT_FALSE(startup_options.IsNullary("--"));
-  EXPECT_FALSE(startup_options.IsNullary("--master_bazelrcascasc"));
+  EXPECT_TRUE(startup_options_->IsNullary("--master_bazelrc"));
+  EXPECT_TRUE(startup_options_->IsNullary("--nomaster_bazelrc"));
+  EXPECT_FALSE(startup_options_->IsNullary(""));
+  EXPECT_FALSE(startup_options_->IsNullary("--"));
+  EXPECT_FALSE(startup_options_->IsNullary("--master_bazelrcascasc"));
   string error_msg = std::string("In argument '--master_bazelrc=foo': option ")
       + std::string("'--master_bazelrc' does not take a value");
-  EXPECT_DEATH(startup_options.IsNullary("--master_bazelrc=foo"),
+  EXPECT_DEATH(startup_options_->IsNullary("--master_bazelrc=foo"),
                error_msg.c_str());
 }
 
 TEST_F(StartupOptionsTest, IsUnaryTest) {
-  blaze::StartupOptions startup_options;
-  EXPECT_FALSE(startup_options.IsUnary(""));
-  EXPECT_FALSE(startup_options.IsUnary("--"));
-
-  EXPECT_TRUE(startup_options.IsUnary("--blazerc=foo"));
-  EXPECT_TRUE(startup_options.IsUnary("--blazerc"));
-  EXPECT_TRUE(startup_options.IsUnary("--blazerc="));
-  EXPECT_TRUE(startup_options.IsUnary("--blazerc"));
-  EXPECT_FALSE(startup_options.IsUnary("--blazercfooblah"));
+  EXPECT_FALSE(startup_options_->IsUnary(""));
+  EXPECT_FALSE(startup_options_->IsUnary("--"));
+
+  EXPECT_TRUE(startup_options_->IsUnary("--blazerc=foo"));
+  EXPECT_TRUE(startup_options_->IsUnary("--blazerc"));
+  EXPECT_TRUE(startup_options_->IsUnary("--blazerc="));
+  EXPECT_TRUE(startup_options_->IsUnary("--blazerc"));
+  EXPECT_FALSE(startup_options_->IsUnary("--blazercfooblah"));
 }
 
 }  // namespace blaze
diff --git a/src/test/cpp/workspace_layout_test.cc b/src/test/cpp/workspace_layout_test.cc
new file mode 100644
index 0000000000..d4ab3c9c64
--- /dev/null
+++ b/src/test/cpp/workspace_layout_test.cc
@@ -0,0 +1,72 @@
+// Copyright 2016 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "third_party/bazel/src/main/cpp/workspace_layout.h"
+
+#include <fcntl.h>
+
+#include "file/base/file.h"
+#include "file/base/filesystem.h"
+#include "file/base/helpers.h"
+#include "file/base/path.h"
+#include "strings/strcat.h"
+#include "gtest/gtest.h"
+#include "third_party/bazel/src/main/cpp/util/file.h"
+
+namespace blaze {
+
+class WorkspaceLayoutTest : public ::testing::Test {
+ protected:
+  WorkspaceLayoutTest() : workspace_layout_(new WorkspaceLayout()) {}
+
+  void SetUp() {
+    build_root_ = file::JoinPath(FLAGS_test_tmpdir, "build_root");
+    CHECK_OK(RecursivelyCreateDir(build_root_, file::Defaults()));
+    CHECK_OK(file::SetContents(
+        file::JoinPath(build_root_, "WORKSPACE"), "", file::Defaults()));
+
+    // Create fake javac so that Blaze can find the javabase
+    string javac = file::JoinPath(FLAGS_test_tmpdir, "javac");
+    CHECK_OK(file::SetContents(javac, "", file::Defaults()));
+    CHECK_GE(chmod(javac.c_str(), 0755), 0);
+
+    string path(getenv("PATH"));
+    string test_tmpdir(getenv("TEST_TMPDIR"));
+    path = test_tmpdir + ":" + path;
+    setenv("PATH", path.c_str(), 1);
+  }
+
+  void TearDown() {
+    file::RecursivelyDelete(build_root_, file::Defaults()).IgnoreError();
+  }
+
+  string build_root_;
+  const std::unique_ptr<WorkspaceLayout> workspace_layout_;
+};
+
+TEST_F(WorkspaceLayoutTest, GetWorkspace) {
+  // "" is returned when there's no workspace path.
+  string cwd = "foo/bar";
+  ASSERT_EQ("", workspace_layout_->GetWorkspace(cwd));
+  ASSERT_FALSE(workspace_layout_->InWorkspace(cwd));
+
+  cwd = build_root_;
+  ASSERT_EQ(build_root_, workspace_layout_->GetWorkspace(cwd));
+  ASSERT_TRUE(workspace_layout_->InWorkspace(build_root_));
+
+  cwd = file::JoinPath(build_root_, "foo/bar");
+  ASSERT_EQ(build_root_, workspace_layout_->GetWorkspace(cwd));
+}
+
+}  // namespace blaze