diagnostics/cros_healthd/routines/subproc_routine_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2019 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "diagnostics/cros_healthd/routines/subproc_routine.h"

 #include <cstdint>
 #include <list>
 #include <utility>
 #include <vector>

 #include <base/command_line.h>
 #include <base/test/simple_test_tick_clock.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include "diagnostics/cros_healthd/routines/diag_process_adapter.h"
 #include "diagnostics/cros_healthd/routines/routine_test_utils.h"

 namespace diagnostics {
 namespace mojo_ipc = ::chromeos::cros_healthd::mojom;

 namespace {

 using ::testing::_;
 using ::testing::AtMost;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 using ::testing::StrictMock;
 using ::testing::Test;

 void CheckRoutineUpdate(uint32_t progress_percent,
                         std::string status_message,
                         mojo_ipc::DiagnosticRoutineStatusEnum status,
                         const mojo_ipc::RoutineUpdate& update) {
   EXPECT_EQ(update.progress_percent, progress_percent);
   VerifyNonInteractiveUpdate(update.routine_update_union, status,
                              status_message);
 }

 class MockCallback {
  public:
   MOCK_METHOD(bool, PreStart, ());
   MOCK_METHOD(void, PostStop, ());
 };

 class MockDiagProcessAdapter : public DiagProcessAdapter {
  public:
   MOCK_METHOD(base::TerminationStatus,
               GetStatus,
               (const base::ProcessHandle&),
               (const, override));
   MOCK_METHOD(bool,
               StartProcess,
               (const std::vector<std::string>&, base::ProcessHandle*),
               (override));
   MOCK_METHOD(bool, KillProcess, (const base::ProcessHandle&), (override));
 };

 }  // namespace

 class SubprocRoutineTest : public Test {
  protected:
   SubprocRoutineTest() = default;
   SubprocRoutineTest(const SubprocRoutineTest&) = delete;
   SubprocRoutineTest& operator=(const SubprocRoutineTest&) = delete;

   SubprocRoutine* routine() { return routine_.get(); }

   mojo_ipc::RoutineUpdate* update() { return &update_; }

   StrictMock<MockDiagProcessAdapter>* mock_adapter() { return mock_adapter_; }
   base::SimpleTestTickClock* tick_clock() { return tick_clock_; }

   void CreateRoutine(uint32_t predicted_duration_in_seconds = 10) {
     auto mock_adapter_ptr =
         std::make_unique<StrictMock<MockDiagProcessAdapter>>();
     mock_adapter_ = mock_adapter_ptr.get();
     auto tick_clock_ptr = std::make_unique<base::SimpleTestTickClock>();
     tick_clock_ = tick_clock_ptr.get();

     // We never actually run subprocesses in this unit test, because this module
     // is not actually responsible for process invocation, and we trust the
     // DiagProcessAdapter to do things appropriately.
     auto command_line = base::CommandLine({"/dev/null"});

     routine_ = std::make_unique<SubprocRoutine>(
         std::move(mock_adapter_ptr), std::move(tick_clock_ptr),
         std::list<base::CommandLine>{command_line},
         predicted_duration_in_seconds);
   }

   void CreateRoutineWithMultipleCmds(
       uint32_t predicted_duration_in_seconds = 10) {
     auto mock_adapter_ptr =
         std::make_unique<StrictMock<MockDiagProcessAdapter>>();
     mock_adapter_ = mock_adapter_ptr.get();
     auto tick_clock_ptr = std::make_unique<base::SimpleTestTickClock>();
     tick_clock_ = tick_clock_ptr.get();

     // We never actually run subprocesses in this unit test, because this module
     // is not actually responsible for process invocation, and we trust the
     // DiagProcessAdapter to do things appropriately.
     auto command_line = base::CommandLine({"/dev/null"});
     auto command_line1 = base::CommandLine({"/dev/zero"});

     routine_ = std::make_unique<SubprocRoutine>(
         std::move(mock_adapter_ptr), std::move(tick_clock_ptr),
         std::list<base::CommandLine>{command_line, command_line1},
         predicted_duration_in_seconds);
   }

   void RegisterPreStartCallback(base::OnceCallback<bool()> callback) {
     routine_->RegisterPreStartCallback(std::move(callback));
   }

   void RegisterPostStopCallback(base::OnceClosure callback) {
     routine_->RegisterPostStopCallback(std::move(callback));
   }

   void RunRoutineWithTerminationStatus(base::TerminationStatus status) {
     EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
         .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                         Return(true)));
     routine_->Start();
     PopulateStatusUpdateForRunningRoutine(status);
   }

   void PopulateStatusUpdateForRunningRoutine(base::TerminationStatus status) {
     EXPECT_CALL(*mock_adapter_, GetStatus(_)).WillOnce(Return(status));
     routine_->PopulateStatusUpdate(&update_, true);
   }

   void DestroyRoutine() { routine_.reset(); }

  private:
   StrictMock<MockDiagProcessAdapter>* mock_adapter_;  // Owned by |routine_|.
   base::SimpleTestTickClock* tick_clock_;             // Owned by |routine_|.
   std::unique_ptr<SubprocRoutine> routine_;
   mojo_ipc::RoutineUpdate update_{0, mojo::ScopedHandle(),
                                   mojo_ipc::RoutineUpdateUnion::New()};
 };

 TEST_F(SubprocRoutineTest, InvokeSubprocWithSuccess) {
   CreateRoutine();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));

   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));
   routine()->Start();

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   routine()->PopulateStatusUpdate(&update, false);

   CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
 }

 TEST_F(SubprocRoutineTest, InvokeSubprocWithMultipleCmdsWithSuccess) {
   CreateRoutineWithMultipleCmds();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .Times(2)
       .WillRepeatedly(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                             Return(true)));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .Times(2)
       .WillRepeatedly(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

   routine()->Start();

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   tick_clock()->Advance(base::TimeDelta::FromSeconds(5));
   routine()->PopulateStatusUpdate(&update, false);
   CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);
   routine()->PopulateStatusUpdate(&update, false);
   CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
 }

 TEST_F(SubprocRoutineTest, InvokeSubprocWithPreStartCallbackSuccess) {
   CreateRoutine();
   StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
   EXPECT_CALL(*mock_callback, PreStart()).WillOnce(Return(true));
   RegisterPreStartCallback(
       base::BindOnce(&MockCallback::PreStart, base::Owned(mock_callback)));
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

   routine()->Start();

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   routine()->PopulateStatusUpdate(&update, false);
   CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
 }

 TEST_F(SubprocRoutineTest, InvokeSubprocWithPreStartCallbackFailure) {
   CreateRoutine();
   StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
   EXPECT_CALL(*mock_callback, PreStart()).WillOnce(Return(false));
   base::OnceCallback<bool()> cb =
       base::Bind(&MockCallback::PreStart, base::Owned(mock_callback));
   RegisterPreStartCallback(std::move(cb));

   routine()->Start();

   EXPECT_EQ(routine()->GetStatus(),
             mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart);
 }

 TEST_F(SubprocRoutineTest, InvokeSubprocWithPostStopCallback) {
   CreateRoutine();
   StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
   EXPECT_CALL(*mock_callback, PostStop());
   RegisterPostStopCallback(
       base::BindOnce(&MockCallback::PostStop, base::Owned(mock_callback)));
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

   routine()->Start();

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   routine()->PopulateStatusUpdate(&update, false);
   CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
   DestroyRoutine();
 }

 TEST_F(SubprocRoutineTest, InvokeSubprocWithPostStopCallbackWithoutStart) {
   CreateRoutine();
   StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
   EXPECT_CALL(*mock_callback, PostStop());
   RegisterPostStopCallback(
       base::BindOnce(&MockCallback::PostStop, base::Owned(mock_callback)));
 }

 TEST_F(SubprocRoutineTest, InvokeSubprocWithMultipleCmdsAndPreStartCallback) {
   CreateRoutineWithMultipleCmds();
   StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
   EXPECT_CALL(*mock_callback, PreStart()).WillOnce(Return(true));
   RegisterPreStartCallback(
       base::BindOnce(&MockCallback::PreStart, base::Owned(mock_callback)));
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .Times(2)
       .WillRepeatedly(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                             Return(true)));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .Times(2)
       .WillRepeatedly(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

   routine()->Start();

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   tick_clock()->Advance(base::TimeDelta::FromSeconds(5));
   routine()->PopulateStatusUpdate(&update, false);
   CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);
   routine()->PopulateStatusUpdate(&update, false);
   CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
 }

 TEST_F(SubprocRoutineTest, InvokeSubprocWithFailure) {
   CreateRoutine();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .WillOnce(Return(base::TERMINATION_STATUS_ABNORMAL_TERMINATION));
   routine()->Start();

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   routine()->PopulateStatusUpdate(&update, false);

   CheckRoutineUpdate(100, kSubprocRoutineFailedMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kFailed, update);
 }

 TEST_F(SubprocRoutineTest, FailInvokingSubproc) {
   CreateRoutine();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _)).WillOnce(Return(false));
   routine()->Start();

   EXPECT_EQ(routine()->GetStatus(),
             mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart);
 }

 TEST_F(SubprocRoutineTest, TestHalfProgressPercent) {
   CreateRoutine();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .Times(AtMost(2))
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
       .WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

   routine()->Start();

   tick_clock()->Advance(base::TimeDelta::FromSeconds(5));

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   routine()->PopulateStatusUpdate(&update, false);

   CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);
 }

 TEST_F(SubprocRoutineTest, TestHalfProgressThenCancel) {
   CreateRoutine();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));
   EXPECT_CALL(*mock_adapter(), KillProcess(_)).Times(AtMost(1));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .Times(AtMost(4))
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
       .WillOnce(Return(base::TERMINATION_STATUS_ABNORMAL_TERMINATION));

   routine()->Start();

   tick_clock()->Advance(base::TimeDelta::FromSeconds(5));
   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   routine()->PopulateStatusUpdate(&update, false);

   CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);

   routine()->Cancel();

   tick_clock()->Advance(base::TimeDelta::FromSeconds(1));

   routine()->PopulateStatusUpdate(&update, false);

   CheckRoutineUpdate(50, kSubprocRoutineProcessCancellingMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kCancelling,
                      update);

   // Now the process should appear dead
   routine()->PopulateStatusUpdate(&update, false);

   CheckRoutineUpdate(50, kSubprocRoutineCancelledMessage,
                      mojo_ipc::DiagnosticRoutineStatusEnum::kCancelled, update);
 }

 // Test that we can handle repeated cancel commands to a process that is slow to
 // die.
 TEST_F(SubprocRoutineTest, RepeatedCancelCommands) {
   CreateRoutine();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));
   EXPECT_CALL(*mock_adapter(), KillProcess(_));
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .Times(4)
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
       .WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

   routine()->Start();
   routine()->Cancel();

   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   routine()->PopulateStatusUpdate(&update, false);

   VerifyNonInteractiveUpdate(update.routine_update_union,
                              mojo_ipc::DiagnosticRoutineStatusEnum::kCancelling,
                              kSubprocRoutineProcessCancellingMessage);

   routine()->Cancel();

   routine()->PopulateStatusUpdate(&update, false);

   VerifyNonInteractiveUpdate(update.routine_update_union,
                              mojo_ipc::DiagnosticRoutineStatusEnum::kCancelled,
                              kSubprocRoutineCancelledMessage);
 }

 // Test that SubprocRoutine handles an invalid termination status returned from
 // the diag process adapter.
 TEST_F(SubprocRoutineTest, InvalidTerminationStatus) {
   CreateRoutine();
   RunRoutineWithTerminationStatus(static_cast<base::TerminationStatus>(-1));
   VerifyNonInteractiveUpdate(update()->routine_update_union,
                              mojo_ipc::DiagnosticRoutineStatusEnum::kError,
                              kSubprocRoutineErrorMessage);
 }

 // Test that SubprocRoutine handles a command line that fails to start.
 TEST_F(SubprocRoutineTest, FailedToStart) {
   CreateRoutine();
   RunRoutineWithTerminationStatus(base::TERMINATION_STATUS_LAUNCH_FAILED);
   VerifyNonInteractiveUpdate(
       update()->routine_update_union,
       mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart,
       kSubprocRoutineFailedToLaunchProcessMessage);
 }

 // Test that we attempt to kill a running process during destruction.
 TEST_F(SubprocRoutineTest, KillProcessDuringDestruction) {
   CreateRoutine();
   EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
       .WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
                       Return(true)));

   routine()->Start();

   // When we kill the routine, it should attempt to kill a running process.
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING));
   EXPECT_CALL(*mock_adapter(), KillProcess(_));

   DestroyRoutine();
 }

 // Test that we report the correct progress percent when we don't know the
 // routine's predicted duration.
 TEST_F(SubprocRoutineTest, NoPredictedDuration) {
   CreateRoutine(/*predicted_duration_in_seconds=*/0);
   RunRoutineWithTerminationStatus(base::TERMINATION_STATUS_STILL_RUNNING);
   EXPECT_EQ(update()->progress_percent,
             kSubprocRoutineFakeProgressPercentUnknown);

   // Since we left a zombie process, expect the destructor to try and kill it.
   EXPECT_CALL(*mock_adapter(), GetStatus(_))
       .WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));
 }

 // Test that calling resume doesn't crash.
 TEST_F(SubprocRoutineTest, Resume) {
   CreateRoutine();
   routine()->Resume();
 }

 // Test that we can create a SubprocRoutine with the production constructor.
 TEST(SubprocRoutineTestNoFixture, ProductionConstructor) {
   std::unique_ptr<SubprocRoutine> prod_routine =
       std::make_unique<SubprocRoutine>(base::CommandLine({"/dev/null"}),
                                        /*predicted_duration_in_seconds=*/0);
   mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
                                  mojo_ipc::RoutineUpdateUnion::New()};
   prod_routine->PopulateStatusUpdate(&update, false);
   VerifyNonInteractiveUpdate(update.routine_update_union,
                              mojo_ipc::DiagnosticRoutineStatusEnum::kReady,
                              kSubprocRoutineReadyMessage);
 }

 }  // namespace diagnostics
	// Copyright 2019 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "diagnostics/cros_healthd/routines/subproc_routine.h"

	#include <cstdint>
	#include <list>
	#include <utility>
	#include <vector>

	#include <base/command_line.h>
	#include <base/test/simple_test_tick_clock.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include "diagnostics/cros_healthd/routines/diag_process_adapter.h"
	#include "diagnostics/cros_healthd/routines/routine_test_utils.h"

	namespace diagnostics {
	namespace mojo_ipc = ::chromeos::cros_healthd::mojom;

	namespace {

	using ::testing::_;
	using ::testing::AtMost;
	using ::testing::DoAll;
	using ::testing::Return;
	using ::testing::SetArgPointee;
	using ::testing::StrictMock;
	using ::testing::Test;

	void CheckRoutineUpdate(uint32_t progress_percent,
	std::string status_message,
	mojo_ipc::DiagnosticRoutineStatusEnum status,
	const mojo_ipc::RoutineUpdate& update) {
	EXPECT_EQ(update.progress_percent, progress_percent);
	VerifyNonInteractiveUpdate(update.routine_update_union, status,
	status_message);
	}

	class MockCallback {
	public:
	MOCK_METHOD(bool, PreStart, ());
	MOCK_METHOD(void, PostStop, ());
	};

	class MockDiagProcessAdapter : public DiagProcessAdapter {
	public:
	MOCK_METHOD(base::TerminationStatus,
	GetStatus,
	(const base::ProcessHandle&),
	(const, override));
	MOCK_METHOD(bool,
	StartProcess,
	(const std::vector<std::string>&, base::ProcessHandle*),
	(override));
	MOCK_METHOD(bool, KillProcess, (const base::ProcessHandle&), (override));
	};

	} // namespace

	class SubprocRoutineTest : public Test {
	protected:
	SubprocRoutineTest() = default;
	SubprocRoutineTest(const SubprocRoutineTest&) = delete;
	SubprocRoutineTest& operator=(const SubprocRoutineTest&) = delete;

	SubprocRoutine* routine() { return routine_.get(); }

	mojo_ipc::RoutineUpdate* update() { return &update_; }

	StrictMock<MockDiagProcessAdapter>* mock_adapter() { return mock_adapter_; }
	base::SimpleTestTickClock* tick_clock() { return tick_clock_; }

	void CreateRoutine(uint32_t predicted_duration_in_seconds = 10) {
	auto mock_adapter_ptr =
	std::make_unique<StrictMock<MockDiagProcessAdapter>>();
	mock_adapter_ = mock_adapter_ptr.get();
	auto tick_clock_ptr = std::make_unique<base::SimpleTestTickClock>();
	tick_clock_ = tick_clock_ptr.get();

	// We never actually run subprocesses in this unit test, because this module
	// is not actually responsible for process invocation, and we trust the
	// DiagProcessAdapter to do things appropriately.
	auto command_line = base::CommandLine({"/dev/null"});

	routine_ = std::make_unique<SubprocRoutine>(
	std::move(mock_adapter_ptr), std::move(tick_clock_ptr),
	std::list<base::CommandLine>{command_line},
	predicted_duration_in_seconds);
	}

	void CreateRoutineWithMultipleCmds(
	uint32_t predicted_duration_in_seconds = 10) {
	auto mock_adapter_ptr =
	std::make_unique<StrictMock<MockDiagProcessAdapter>>();
	mock_adapter_ = mock_adapter_ptr.get();
	auto tick_clock_ptr = std::make_unique<base::SimpleTestTickClock>();
	tick_clock_ = tick_clock_ptr.get();

	// We never actually run subprocesses in this unit test, because this module
	// is not actually responsible for process invocation, and we trust the
	// DiagProcessAdapter to do things appropriately.
	auto command_line = base::CommandLine({"/dev/null"});
	auto command_line1 = base::CommandLine({"/dev/zero"});

	routine_ = std::make_unique<SubprocRoutine>(
	std::move(mock_adapter_ptr), std::move(tick_clock_ptr),
	std::list<base::CommandLine>{command_line, command_line1},
	predicted_duration_in_seconds);
	}

	void RegisterPreStartCallback(base::OnceCallback<bool()> callback) {
	routine_->RegisterPreStartCallback(std::move(callback));
	}

	void RegisterPostStopCallback(base::OnceClosure callback) {
	routine_->RegisterPostStopCallback(std::move(callback));
	}

	void RunRoutineWithTerminationStatus(base::TerminationStatus status) {
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	routine_->Start();
	PopulateStatusUpdateForRunningRoutine(status);
	}

	void PopulateStatusUpdateForRunningRoutine(base::TerminationStatus status) {
	EXPECT_CALL(*mock_adapter_, GetStatus(_)).WillOnce(Return(status));
	routine_->PopulateStatusUpdate(&update_, true);
	}

	void DestroyRoutine() { routine_.reset(); }

	private:
	StrictMock<MockDiagProcessAdapter>* mock_adapter_; // Owned by \|routine_\|.
	base::SimpleTestTickClock* tick_clock_; // Owned by \|routine_\|.
	std::unique_ptr<SubprocRoutine> routine_;
	mojo_ipc::RoutineUpdate update_{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	};

	TEST_F(SubprocRoutineTest, InvokeSubprocWithSuccess) {
	CreateRoutine();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));

	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));
	routine()->Start();

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	routine()->PopulateStatusUpdate(&update, false);

	CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
	}

	TEST_F(SubprocRoutineTest, InvokeSubprocWithMultipleCmdsWithSuccess) {
	CreateRoutineWithMultipleCmds();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.Times(2)
	.WillRepeatedly(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.Times(2)
	.WillRepeatedly(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

	routine()->Start();

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	tick_clock()->Advance(base::TimeDelta::FromSeconds(5));
	routine()->PopulateStatusUpdate(&update, false);
	CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);
	routine()->PopulateStatusUpdate(&update, false);
	CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
	}

	TEST_F(SubprocRoutineTest, InvokeSubprocWithPreStartCallbackSuccess) {
	CreateRoutine();
	StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
	EXPECT_CALL(*mock_callback, PreStart()).WillOnce(Return(true));
	RegisterPreStartCallback(
	base::BindOnce(&MockCallback::PreStart, base::Owned(mock_callback)));
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

	routine()->Start();

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	routine()->PopulateStatusUpdate(&update, false);
	CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
	}

	TEST_F(SubprocRoutineTest, InvokeSubprocWithPreStartCallbackFailure) {
	CreateRoutine();
	StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
	EXPECT_CALL(*mock_callback, PreStart()).WillOnce(Return(false));
	base::OnceCallback<bool()> cb =
	base::Bind(&MockCallback::PreStart, base::Owned(mock_callback));
	RegisterPreStartCallback(std::move(cb));

	routine()->Start();

	EXPECT_EQ(routine()->GetStatus(),
	mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart);
	}

	TEST_F(SubprocRoutineTest, InvokeSubprocWithPostStopCallback) {
	CreateRoutine();
	StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
	EXPECT_CALL(*mock_callback, PostStop());
	RegisterPostStopCallback(
	base::BindOnce(&MockCallback::PostStop, base::Owned(mock_callback)));
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

	routine()->Start();

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	routine()->PopulateStatusUpdate(&update, false);
	CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
	DestroyRoutine();
	}

	TEST_F(SubprocRoutineTest, InvokeSubprocWithPostStopCallbackWithoutStart) {
	CreateRoutine();
	StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
	EXPECT_CALL(*mock_callback, PostStop());
	RegisterPostStopCallback(
	base::BindOnce(&MockCallback::PostStop, base::Owned(mock_callback)));
	}

	TEST_F(SubprocRoutineTest, InvokeSubprocWithMultipleCmdsAndPreStartCallback) {
	CreateRoutineWithMultipleCmds();
	StrictMock<MockCallback>* mock_callback = new StrictMock<MockCallback>();
	EXPECT_CALL(*mock_callback, PreStart()).WillOnce(Return(true));
	RegisterPreStartCallback(
	base::BindOnce(&MockCallback::PreStart, base::Owned(mock_callback)));
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.Times(2)
	.WillRepeatedly(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.Times(2)
	.WillRepeatedly(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

	routine()->Start();

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	tick_clock()->Advance(base::TimeDelta::FromSeconds(5));
	routine()->PopulateStatusUpdate(&update, false);
	CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);
	routine()->PopulateStatusUpdate(&update, false);
	CheckRoutineUpdate(100, kSubprocRoutineSucceededMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kPassed, update);
	}

	TEST_F(SubprocRoutineTest, InvokeSubprocWithFailure) {
	CreateRoutine();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.WillOnce(Return(base::TERMINATION_STATUS_ABNORMAL_TERMINATION));
	routine()->Start();

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	routine()->PopulateStatusUpdate(&update, false);

	CheckRoutineUpdate(100, kSubprocRoutineFailedMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kFailed, update);
	}

	TEST_F(SubprocRoutineTest, FailInvokingSubproc) {
	CreateRoutine();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _)).WillOnce(Return(false));
	routine()->Start();

	EXPECT_EQ(routine()->GetStatus(),
	mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart);
	}

	TEST_F(SubprocRoutineTest, TestHalfProgressPercent) {
	CreateRoutine();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.Times(AtMost(2))
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
	.WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

	routine()->Start();

	tick_clock()->Advance(base::TimeDelta::FromSeconds(5));

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	routine()->PopulateStatusUpdate(&update, false);

	CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);
	}

	TEST_F(SubprocRoutineTest, TestHalfProgressThenCancel) {
	CreateRoutine();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), KillProcess(_)).Times(AtMost(1));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.Times(AtMost(4))
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
	.WillOnce(Return(base::TERMINATION_STATUS_ABNORMAL_TERMINATION));

	routine()->Start();

	tick_clock()->Advance(base::TimeDelta::FromSeconds(5));
	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	routine()->PopulateStatusUpdate(&update, false);

	CheckRoutineUpdate(50, kSubprocRoutineProcessRunningMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kRunning, update);

	routine()->Cancel();

	tick_clock()->Advance(base::TimeDelta::FromSeconds(1));

	routine()->PopulateStatusUpdate(&update, false);

	CheckRoutineUpdate(50, kSubprocRoutineProcessCancellingMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kCancelling,
	update);

	// Now the process should appear dead
	routine()->PopulateStatusUpdate(&update, false);

	CheckRoutineUpdate(50, kSubprocRoutineCancelledMessage,
	mojo_ipc::DiagnosticRoutineStatusEnum::kCancelled, update);
	}

	// Test that we can handle repeated cancel commands to a process that is slow to
	// die.
	TEST_F(SubprocRoutineTest, RepeatedCancelCommands) {
	CreateRoutine();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));
	EXPECT_CALL(*mock_adapter(), KillProcess(_));
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.Times(4)
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING))
	.WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));

	routine()->Start();
	routine()->Cancel();

	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	routine()->PopulateStatusUpdate(&update, false);

	VerifyNonInteractiveUpdate(update.routine_update_union,
	mojo_ipc::DiagnosticRoutineStatusEnum::kCancelling,
	kSubprocRoutineProcessCancellingMessage);

	routine()->Cancel();

	routine()->PopulateStatusUpdate(&update, false);

	VerifyNonInteractiveUpdate(update.routine_update_union,
	mojo_ipc::DiagnosticRoutineStatusEnum::kCancelled,
	kSubprocRoutineCancelledMessage);
	}

	// Test that SubprocRoutine handles an invalid termination status returned from
	// the diag process adapter.
	TEST_F(SubprocRoutineTest, InvalidTerminationStatus) {
	CreateRoutine();
	RunRoutineWithTerminationStatus(static_cast<base::TerminationStatus>(-1));
	VerifyNonInteractiveUpdate(update()->routine_update_union,
	mojo_ipc::DiagnosticRoutineStatusEnum::kError,
	kSubprocRoutineErrorMessage);
	}

	// Test that SubprocRoutine handles a command line that fails to start.
	TEST_F(SubprocRoutineTest, FailedToStart) {
	CreateRoutine();
	RunRoutineWithTerminationStatus(base::TERMINATION_STATUS_LAUNCH_FAILED);
	VerifyNonInteractiveUpdate(
	update()->routine_update_union,
	mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart,
	kSubprocRoutineFailedToLaunchProcessMessage);
	}

	// Test that we attempt to kill a running process during destruction.
	TEST_F(SubprocRoutineTest, KillProcessDuringDestruction) {
	CreateRoutine();
	EXPECT_CALL(*mock_adapter(), StartProcess(_, _))
	.WillOnce(DoAll(SetArgPointee<1>(base::GetCurrentProcessHandle()),
	Return(true)));

	routine()->Start();

	// When we kill the routine, it should attempt to kill a running process.
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.WillOnce(Return(base::TERMINATION_STATUS_STILL_RUNNING));
	EXPECT_CALL(*mock_adapter(), KillProcess(_));

	DestroyRoutine();
	}

	// Test that we report the correct progress percent when we don't know the
	// routine's predicted duration.
	TEST_F(SubprocRoutineTest, NoPredictedDuration) {
	CreateRoutine(/predicted_duration_in_seconds=/0);
	RunRoutineWithTerminationStatus(base::TERMINATION_STATUS_STILL_RUNNING);
	EXPECT_EQ(update()->progress_percent,
	kSubprocRoutineFakeProgressPercentUnknown);

	// Since we left a zombie process, expect the destructor to try and kill it.
	EXPECT_CALL(*mock_adapter(), GetStatus(_))
	.WillOnce(Return(base::TERMINATION_STATUS_NORMAL_TERMINATION));
	}

	// Test that calling resume doesn't crash.
	TEST_F(SubprocRoutineTest, Resume) {
	CreateRoutine();
	routine()->Resume();
	}

	// Test that we can create a SubprocRoutine with the production constructor.
	TEST(SubprocRoutineTestNoFixture, ProductionConstructor) {
	std::unique_ptr<SubprocRoutine> prod_routine =
	std::make_unique<SubprocRoutine>(base::CommandLine({"/dev/null"}),
	/predicted_duration_in_seconds=/0);
	mojo_ipc::RoutineUpdate update{0, mojo::ScopedHandle(),
	mojo_ipc::RoutineUpdateUnion::New()};
	prod_routine->PopulateStatusUpdate(&update, false);
	VerifyNonInteractiveUpdate(update.routine_update_union,
	mojo_ipc::DiagnosticRoutineStatusEnum::kReady,
	kSubprocRoutineReadyMessage);
	}

	} // namespace diagnostics