// Copyright 2017 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 "src/main/cpp/option_processor.h"

#include "src/main/cpp/bazel_startup_options.h"
#include "src/main/cpp/blaze_util.h"
#include "src/main/cpp/blaze_util_platform.h"
#include "src/main/cpp/option_processor-internal.h"
#include "src/main/cpp/rc_file.h"
#include "src/main/cpp/util/file.h"
#include "src/main/cpp/util/file_platform.h"
#include "src/main/cpp/util/path.h"
#include "src/main/cpp/util/path_platform.h"
#include "src/main/cpp/workspace_layout.h"
#include "googlemock/include/gmock/gmock.h"
#include "googletest/include/gtest/gtest.h"

namespace blaze {
using ::testing::HasSubstr;
using ::testing::MatchesRegex;

#if defined(_WIN32) || defined(__CYGWIN__)
constexpr const char* kNullDevice = "nul";
#else  // Assume POSIX if not Windows.
constexpr const char* kNullDevice = "/dev/null";
#endif

extern const char* system_bazelrc_path;

class RcFileTest : public ::testing::Test {
 protected:
  RcFileTest()
      : workspace_(
            blaze_util::JoinPath(blaze::GetEnv("TEST_TMPDIR"), "testdir")),
        cwd_(blaze_util::JoinPath(blaze::GetEnv("TEST_TMPDIR"), "cwd")),
        binary_dir_(
            blaze_util::JoinPath(blaze::GetEnv("TEST_TMPDIR"), "bazeldir")),
        binary_path_(blaze_util::JoinPath(binary_dir_, "bazel")),
        workspace_layout_(new WorkspaceLayout()),
        old_system_bazelrc_path_(system_bazelrc_path) {}

  void SetUp() override {
    // We modify the global system_bazelrc_path to be a relative path.
    // This test allows us to verify that the global bazelrc is read correctly,
    // in the right order relative to the other files.
    //
    // However, this does not test the default path of this file, nor does it
    // test that absolute paths are accepted properly. This is an unfortunate
    // limitation of our testing - within the sandboxed environment of a test,
    // we cannot place a file in arbitrary locations.
    system_bazelrc_path = "bazel.bazelrc";

    ASSERT_TRUE(blaze_util::MakeDirectories(workspace_, 0755));
    ASSERT_TRUE(blaze_util::MakeDirectories(cwd_, 0755));
    ASSERT_TRUE(blaze_util::ChangeDirectory(cwd_));
#if defined(_WIN32) || defined(__CYGWIN__)
    // GetCwd returns a short path on Windows, so we store this expectation now
    // to keep assertions sane in the tests.
    std::string short_cwd;
    std::string error;
    ASSERT_TRUE(blaze_util::AsShortWindowsPath(cwd_, &short_cwd, &error))
        << error;
    cwd_ = short_cwd;

#endif

    ASSERT_TRUE(blaze_util::MakeDirectories(binary_dir_, 0755));
    option_processor_.reset(new OptionProcessor(
        workspace_layout_.get(),
        std::unique_ptr<StartupOptions>(
            new BazelStartupOptions(workspace_layout_.get()))));
  }

  void TearDown() override {
    // TODO(bazel-team): The code below deletes all the files in the workspace
    // and other rc-related directories, but it intentionally skips directories.
    // As a consequence, there may be empty directories from test to test.
    // Remove this once blaze_util::DeleteDirectories(path) exists.
    std::vector<std::string> files;
    blaze_util::GetAllFilesUnder(workspace_, &files);
    for (const std::string& file : files) {
      blaze_util::UnlinkPath(file);
    }
    blaze_util::GetAllFilesUnder(cwd_, &files);
    for (const std::string& file : files) {
      blaze_util::UnlinkPath(file);
    }
    blaze_util::GetAllFilesUnder(binary_dir_, &files);
    for (const std::string& file : files) {
      blaze_util::UnlinkPath(file);
    }
    system_bazelrc_path = old_system_bazelrc_path_.c_str();
  }

  bool SetUpGlobalRcFile(const std::string& contents,
                         std::string* rcfile_path) const {
    const std::string global_rc_path =
        blaze_util::ConvertPath(blaze_util::JoinPath(cwd_, "bazel.bazelrc"));

    if (blaze_util::WriteFile(contents, global_rc_path, 0755)) {
      *rcfile_path = global_rc_path;
      return true;
    }
    return false;
  }

  bool SetUpMasterRcFileInWorkspace(const std::string& contents,
                                    std::string* rcfile_path) const {
    const std::string tools_dir = blaze_util::JoinPath(workspace_, "tools");
    const std::string workspace_rc_path =
        blaze_util::JoinPath(tools_dir, "bazel.rc");
    if (blaze_util::MakeDirectories(tools_dir, 0755) &&
        blaze_util::WriteFile(contents, workspace_rc_path, 0755)) {
      *rcfile_path = workspace_rc_path;
      return true;
    }
    return false;
  }

  bool SetUpMasterRcFileAlongsideBinary(const std::string& contents,
                                        std::string* rcfile_path) const {
    const std::string binary_rc_path =
        blaze_util::JoinPath(binary_dir_, "bazel.bazelrc");
    if (blaze_util::WriteFile(contents, binary_rc_path, 0755)) {
      *rcfile_path = binary_rc_path;
      return true;
    }
    return false;
  }

  // This file is looked for if no --bazelrc is explicitly provided.
  bool SetUpUserRcFileInWorkspace(const std::string& contents,
                                  std::string* rcfile_path) const {
    const std::string workspace_user_rc_path =
        blaze_util::JoinPath(workspace_, ".bazelrc");
    if (blaze_util::WriteFile(contents, workspace_user_rc_path, 0755)) {
      *rcfile_path = workspace_user_rc_path;
      return true;
    }
    return false;
  }

  const std::string workspace_;
  std::string cwd_;
  const std::string binary_dir_;
  const std::string binary_path_;
  const std::unique_ptr<WorkspaceLayout> workspace_layout_;
  const std::string old_system_bazelrc_path_;
  std::unique_ptr<OptionProcessor> option_processor_;
};

using GetRcFileTest = RcFileTest;

TEST_F(GetRcFileTest, GetRcFilesLoadsAllMasterBazelrcs) {
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("", &workspace_rc));
  std::string binary_rc;
  ASSERT_TRUE(SetUpMasterRcFileAlongsideBinary("", &binary_rc));
  std::string global_rc;
  ASSERT_TRUE(SetUpGlobalRcFile("", &global_rc));

  const CommandLine cmd_line =
      CommandLine(binary_path_, {"--bazelrc=/dev/null"}, "build", {});
  std::string error = "check that this string is not modified";
  std::vector<std::unique_ptr<RcFile>> parsed_rcs;
  const blaze_exit_code::ExitCode exit_code =
      option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
                                    &cmd_line, &parsed_rcs, &error);
  EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
  EXPECT_EQ("check that this string is not modified", error);

  // There should be 4 rc files, since "/dev/null" does count along with the 3
  // master rcs.
  ASSERT_EQ(4, parsed_rcs.size());
  const std::deque<std::string> expected_workspace_rc_que = {workspace_rc};
  const std::deque<std::string> expected_binary_rc_que = {binary_rc};
  const std::deque<std::string> expected_global_rc_que = {global_rc};
  const std::deque<std::string> expected_user_rc_que = {kNullDevice};
  EXPECT_EQ(expected_workspace_rc_que, parsed_rcs[0].get()->sources());
  EXPECT_EQ(expected_binary_rc_que, parsed_rcs[1].get()->sources());
  EXPECT_EQ(expected_global_rc_que, parsed_rcs[2].get()->sources());
  EXPECT_EQ(expected_user_rc_que, parsed_rcs[3].get()->sources());
}

TEST_F(GetRcFileTest, GetRcFilesRespectsNoMasterBazelrc) {
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("", &workspace_rc));
  std::string binary_rc;
  ASSERT_TRUE(SetUpMasterRcFileAlongsideBinary("", &binary_rc));
  std::string global_rc;
  ASSERT_TRUE(SetUpGlobalRcFile("", &global_rc));

  const CommandLine cmd_line = CommandLine(
      binary_path_, {"--nomaster_bazelrc", "--bazelrc=/dev/null"}, "build", {});
  std::string error = "check that this string is not modified";
  std::vector<std::unique_ptr<RcFile>> parsed_rcs;
  const blaze_exit_code::ExitCode exit_code =
      option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
                                    &cmd_line, &parsed_rcs, &error);
  EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
  EXPECT_EQ("check that this string is not modified", error);

  // /dev/null is technically a file, but no master rcs should have been loaded.
  const std::deque<std::string> expected_user_rc_que = {kNullDevice};
  EXPECT_EQ(expected_user_rc_que, parsed_rcs[0].get()->sources());
}

TEST_F(GetRcFileTest, GetRcFilesReadsCommandLineUserRc) {
  const std::string cmdline_rc_path =
      blaze_util::JoinPath(workspace_, "mybazelrc");
  ASSERT_TRUE(
      blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
  ASSERT_TRUE(blaze_util::WriteFile("", cmdline_rc_path, 0755));

  const CommandLine cmd_line = CommandLine(
      binary_path_, {"--nomaster_bazelrc", "--bazelrc=" + cmdline_rc_path},
      "build", {});
  std::string error = "check that this string is not modified";
  std::vector<std::unique_ptr<RcFile>> parsed_rcs;
  const blaze_exit_code::ExitCode exit_code =
      option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
                                    &cmd_line, &parsed_rcs, &error);
  EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
  EXPECT_EQ("check that this string is not modified", error);

  // Because of the variety of path representations in windows, this
  // equality test does not attempt to check the entire path.
  ASSERT_EQ(1, parsed_rcs.size());
  ASSERT_EQ(1, parsed_rcs[0].get()->sources().size());
  EXPECT_THAT(parsed_rcs[0].get()->sources().front(), HasSubstr("mybazelrc"));
}

TEST_F(GetRcFileTest, GetRcFilesReadsUserRcInWorkspace) {
  // We expect the user rc to be read when from the workspace if no alternative
  // --bazelrc is provided.
  std::string user_workspace_rc;
  ASSERT_TRUE(SetUpUserRcFileInWorkspace("", &user_workspace_rc));

  const CommandLine cmd_line =
      CommandLine(binary_path_, {"--nomaster_bazelrc"}, "build", {});
  std::string error = "check that this string is not modified";
  std::vector<std::unique_ptr<RcFile>> parsed_rcs;
  const blaze_exit_code::ExitCode exit_code =
      option_processor_->GetRcFiles(workspace_layout_.get(), workspace_, cwd_,
                                    &cmd_line, &parsed_rcs, &error);
  EXPECT_EQ(blaze_exit_code::SUCCESS, exit_code);
  EXPECT_EQ("check that this string is not modified", error);

  const std::deque<std::string> expected_user_rc_que = {user_workspace_rc};
  ASSERT_EQ(1, parsed_rcs.size());
  EXPECT_EQ(expected_user_rc_que, parsed_rcs[0].get()->sources());
}

using ParseOptionsTest = RcFileTest;

TEST_F(ParseOptionsTest, IgnoreAllRcFilesIgnoresAllMasterAndUserRcFiles) {
  // Put fake options in different expected rc files, to check that none of them
  // are read.
  std::string user_workspace_rc;
  ASSERT_TRUE(
      SetUpUserRcFileInWorkspace("startup --userfoo", &user_workspace_rc));
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("startup --workspacemasterfoo",
                                           &workspace_rc));
  std::string binary_rc;
  ASSERT_TRUE(SetUpMasterRcFileAlongsideBinary("startup --binarymasterfoo",
                                               &binary_rc));
  std::string global_rc;
  ASSERT_TRUE(SetUpGlobalRcFile("startup --globalmasterfoo", &global_rc));

  const std::vector<std::string> args = {binary_path_, "--ignore_all_rc_files",
                                         "build"};
  // Expect no error due to the incorrect options, as non of them should have
  // been loaded.
  std::string error;
  EXPECT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error));
  ASSERT_EQ("", error);

  // Check that the startup options' provenance message contains nothing
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_EQ(output, "");
}

TEST_F(ParseOptionsTest, LaterIgnoreRcFileValueWins) {
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("startup --workspacemasterfoo",
                                           &workspace_rc));

  const std::vector<std::string> args = {binary_path_, "--ignore_all_rc_files",
                                         "--noignore_all_rc_files", "build"};
  std::string error;
  EXPECT_EQ(blaze_exit_code::BAD_ARGV,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error));
  ASSERT_EQ(
      "Unknown startup option: '--workspacemasterfoo'.\n  For more info, run "
      "'bazel help startup_options'.",
      error);

  // Check that the startup options' provenance message contains the provenance
  // of the incorrect option.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_THAT(output,
              MatchesRegex("INFO: Reading 'startup' options from .*bazel.rc: "
                           "--workspacemasterfoo\n"));
}

TEST_F(ParseOptionsTest, IgnoreAllRcFilesIgnoresCommandLineRcFileToo) {
  // Put fake options in different expected rc files, to check that none of them
  // are read.
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("startup --workspacemasterfoo",
                                           &workspace_rc));
  std::string binary_rc;
  ASSERT_TRUE(SetUpMasterRcFileAlongsideBinary("startup --binarymasterfoo",
                                               &binary_rc));
  std::string global_rc;
  ASSERT_TRUE(SetUpGlobalRcFile("startup --globalmasterfoo", &global_rc));
  const std::string cmdline_rc_path =
      blaze_util::JoinPath(workspace_, "mybazelrc");
  ASSERT_TRUE(
      blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
  ASSERT_TRUE(
      blaze_util::WriteFile("startup --userfoo", cmdline_rc_path, 0755));

  const std::vector<std::string> args = {binary_path_, "--ignore_all_rc_files",
                                         "--bazelrc=" + cmdline_rc_path,
                                         "build"};
  // Expect no error due to the incorrect options, as non of them should have
  // been loaded.
  std::string error;
  EXPECT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error));
  ASSERT_EQ("", error);

  // Check that the startup options' provenance message contains nothing
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_EQ(output, "");
}

TEST_F(ParseOptionsTest, CommandLineBazelrcHasUnknownOption) {
  const std::string cmdline_rc_path =
      blaze_util::JoinPath(workspace_, "mybazelrc");
  ASSERT_TRUE(
      blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
  ASSERT_TRUE(blaze_util::WriteFile("startup --foo", cmdline_rc_path, 0755));

  const std::vector<std::string> args = {binary_path_, "--nomaster_bazelrc",
                                         "--bazelrc=" + cmdline_rc_path,
                                         "build"};
  const std::string expected_error =
      "Unknown startup option: '--foo'.\n"
      "  For more info, run 'bazel help startup_options'.";
  std::string error;
  ASSERT_NE(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error))
      << error;
  ASSERT_EQ(expected_error, error);

  // Check that the startup options' provenance message contains the correct
  // information for the incorrect flag, and does not print the command-line
  // provided startup flags.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_THAT(output,
              MatchesRegex(
                  "INFO: Reading 'startup' options from .*mybazelrc: --foo\n"));
}

TEST_F(ParseOptionsTest, MasterBazelrcHasUnknownOption) {
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("startup --foo", &workspace_rc));

  const std::vector<std::string> args = {binary_path_, "build"};

  // Expect no error due to the incorrect --foo.
  std::string error;
  EXPECT_EQ(blaze_exit_code::BAD_ARGV,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error));
  ASSERT_EQ(
      "Unknown startup option: '--foo'.\n"
      "  For more info, run 'bazel help startup_options'.",
      error);

  // Check that the startup options' provenance message contains nothing for the
  // master bazelrc.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_THAT(
      output,
      MatchesRegex(
          "INFO: Reading 'startup' options from .*tools.bazel.rc: --foo\n"));
}

TEST_F(ParseOptionsTest,
       IncorrectMasterBazelrcIgnoredWhenNoMasterBazelrcIsPresent) {
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("startup --foo", &workspace_rc));
  std::string global_rc;
  ASSERT_TRUE(SetUpGlobalRcFile("startup --globalfoo", &global_rc));

  const std::vector<std::string> args = {binary_path_, "--nomaster_bazelrc",
                                         "build"};

  // Expect no error due to the incorrect --foo.
  std::string error;
  EXPECT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error));
  ASSERT_EQ("", error);

  // Check that the startup options' provenance message contains nothing for the
  // master bazelrc.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_EQ(output, "");
}

TEST_F(ParseOptionsTest, UserBazelrcHasPriorityOverMasterBazelrc) {
  std::string user_rc;
  ASSERT_TRUE(
      SetUpUserRcFileInWorkspace("startup --max_idle_secs=123", &user_rc));
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("startup --max_idle_secs=42",
                                           &workspace_rc));

  const std::vector<std::string> args = {binary_path_, "build"};
  std::string error;
  ASSERT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error))
      << error;

  EXPECT_EQ(123, option_processor_->GetParsedStartupOptions()->max_idle_secs);

  // Check that the startup options' provenance message contains the correct
  // information for the provided rc, and prints nothing for the master bazelrc.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  const std::string expected_message = "INFO: Reading 'startup' options from " +
                                       workspace_rc +
                                       ": --max_idle_secs=42\n"
                                       "INFO: Reading 'startup' options from " +
                                       user_rc + ": --max_idle_secs=123\n";
  EXPECT_EQ(output, expected_message);
}

TEST_F(ParseOptionsTest, MasterBazelrcOverridesNoMasterBazelrc) {
  std::string workspace_rc;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace("startup --max_idle_secs=123",
                                           &workspace_rc));

  const std::vector<std::string> args = {"bazel", "--nomaster_bazelrc",
                                         "--master_bazelrc", "build"};
  std::string error;
  ASSERT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error))
      << error;
  EXPECT_EQ(123, option_processor_->GetParsedStartupOptions()->max_idle_secs);

  // Check that the startup options' provenance message contains the correct
  // information for the master bazelrc.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_THAT(output, MatchesRegex("INFO: Reading 'startup' options from "
                                   ".*tools.bazel.rc: --max_idle_secs=123\n"));
}

TEST_F(ParseOptionsTest, MultipleStartupArgsInMasterBazelrcWorksCorrectly) {
  // Add startup flags to the master bazelrc.
  std::string master_rc_path;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace(
      "startup --max_idle_secs=42\nstartup --io_nice_level=6",
      &master_rc_path));

  const std::vector<std::string> args = {binary_path_, "build"};
  std::string error;
  ASSERT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error))
      << error;

  EXPECT_EQ(42, option_processor_->GetParsedStartupOptions()->max_idle_secs);
  EXPECT_EQ(6, option_processor_->GetParsedStartupOptions()->io_nice_level);

  // Check that the startup options get grouped together properly in the output
  // message.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_THAT(
      output,
      MatchesRegex("INFO: Reading 'startup' options from .*tools.bazel.rc: "
                   "--max_idle_secs=42 --io_nice_level=6\n"));
}

TEST_F(ParseOptionsTest, CustomBazelrcOverridesMasterBazelrc) {
  // Add startup flags to the master bazelrc.
  std::string master_rc_path;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace(
      "startup --max_idle_secs=42\nstartup --io_nice_level=6",
      &master_rc_path));

  // Override one of the master bazelrc's flags in the commandline rc.
  const std::string cmdline_rc_path =
      blaze_util::JoinPath(workspace_, "mybazelrc");
  ASSERT_TRUE(
      blaze_util::MakeDirectories(blaze_util::Dirname(cmdline_rc_path), 0755));
  ASSERT_TRUE(blaze_util::WriteFile("startup --max_idle_secs=123",
                                    cmdline_rc_path, 0755));

  const std::vector<std::string> args = {
      "bazel", "--bazelrc=" + cmdline_rc_path, "build"};
  std::string error;
  ASSERT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error))
      << error;

  EXPECT_EQ(123, option_processor_->GetParsedStartupOptions()->max_idle_secs);
  EXPECT_EQ(6, option_processor_->GetParsedStartupOptions()->io_nice_level);

  // Check that the options are reported in the correct order in the provenance
  // message.
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_THAT(
      output,
      MatchesRegex("INFO: Reading 'startup' options from .*tools.*bazel.rc: "
                   "--max_idle_secs=42 --io_nice_level=6\n"
                   "INFO: Reading 'startup' options from .*mybazelrc: "
                   "--max_idle_secs=123\n"));
}

TEST_F(ParseOptionsTest, BazelRcImportsMaintainsFlagOrdering) {
  // Override one of the master bazelrc's flags in the custom bazelrc.
  const std::string imported_rc_path =
      blaze_util::JoinPath(workspace_, "myimportedbazelrc");
  ASSERT_TRUE(
      blaze_util::MakeDirectories(blaze_util::Dirname(imported_rc_path), 0755));
  ASSERT_TRUE(blaze_util::WriteFile(
      "startup --max_idle_secs=123\nstartup --io_nice_level=4",
      imported_rc_path, 0755));

  // Add startup flags the imported bazelrc.
  std::string master_rc_path;
  ASSERT_TRUE(SetUpMasterRcFileInWorkspace(
      "startup --max_idle_secs=42\nimport " + imported_rc_path +
          "\nstartup --io_nice_level=6",
      &master_rc_path));

  const std::vector<std::string> args = {"bazel", "build"};
  std::string error;
  ASSERT_EQ(blaze_exit_code::SUCCESS,
            option_processor_->ParseOptions(args, workspace_, cwd_, &error))
      << error;

  EXPECT_EQ(123, option_processor_->GetParsedStartupOptions()->max_idle_secs);
  EXPECT_EQ(6, option_processor_->GetParsedStartupOptions()->io_nice_level);

  // Check that the options are reported in the correct order in the provenance
  // message, the imported file between the two master flags
  testing::internal::CaptureStderr();
  option_processor_->PrintStartupOptionsProvenanceMessage();
  const std::string& output = testing::internal::GetCapturedStderr();

  EXPECT_THAT(
      output,
      MatchesRegex("INFO: Reading 'startup' options from .*tools.*bazel.rc: "
                   "--max_idle_secs=42\n"
                   "INFO: Reading 'startup' options from .*myimportedbazelrc: "
                   "--max_idle_secs=123 --io_nice_level=4\n"
                   "INFO: Reading 'startup' options from .*tools.*bazel.rc: "
                   "--io_nice_level=6\n"));
}

}  // namespace blaze