Description redacted.

--
PiperOrigin-RevId: 141483567
MOS_MIGRATED_REVID=141483567

2 files changed, 108 insertions, 25 deletions

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