// 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 <cstdint>
#include <functional>
#include <map>
#include <string>
#include <utility>
#include <vector>

#include <base/files/file_path.h>
#include <base/files/file_util.h>
#include <base/files/scoped_temp_dir.h>
#include <base/logging.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "diagnostics/common/file_test_utils.h"
#include "diagnostics/cros_healthd/fetchers/cpu_fetcher.h"
#include "diagnostics/cros_healthd/system/fake_system_utilities.h"
#include "diagnostics/cros_healthd/system/mock_context.h"
#include "diagnostics/cros_healthd/system/system_utilities_constants.h"
#include "diagnostics/cros_healthd/utils/cpu_file_helpers.h"
#include "diagnostics/cros_healthd/utils/procfs_utils.h"
#include "mojo/cros_healthd_probe.mojom.h"

namespace diagnostics {

namespace {

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

using ::testing::UnorderedElementsAreArray;

// POD struct for ParseCpuArchitectureTest.
struct ParseCpuArchitectureTestParams {
  std::string uname_machine;
  mojo_ipc::CpuArchitectureEnum expected_mojo_enum;
};

// No other logical IDs should be used, or the logic for writing C-state files
// will break.
constexpr char kFirstLogicalId[] = "0";
constexpr char kSecondLogicalId[] = "1";
constexpr char kThirdLogicalId[] = "12";

// First C-State directory to be written.
constexpr char kFirstCStateDir[] = "state0";

constexpr char kNonIntegralFileContents[] = "Not an integer!";

constexpr char kHardwareDescriptionCpuinfoContents[] =
    "Hardware\t: Rockchip (Device Tree)\nRevision\t: 0000\nSerial\t: "
    "0000000000000000\n\n";
constexpr char kNoModelNameCpuinfoContents[] = "processor\t: 0\n\n";
constexpr char kNoPhysicalIdCpuinfoContents[] =
    "processor\t: 0\nmodel name\t: Dank CPU 1 @ 8.90GHz\n\n"
    "processor\t: 1\nmodel name\t: Dank CPU 1 @ 8.90GHzn\n\n"
    "processor\t: 12\nmodel name\t: Dank CPU 2 @ 2.80GHz\n\n";
constexpr char kFakeCpuinfoContents[] =
    "processor\t: 0\nmodel name\t: Dank CPU 1 @ 8.90GHz\nphysical id\t: 0\n\n"
    "processor\t: 1\nmodel name\t: Dank CPU 1 @ 8.90GHz\nphysical id\t: 0\n\n"
    "processor\t: 12\nmodel name\t: Dank CPU 2 @ 2.80GHz\nphysical id\t: 1\n\n";
constexpr char kFirstFakeModelName[] = "Dank CPU 1 @ 8.90GHz";
constexpr char kSecondFakeModelName[] = "Dank CPU 2 @ 2.80GHz";

constexpr uint32_t kFirstFakeMaxClockSpeed = 3400000;
constexpr uint32_t kSecondFakeMaxClockSpeed = 1600000;
constexpr uint32_t kThirdFakeMaxClockSpeed = 1800000;

constexpr char kBadPresentContents[] = "Char-7";
constexpr char kFakePresentContents[] = "0-7";
constexpr uint32_t kExpectedNumTotalThreads = 8;

constexpr uint32_t kFirstFakeScalingCurrentFrequency = 859429;
constexpr uint32_t kSecondFakeScalingCurrentFrequency = 637382;
constexpr uint32_t kThirdFakeScalingCurrentFrequency = 737382;

constexpr uint32_t kFirstFakeScalingMaxFrequency = 2800000;
constexpr uint32_t kSecondFakeScalingMaxFrequency = 1400000;
constexpr uint32_t kThirdFakeScalingMaxFrequency = 1700000;

constexpr char kFirstFakeCStateNameContents[] = "C1-SKL";
constexpr uint64_t kFirstFakeCStateTime = 536018855;
constexpr char kSecondFakeCStateNameContents[] = "C10-SKL";
constexpr uint64_t kSecondFakeCStateTime = 473634000891;
constexpr char kThirdFakeCStateNameContents[] = "C7s-SKL";
constexpr uint64_t kThirdFakeCStateTime = 473634000891;
constexpr char kFourthFakeCStateNameContents[] = "C1E-SKL";
constexpr uint64_t kFourthFakeCStateTime = 79901786;

constexpr char kBadStatContents[] =
    "cpu   12389 69724 98732420 420347203\ncpu0  0 10 890 473634000891\n";
constexpr char kMissingLogicalCpuStatContents[] =
    "cpu   12389 69724 98732420 420347203\n"
    "cpu0  69234 98 0 2349\n"
    "cpu12 0 64823 293802 871239\n";
constexpr char kFakeStatContents[] =
    "cpu   12389 69724 98732420 420347203\n"
    "cpu0  69234 98 0 2349\n"
    "cpu1  989 0 4536824 123\n"
    "cpu12 0 64823 293802 871239\n";
constexpr uint64_t kFirstFakeUserTime = 69234;
constexpr uint64_t kFirstFakeSystemTime = 0;
constexpr uint32_t kFirstFakeIdleTime = 2349;
constexpr uint64_t kSecondFakeUserTime = 989;
constexpr uint64_t kSecondFakeSystemTime = 4536824;
constexpr uint32_t kSecondFakeIdleTime = 123;
constexpr uint64_t kThirdFakeUserTime = 0;
constexpr uint64_t kThirdFakeSystemTime = 293802;
constexpr uint32_t kThirdFakeIdleTime = 871239;

constexpr char kFirstFakeCpuTemperatureDir[] = "sys/class/hwmon/hwmon1/device";
constexpr char kFirstFakeCpuTemperatureInputFile[] = "temp9_input";
constexpr char kFirstFakeCpuTemperatureLabelFile[] = "name";
constexpr int32_t kFirstFakeCpuTemperature = -186;
constexpr int32_t kFirstFakeCpuTemperatureMilliDegrees =
    kFirstFakeCpuTemperature * 1000;
constexpr char kFirstFakeCpuTemperatureLabel[] = "First Temperature Label";
constexpr char kSecondFakeCpuTemperatureDir[] = "sys/class/hwmon/hwmon2";
constexpr char kSecondFakeCpuTemperatureInputFile[] = "temp1_input";
constexpr char kSecondFakeCpuTemperatureLabelFile[] = "temp1_label";
constexpr int32_t kSecondFakeCpuTemperature = 99;
constexpr int32_t kSecondFakeCpuTemperatureMilliDegrees =
    kSecondFakeCpuTemperature * 1000;
constexpr char kSecondFakeCpuTemperatureLabel[] = "Second Temperature Label";

// Workaround matchers for UnorderedElementsAreArray not accepting
// move-only types.

// This matcher expects a std::cref(mojo_ipc::CStateInfoPtr) and
// checks each of the fields for equality.
MATCHER_P(MatchesCStateInfoPtr, ptr, "") {
  return arg->name == ptr.get()->name &&
         arg->time_in_state_since_last_boot_us ==
             ptr.get()->time_in_state_since_last_boot_us;
}

// This matcher expects a std::cref(mojo_ipc::CpuTemperatureChannelPtr) and
// checks each of the fields for equality.
MATCHER_P(MatchesCpuTemperatureChannelPtr, ptr, "") {
  return arg->label == ptr.get()->label &&
         arg->temperature_celsius == ptr.get()->temperature_celsius;
}

// Note that this function only works for Logical CPUs with one or two C-states.
// Luckily, that's all we need for solid unit tests.
void VerifyLogicalCpu(
    uint32_t expected_max_clock_speed_khz,
    uint32_t expected_scaling_max_frequency_khz,
    uint32_t expected_scaling_current_frequency_khz,
    uint32_t expected_user_time_user_hz,
    uint32_t expected_system_time_user_hz,
    uint32_t expected_idle_time_user_hz,
    const std::vector<std::pair<std::string, uint64_t>>& expected_c_states,
    const mojo_ipc::LogicalCpuInfoPtr& actual_data) {
  ASSERT_FALSE(actual_data.is_null());
  EXPECT_EQ(actual_data->max_clock_speed_khz, expected_max_clock_speed_khz);
  EXPECT_EQ(actual_data->scaling_max_frequency_khz,
            expected_scaling_max_frequency_khz);
  EXPECT_EQ(actual_data->scaling_current_frequency_khz,
            expected_scaling_current_frequency_khz);
  EXPECT_EQ(actual_data->user_time_user_hz, expected_user_time_user_hz);
  EXPECT_EQ(actual_data->system_time_user_hz, expected_system_time_user_hz);
  EXPECT_EQ(actual_data->idle_time_user_hz, expected_idle_time_user_hz);

  const auto& c_states = actual_data->c_states;
  int c_state_size = c_states.size();
  int expected_c_state_size = expected_c_states.size();
  ASSERT_TRUE(c_state_size == expected_c_state_size &&
              (c_state_size == 1 || c_state_size == 2));
  if (c_state_size == 1) {
    const auto& c_state = c_states[0];
    ASSERT_FALSE(c_state.is_null());
    const auto& expected_c_state = expected_c_states[0];
    EXPECT_EQ(c_state->name, expected_c_state.first);
    EXPECT_EQ(c_state->time_in_state_since_last_boot_us,
              expected_c_state.second);
  } else {
    // Since fetching C-states uses base::FileEnumerator, we're not guaranteed
    // the order of the two results.
    auto first_expected_c_state = mojo_ipc::CpuCStateInfo::New(
        expected_c_states[0].first, expected_c_states[0].second);
    auto second_expected_c_state = mojo_ipc::CpuCStateInfo::New(
        expected_c_states[1].first, expected_c_states[1].second);
    EXPECT_THAT(
        c_states,
        UnorderedElementsAreArray(
            {MatchesCStateInfoPtr(std::cref(first_expected_c_state)),
             MatchesCStateInfoPtr(std::cref(second_expected_c_state))}));
  }
}

// Verifies that the two received CPU temperature channels have the correct
// values.
void VerifyCpuTemps(
    const std::vector<mojo_ipc::CpuTemperatureChannelPtr>& cpu_temps) {
  ASSERT_EQ(cpu_temps.size(), 2);

  // Since fetching temperatures uses base::FileEnumerator, we're not
  // guaranteed the order of the two results.
  auto first_expected_temp = mojo_ipc::CpuTemperatureChannel::New(
      kFirstFakeCpuTemperatureLabel, kFirstFakeCpuTemperature);
  auto second_expected_temp = mojo_ipc::CpuTemperatureChannel::New(
      kSecondFakeCpuTemperatureLabel, kSecondFakeCpuTemperature);
  EXPECT_THAT(
      cpu_temps,
      UnorderedElementsAreArray(
          {MatchesCpuTemperatureChannelPtr(std::cref(first_expected_temp)),
           MatchesCpuTemperatureChannelPtr(std::cref(second_expected_temp))}));
}

}  // namespace

class CpuFetcherTest : public testing::Test {
 protected:
  CpuFetcherTest() = default;

  void SetUp() override {
    ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());

    ASSERT_TRUE(mock_context_.Initialize());

    // Set up valid files for two physical CPUs, the first of which has two
    // logical CPUs. Individual tests are expected to override this
    // configuration when necessary.

    // Write /proc/cpuinfo.
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        GetProcCpuInfoPath(temp_dir_path()), kFakeCpuinfoContents));
    // Write /proc/stat.
    ASSERT_TRUE(WriteFileAndCreateParentDirs(GetProcStatPath(temp_dir_path()),
                                             kFakeStatContents));
    // Write /sys/devices/system/cpu/present.
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        GetCpuDirectoryPath(temp_dir_path()).Append(kCpuPresentFile),
        kFakePresentContents));
    // Write policy data for the first logical CPU.
    WritePolicyData(std::to_string(kFirstFakeMaxClockSpeed),
                    std::to_string(kFirstFakeScalingMaxFrequency),
                    std::to_string(kFirstFakeScalingCurrentFrequency),
                    kFirstLogicalId);
    // Write policy data for the second logical CPU.
    WritePolicyData(std::to_string(kSecondFakeMaxClockSpeed),
                    std::to_string(kSecondFakeScalingMaxFrequency),
                    std::to_string(kSecondFakeScalingCurrentFrequency),
                    kSecondLogicalId);
    // Write policy data for the third logical CPU.
    WritePolicyData(std::to_string(kThirdFakeMaxClockSpeed),
                    std::to_string(kThirdFakeScalingMaxFrequency),
                    std::to_string(kThirdFakeScalingCurrentFrequency),
                    kThirdLogicalId);
    // Write C-state data for the first logical CPU.
    WriteCStateData(kFirstCStates, kFirstLogicalId);
    // Write C-state data for the second logical CPU.
    WriteCStateData(kSecondCStates, kSecondLogicalId);
    // Write C-state data for the third logical CPU.
    WriteCStateData(kThirdCStates, kThirdLogicalId);

    // Write CPU temperature data.
    base::FilePath first_temp_dir =
        temp_dir_path().AppendASCII(kFirstFakeCpuTemperatureDir);
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        first_temp_dir.AppendASCII(kFirstFakeCpuTemperatureInputFile),
        std::to_string(kFirstFakeCpuTemperatureMilliDegrees)));
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        first_temp_dir.AppendASCII(kFirstFakeCpuTemperatureLabelFile),
        kFirstFakeCpuTemperatureLabel));
    base::FilePath second_temp_dir =
        temp_dir_path().AppendASCII(kSecondFakeCpuTemperatureDir);
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        second_temp_dir.AppendASCII(kSecondFakeCpuTemperatureInputFile),
        std::to_string(kSecondFakeCpuTemperatureMilliDegrees)));
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        second_temp_dir.AppendASCII(kSecondFakeCpuTemperatureLabelFile),
        kSecondFakeCpuTemperatureLabel));

    // Set the fake uname response.
    fake_system_utils()->SetUnameResponse(/*ret_code=*/0, kUnameMachineX86_64);
  }

  const base::FilePath& temp_dir_path() const { return temp_dir_.GetPath(); }

  FakeSystemUtilities* fake_system_utils() const {
    return mock_context_.fake_system_utils();
  }

  mojo_ipc::CpuResultPtr FetchCpuInfo() {
    return cpu_fetcher_.FetchCpuInfo(temp_dir_path());
  }

  const std::vector<std::pair<std::string, uint64_t>>& GetCStateVector(
      const std::string& logical_id) {
    if (logical_id == kFirstLogicalId) {
      return kFirstCStates;
    } else if (logical_id == kSecondLogicalId) {
      return kSecondCStates;
    } else if (logical_id == kThirdLogicalId) {
      return kThirdCStates;
    }

    NOTREACHED();
    return kFirstCStates;
  }

  // Verifies that the received PhysicalCpuInfoPtrs matched the expected default
  // value.
  void VerifyPhysicalCpus(
      const std::vector<mojo_ipc::PhysicalCpuInfoPtr>& physical_cpus) {
    ASSERT_EQ(physical_cpus.size(), 2);
    const auto& first_physical_cpu = physical_cpus[0];
    ASSERT_FALSE(first_physical_cpu.is_null());
    EXPECT_EQ(first_physical_cpu->model_name, kFirstFakeModelName);
    const auto& first_logical_cpus = first_physical_cpu->logical_cpus;
    ASSERT_EQ(first_logical_cpus.size(), 2);
    VerifyLogicalCpu(kFirstFakeMaxClockSpeed, kFirstFakeScalingMaxFrequency,
                     kFirstFakeScalingCurrentFrequency, kFirstFakeUserTime,
                     kFirstFakeSystemTime, kFirstFakeIdleTime,
                     GetCStateVector(kFirstLogicalId), first_logical_cpus[0]);
    VerifyLogicalCpu(kSecondFakeMaxClockSpeed, kSecondFakeScalingMaxFrequency,
                     kSecondFakeScalingCurrentFrequency, kSecondFakeUserTime,
                     kSecondFakeSystemTime, kSecondFakeIdleTime,
                     GetCStateVector(kSecondLogicalId), first_logical_cpus[1]);
    const auto& second_physical_cpu = physical_cpus[1];
    ASSERT_FALSE(second_physical_cpu.is_null());
    EXPECT_EQ(second_physical_cpu->model_name, kSecondFakeModelName);
    const auto& second_logical_cpus = second_physical_cpu->logical_cpus;
    ASSERT_EQ(second_logical_cpus.size(), 1);
    VerifyLogicalCpu(kThirdFakeMaxClockSpeed, kThirdFakeScalingMaxFrequency,
                     kThirdFakeScalingCurrentFrequency, kThirdFakeUserTime,
                     kThirdFakeSystemTime, kThirdFakeIdleTime,
                     GetCStateVector(kThirdLogicalId), second_logical_cpus[0]);
  }

 private:
  // Writes pairs of data into the name and time files of the appropriate
  // C-state directory.
  void WriteCStateData(
      const std::vector<std::pair<std::string, uint64_t>>& data,
      const std::string& logical_id) {
    for (const auto& pair : data)
      WriteCStateFiles(logical_id, pair.first, std::to_string(pair.second));
  }

  // Writes to cpuinfo_max_freq, scaling_max_freq, and scaling_cur_freq. If any
  // of the optional values are base::nullopt, the corresponding file will not
  // be written.
  void WritePolicyData(const std::string cpuinfo_max_freq_contents,
                       const std::string scaling_max_freq_contents,
                       const std::string scaling_cur_freq_contents,
                       const std::string& logical_id) {
    WritePolicyFile(logical_id, kCpuinfoMaxFreqFile, cpuinfo_max_freq_contents);

    WritePolicyFile(logical_id, kCpuScalingMaxFreqFile,
                    scaling_max_freq_contents);

    WritePolicyFile(logical_id, kCpuScalingCurFreqFile,
                    scaling_cur_freq_contents);
  }

  // Helper to write individual C-state files.
  void WriteCStateFiles(const std::string& logical_id,
                        const std::string& name_contents,
                        const std::string& time_contents) {
    auto policy_dir = GetCStateDirectoryPath(temp_dir_path(), logical_id);
    int state_to_write = c_states_written[logical_id];
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        policy_dir.Append("state" + std::to_string(state_to_write))
            .Append(kCStateNameFile),
        name_contents));
    ASSERT_TRUE(WriteFileAndCreateParentDirs(
        policy_dir.Append("state" + std::to_string(state_to_write))
            .Append(kCStateTimeFile),
        time_contents));
    c_states_written[logical_id] += 1;
  }

  // Helper to write individual policy files.
  void WritePolicyFile(const std::string& logical_id,
                       const std::string& file_name,
                       const std::string& file_contents) {
    auto policy_dir = GetCpuFreqDirectoryPath(temp_dir_path(), logical_id);
    ASSERT_TRUE(WriteFileAndCreateParentDirs(policy_dir.Append(file_name),
                                             file_contents));
  }

  base::ScopedTempDir temp_dir_;
  MockContext mock_context_;
  CpuFetcher cpu_fetcher_{&mock_context_};
  // Records the next C-state file to be written.
  std::map<std::string, int> c_states_written = {
      {kFirstLogicalId, 0}, {kSecondLogicalId, 0}, {kThirdLogicalId, 0}};
  // C-state data for each of the three logical CPUs tested.
  const std::vector<std::pair<std::string, uint64_t>> kFirstCStates = {
      {kFirstFakeCStateNameContents, kFirstFakeCStateTime},
      {kSecondFakeCStateNameContents, kSecondFakeCStateTime}};
  const std::vector<std::pair<std::string, uint64_t>> kSecondCStates = {
      {kThirdFakeCStateNameContents, kThirdFakeCStateTime}};
  const std::vector<std::pair<std::string, uint64_t>> kThirdCStates = {
      {kFourthFakeCStateNameContents, kFourthFakeCStateTime}};
};

// Test that CPU info can be read when it exists.
TEST_F(CpuFetcherTest, TestFetchCpuInfo) {
  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  const auto& cpu_info = cpu_result->get_cpu_info();
  EXPECT_EQ(cpu_info->num_total_threads, kExpectedNumTotalThreads);
  EXPECT_EQ(cpu_info->architecture, mojo_ipc::CpuArchitectureEnum::kX86_64);
  VerifyPhysicalCpus(cpu_info->physical_cpus);
  VerifyCpuTemps(cpu_info->temperature_channels);
}

// Test that we handle a cpuinfo file for processors without physical_ids.
TEST_F(CpuFetcherTest, NoPhysicalIdCpuinfoFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(GetProcCpuInfoPath(temp_dir_path()),
                                           kNoPhysicalIdCpuinfoContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  const auto& cpu_info = cpu_result->get_cpu_info();
  EXPECT_EQ(cpu_info->num_total_threads, kExpectedNumTotalThreads);
  EXPECT_EQ(cpu_info->architecture, mojo_ipc::CpuArchitectureEnum::kX86_64);
  const auto& physical_cpus = cpu_info->physical_cpus;
  ASSERT_EQ(physical_cpus.size(), 3);
  const auto& first_physical_cpu = physical_cpus[0];
  ASSERT_FALSE(first_physical_cpu.is_null());
  EXPECT_EQ(first_physical_cpu->model_name, kFirstFakeModelName);
  const auto& first_logical_cpus = first_physical_cpu->logical_cpus;
  ASSERT_EQ(first_logical_cpus.size(), 1);
  VerifyLogicalCpu(kFirstFakeMaxClockSpeed, kFirstFakeScalingMaxFrequency,
                   kFirstFakeScalingCurrentFrequency, kFirstFakeUserTime,
                   kFirstFakeSystemTime, kFirstFakeIdleTime,
                   GetCStateVector(kFirstLogicalId), first_logical_cpus[0]);
  const auto& second_physical_cpu = physical_cpus[1];
  ASSERT_FALSE(second_physical_cpu.is_null());
  const auto& second_logical_cpu = second_physical_cpu->logical_cpus;
  ASSERT_EQ(second_logical_cpu.size(), 1);
  VerifyLogicalCpu(kSecondFakeMaxClockSpeed, kSecondFakeScalingMaxFrequency,
                   kSecondFakeScalingCurrentFrequency, kSecondFakeUserTime,
                   kSecondFakeSystemTime, kSecondFakeIdleTime,
                   GetCStateVector(kSecondLogicalId), second_logical_cpu[0]);
  const auto& third_physical_cpu = physical_cpus[2];
  ASSERT_FALSE(third_physical_cpu.is_null());
  const auto& third_logical_cpu = third_physical_cpu->logical_cpus;
  ASSERT_EQ(third_logical_cpu.size(), 1);
  VerifyLogicalCpu(kThirdFakeMaxClockSpeed, kThirdFakeScalingMaxFrequency,
                   kThirdFakeScalingCurrentFrequency, kThirdFakeUserTime,
                   kThirdFakeSystemTime, kThirdFakeIdleTime,
                   GetCStateVector(kThirdLogicalId), third_logical_cpu[0]);
  VerifyCpuTemps(cpu_info->temperature_channels);
}

// Test that we handle a missing cpuinfo file.
TEST_F(CpuFetcherTest, MissingCpuinfoFile) {
  ASSERT_TRUE(base::DeleteFile(GetProcCpuInfoPath(temp_dir_path())));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle a cpuinfo file with a hardware description block.
TEST_F(CpuFetcherTest, HardwareDescriptionCpuinfoFile) {
  std::string cpu_info_contents = kFakeCpuinfoContents;
  cpu_info_contents += kHardwareDescriptionCpuinfoContents;
  ASSERT_TRUE(WriteFileAndCreateParentDirs(GetProcCpuInfoPath(temp_dir_path()),
                                           cpu_info_contents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  const auto& cpu_info = cpu_result->get_cpu_info();
  EXPECT_EQ(cpu_info->num_total_threads, kExpectedNumTotalThreads);
  EXPECT_EQ(cpu_info->architecture, mojo_ipc::CpuArchitectureEnum::kX86_64);
  VerifyPhysicalCpus(cpu_info->physical_cpus);
  VerifyCpuTemps(cpu_info->temperature_channels);
}

// Test that we handle a cpuinfo file without a model name.
TEST_F(CpuFetcherTest, NoModelNameCpuinfoFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(GetProcCpuInfoPath(temp_dir_path()),
                                           kNoModelNameCpuinfoContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  ASSERT_EQ(cpu_result->get_cpu_info()->physical_cpus.size(), 1);
  EXPECT_FALSE(
      cpu_result->get_cpu_info()->physical_cpus[0]->model_name.has_value());
}

// Test that we handle a missing stat file.
TEST_F(CpuFetcherTest, MissingStatFile) {
  ASSERT_TRUE(base::DeleteFile(GetProcStatPath(temp_dir_path())));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle an incorrectly-formatted stat file.
TEST_F(CpuFetcherTest, IncorrectlyFormattedStatFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(GetProcStatPath(temp_dir_path()),
                                           kBadStatContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kParseError);
}

// Test that we handle a stat file which is missing an entry for an existing
// logical CPU.
TEST_F(CpuFetcherTest, StatFileMissingLogicalCpuEntry) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(GetProcStatPath(temp_dir_path()),
                                           kMissingLogicalCpuStatContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kParseError);
}

// Test that we handle a missing present file.
TEST_F(CpuFetcherTest, MissingPresentFile) {
  ASSERT_TRUE(base::DeleteFile(
      GetCpuDirectoryPath(temp_dir_path()).Append(kCpuPresentFile)));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle an incorrectly-formatted present file.
TEST_F(CpuFetcherTest, IncorrectlyFormattedPresentFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(
      GetCpuDirectoryPath(temp_dir_path()).Append(kCpuPresentFile),
      kBadPresentContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kParseError);
}

// Test that we handle a missing cpuinfo_max_freq file.
TEST_F(CpuFetcherTest, MissingCpuinfoMaxFreqFile) {
  ASSERT_TRUE(
      base::DeleteFile(GetCpuFreqDirectoryPath(temp_dir_path(), kFirstLogicalId)
                           .Append(kCpuinfoMaxFreqFile)));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle an incorrectly-formatted cpuinfo_max_freq file.
TEST_F(CpuFetcherTest, IncorrectlyFormattedCpuinfoMaxFreqFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(
      GetCpuFreqDirectoryPath(temp_dir_path(), kFirstLogicalId)
          .Append(kCpuinfoMaxFreqFile),
      kNonIntegralFileContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle a missing scaling_max_freq file.
TEST_F(CpuFetcherTest, MissingScalingMaxFreqFile) {
  ASSERT_TRUE(
      base::DeleteFile(GetCpuFreqDirectoryPath(temp_dir_path(), kFirstLogicalId)
                           .Append(kCpuScalingMaxFreqFile)));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle an incorrectly-formatted scaling_max_freq file.
TEST_F(CpuFetcherTest, IncorrectlyFormattedScalingMaxFreqFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(
      GetCpuFreqDirectoryPath(temp_dir_path(), kFirstLogicalId)
          .Append(kCpuScalingMaxFreqFile),
      kNonIntegralFileContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle a missing scaling_cur_freq file.
TEST_F(CpuFetcherTest, MissingScalingCurFreqFile) {
  ASSERT_TRUE(
      base::DeleteFile(GetCpuFreqDirectoryPath(temp_dir_path(), kFirstLogicalId)
                           .Append(kCpuScalingCurFreqFile)));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle an incorrectly-formatted scaling_cur_freq file.
TEST_F(CpuFetcherTest, IncorrectlyFormattedScalingCurFreqFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(
      GetCpuFreqDirectoryPath(temp_dir_path(), kFirstLogicalId)
          .Append(kCpuScalingCurFreqFile),
      kNonIntegralFileContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle a missing C-state name file.
TEST_F(CpuFetcherTest, MissingCStateNameFile) {
  ASSERT_TRUE(
      base::DeleteFile(GetCStateDirectoryPath(temp_dir_path(), kFirstLogicalId)
                           .Append(kFirstCStateDir)
                           .Append(kCStateNameFile)));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle a missing C-state time file.
TEST_F(CpuFetcherTest, MissingCStateTimeFile) {
  ASSERT_TRUE(
      base::DeleteFile(GetCStateDirectoryPath(temp_dir_path(), kFirstLogicalId)
                           .Append(kFirstCStateDir)
                           .Append(kCStateTimeFile)));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle an incorrectly-formatted C-state time file.
TEST_F(CpuFetcherTest, IncorrectlyFormattedCStateTimeFile) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(
      GetCStateDirectoryPath(temp_dir_path(), kFirstLogicalId)
          .Append(kFirstCStateDir)
          .Append(kCStateTimeFile),
      kNonIntegralFileContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_error());
  EXPECT_EQ(cpu_result->get_error()->type, mojo_ipc::ErrorType::kFileReadError);
}

// Test that we handle CPU temperatures without labels.
TEST_F(CpuFetcherTest, CpuTemperatureWithoutLabel) {
  ASSERT_TRUE(
      base::DeleteFile(temp_dir_path()
                           .AppendASCII(kFirstFakeCpuTemperatureDir)
                           .AppendASCII(kFirstFakeCpuTemperatureLabelFile)));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  const auto& cpu_info = cpu_result->get_cpu_info();
  EXPECT_EQ(cpu_info->num_total_threads, kExpectedNumTotalThreads);
  EXPECT_EQ(cpu_info->architecture, mojo_ipc::CpuArchitectureEnum::kX86_64);
  VerifyPhysicalCpus(cpu_info->physical_cpus);

  const auto& cpu_temps = cpu_info->temperature_channels;
  ASSERT_EQ(cpu_temps.size(), 2);

  // Since fetching temperatures uses base::FileEnumerator, we're not
  // guaranteed the order of the two results.
  auto first_expected_temp = mojo_ipc::CpuTemperatureChannel::New(
      base::nullopt, kFirstFakeCpuTemperature);
  auto second_expected_temp = mojo_ipc::CpuTemperatureChannel::New(
      kSecondFakeCpuTemperatureLabel, kSecondFakeCpuTemperature);
  EXPECT_THAT(
      cpu_temps,
      UnorderedElementsAreArray(
          {MatchesCpuTemperatureChannelPtr(std::cref(first_expected_temp)),
           MatchesCpuTemperatureChannelPtr(std::cref(second_expected_temp))}));
}

// Test that we handle incorrectly-formatted CPU temperature files.
TEST_F(CpuFetcherTest, IncorrectlyFormattedTemperature) {
  ASSERT_TRUE(WriteFileAndCreateParentDirs(
      temp_dir_path()
          .AppendASCII(kFirstFakeCpuTemperatureDir)
          .AppendASCII(kFirstFakeCpuTemperatureInputFile),
      kNonIntegralFileContents));

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  const auto& cpu_info = cpu_result->get_cpu_info();
  EXPECT_EQ(cpu_info->num_total_threads, kExpectedNumTotalThreads);
  EXPECT_EQ(cpu_info->architecture, mojo_ipc::CpuArchitectureEnum::kX86_64);
  VerifyPhysicalCpus(cpu_info->physical_cpus);

  // We shouldn't have data corresponding to the first fake temperature values,
  // because it was formatted incorrectly.
  const auto& cpu_temps = cpu_info->temperature_channels;
  ASSERT_EQ(cpu_temps.size(), 1);
  const auto& second_temp = cpu_temps[0];
  ASSERT_FALSE(second_temp.is_null());
  ASSERT_TRUE(second_temp->label.has_value());
  EXPECT_EQ(second_temp->label.value(), kSecondFakeCpuTemperatureLabel);
  EXPECT_EQ(second_temp->temperature_celsius, kSecondFakeCpuTemperature);
}

// Test that we handle uname failing.
TEST_F(CpuFetcherTest, UnameFailure) {
  fake_system_utils()->SetUnameResponse(-1, base::nullopt);

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  EXPECT_EQ(cpu_result->get_cpu_info()->architecture,
            mojo_ipc::CpuArchitectureEnum::kUnknown);
}

// Tests that CpuFetcher can correctly parse each known architecture.
//
// This is a parameterized test with the following parameters (accessed
// through the ParseCpuArchitectureTestParams POD struct):
// * |raw_state| - written to /proc/|kPid|/stat's process state field.
// * |expected_mojo_state| - expected value of the returned ProcessInfo's state
//                           field.
class ParseCpuArchitectureTest
    : public CpuFetcherTest,
      public testing::WithParamInterface<ParseCpuArchitectureTestParams> {
 protected:
  // Accessors to the test parameters returned by gtest's GetParam():
  ParseCpuArchitectureTestParams params() const { return GetParam(); }
};

// Test that we can parse the given uname response for CPU architecture.
TEST_P(ParseCpuArchitectureTest, ParseUnameResponse) {
  fake_system_utils()->SetUnameResponse(0, params().uname_machine);

  auto cpu_result = FetchCpuInfo();

  ASSERT_TRUE(cpu_result->is_cpu_info());
  EXPECT_EQ(cpu_result->get_cpu_info()->architecture,
            params().expected_mojo_enum);
}

INSTANTIATE_TEST_SUITE_P(
    ,
    ParseCpuArchitectureTest,
    testing::Values(
        ParseCpuArchitectureTestParams{kUnameMachineX86_64,
                                       mojo_ipc::CpuArchitectureEnum::kX86_64},
        ParseCpuArchitectureTestParams{kUnameMachineAArch64,
                                       mojo_ipc::CpuArchitectureEnum::kAArch64},
        ParseCpuArchitectureTestParams{kUnameMachineArmv7l,
                                       mojo_ipc::CpuArchitectureEnum::kArmv7l},
        ParseCpuArchitectureTestParams{
            "Unknown uname machine", mojo_ipc::CpuArchitectureEnum::kUnknown}));

}  // namespace diagnostics