diagnostics/wilco_dtc_supportd/telemetry/system_files_service_impl_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/wilco_dtc_supportd/telemetry/system_files_service_impl.h"

 #include <algorithm>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <tuple>

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

 #include "diagnostics/common/file_test_utils.h"
 #include "diagnostics/wilco_dtc_supportd/telemetry/system_files_service.h"

 using testing::AnyOf;
 using testing::StrEq;

 namespace {
 std::string FakeFileContents() {
   constexpr char kFakeFileContents[] = "test1 \0 Œ test2/test3 \0 Ö";

   return std::string(std::begin(kFakeFileContents),
                      std::end(kFakeFileContents));
 }
 }  // namespace

 namespace diagnostics {

 // Tests for SystemFilesService
 class SystemFilesServiceTest : public testing::Test {
  public:
   SystemFilesServiceTest() = default;
   SystemFilesServiceTest(const SystemFilesServiceTest&) = delete;
   SystemFilesServiceTest& operator=(const SystemFilesServiceTest&) = delete;

   ~SystemFilesServiceTest() override = default;

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

     system_files_service_.set_root_dir_for_testing(temp_dir_.GetPath());
   }

  protected:
   base::ScopedTempDir temp_dir_;
   SystemFilesServiceImpl system_files_service_;
 };

 // Test that GetFileDump() returns false when the file doesn't exist.
 TEST_F(SystemFilesServiceTest, NonExistingFile) {
   auto file_dump =
       system_files_service_.GetFileDump(SystemFilesService::File::kProcMeminfo);
   EXPECT_FALSE(file_dump);
 }

 // Test that GetFileDump() returns the requested file data when the file
 // exists.
 TEST_F(SystemFilesServiceTest, SimpleFile) {
   const base::FilePath kTestPath("proc/meminfo");

   base::FilePath abs_file = temp_dir_.GetPath().Append(kTestPath);

   ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file, FakeFileContents()));

   const auto file_dump =
       system_files_service_.GetFileDump(SystemFilesService::File::kProcMeminfo);

   EXPECT_TRUE(file_dump);
   EXPECT_EQ(file_dump.value().path, abs_file);
   EXPECT_EQ(file_dump.value().canonical_path, abs_file);
   EXPECT_EQ(file_dump.value().contents, FakeFileContents());
 }

 // Test that GetFileDump() returns the requested file data when the file
 // exists and is a symlink.
 TEST_F(SystemFilesServiceTest, Symlink) {
   const base::FilePath kTestPath("proc/meminfo");
   const base::FilePath kTestLinkPath("proc/loadavg");

   base::FilePath abs_file = temp_dir_.GetPath().Append(kTestPath);
   base::FilePath abs_link = temp_dir_.GetPath().Append(kTestLinkPath);

   ASSERT_TRUE(
       WriteFileAndCreateSymbolicLink(abs_file, FakeFileContents(), abs_link));

   const auto file_dump =
       system_files_service_.GetFileDump(SystemFilesService::File::kProcLoadavg);

   EXPECT_TRUE(file_dump);
   EXPECT_EQ(file_dump.value().path, abs_link);
   EXPECT_EQ(file_dump.value().canonical_path, abs_file);
   EXPECT_EQ(file_dump.value().contents, FakeFileContents());
 }

 // Test that GetVpdField() returns false when the VPD field doesn't exist.
 TEST_F(SystemFilesServiceTest, NoVpdField) {
   EXPECT_FALSE(system_files_service_.GetVpdField(
       SystemFilesService::VpdField::kSerialNumber));
 }

 // Test that GetVpdField() returns false when the VPD field contains non ASCII
 // symbols.
 TEST_F(SystemFilesServiceTest, NonASCIIVpdField) {
   constexpr char kNonASCIIContent[] = "test1 Œ test2 不 test3";

   base::FilePath abs_file =
       temp_dir_.GetPath().Append("run/wilco_dtc/vpd_fields/system_id");

   ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file, kNonASCIIContent));

   EXPECT_FALSE(system_files_service_.GetVpdField(
       SystemFilesService::VpdField::kSystemId));
 }

 // Test that GetVpdField() returns false when the VPD field is empty.
 TEST_F(SystemFilesServiceTest, EmptyVpdField) {
   base::FilePath abs_file =
       temp_dir_.GetPath().Append("run/wilco_dtc/vpd_fields/model_name");

   ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file, ""));

   EXPECT_FALSE(system_files_service_.GetVpdField(
       SystemFilesService::VpdField::kModelName));
 }

 // Test that GetVpdField() returns the requested trimmed VPD field when the VPD
 // field exists.
 TEST_F(SystemFilesServiceTest, TrimmedVpdField) {
   base::FilePath abs_file =
       temp_dir_.GetPath().Append("run/wilco_dtc/vpd_fields/ActivateDate");

   ASSERT_TRUE(
       WriteFileAndCreateParentDirs(abs_file, "\n \t 20 Apr 2020 \t\t \n\n"));

   auto vpd_field = system_files_service_.GetVpdField(
       SystemFilesService::VpdField::kActivateDate);

   EXPECT_TRUE(vpd_field);
   EXPECT_EQ(vpd_field.value(), "20 Apr 2020");
 }

 // Test that GetDirectoryDump() returns false when the directory doesn't
 // exist.
 TEST_F(SystemFilesServiceTest, NonExistingDirectory) {
   EXPECT_FALSE(system_files_service_.GetDirectoryDump(
       SystemFilesService::Directory::kSysFirmwareDmiTables));
 }

 // Test that GetDirectoryDump() returns a single file when called on a
 // directory containing a single file.
 TEST_F(SystemFilesServiceTest, SingleFileInDirectory) {
   const base::FilePath kDirPath("sys/firmware/dmi/tables/");
   const base::FilePath kFilePath("testf");

   base::FilePath abs_path =
       temp_dir_.GetPath().Append(kDirPath).Append(kFilePath);

   ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_path, FakeFileContents()));

   auto file_dumps = system_files_service_.GetDirectoryDump(
       SystemFilesService::Directory::kSysFirmwareDmiTables);

   ASSERT_TRUE(file_dumps);
   ASSERT_EQ(file_dumps.value().size(), 1);

   EXPECT_EQ(file_dumps.value()[0]->path, abs_path);
   EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_path);
   EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());
 }

 // Test that GetDirectoryDump returns correct file dumps for files in nested
 // directories.
 TEST_F(SystemFilesServiceTest, GetFileInNestedDirectory) {
   const base::FilePath kDirPath("sys/firmware/dmi/tables/");
   const base::FilePath kFilePath("a.testf");
   const base::FilePath kNestedPath("b.testn/testf");

   std::string nested_file_contents = FakeFileContents() + " nested";

   base::FilePath abs_file_path =
       temp_dir_.GetPath().Append(kDirPath).Append(kFilePath);
   base::FilePath abs_nested_path =
       temp_dir_.GetPath().Append(kDirPath).Append(kNestedPath);

   ASSERT_TRUE(
       WriteFileAndCreateParentDirs(abs_nested_path, nested_file_contents));
   ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file_path, FakeFileContents()));

   auto file_dumps = system_files_service_.GetDirectoryDump(
       SystemFilesService::Directory::kSysFirmwareDmiTables);

   ASSERT_TRUE(file_dumps);
   ASSERT_EQ(file_dumps.value().size(), 2);

   // We need to sort to ensure ordering for the next checks as file listing
   // is not deterministic
   std::sort(file_dumps.value().begin(), file_dumps.value().end(),
             [](const std::unique_ptr<SystemFilesService::FileDump>& a,
                const std::unique_ptr<SystemFilesService::FileDump>& b) {
               return a->path.value() < b->path.value();
             });

   EXPECT_EQ(file_dumps.value()[0]->path, abs_file_path);
   EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_file_path);
   EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());

   EXPECT_EQ(file_dumps.value()[1]->path, abs_nested_path);
   EXPECT_EQ(file_dumps.value()[1]->canonical_path, abs_nested_path);
   EXPECT_EQ(file_dumps.value()[1]->contents, nested_file_contents);
 }

 TEST_F(SystemFilesServiceTest, ShouldFollowSymlink) {
   const base::FilePath kLinkPath("sys/class/net/");
   const base::FilePath kFilePath("a.testf");

   base::ScopedTempDir other_dir;
   ASSERT_TRUE(other_dir.CreateUniqueTempDir());

   base::FilePath abs_file_path = other_dir.GetPath().Append(kFilePath);
   base::FilePath abs_link_path =
       temp_dir_.GetPath().Append(kLinkPath).Append(kFilePath);

   ASSERT_TRUE(WriteFileAndCreateSymbolicLink(abs_file_path, FakeFileContents(),
                                              abs_link_path));

   auto file_dumps = system_files_service_.GetDirectoryDump(
       SystemFilesService::Directory::kSysClassNetwork);

   ASSERT_TRUE(file_dumps);
   ASSERT_EQ(file_dumps.value().size(), 1);

   EXPECT_EQ(file_dumps.value()[0]->path, abs_link_path);
   EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_file_path);
   EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());
 }

 // Test that GetDirectoryDump() returns an empty result when given a directory
 // with only a cyclic symlink.
 TEST_F(SystemFilesServiceTest, CyclicSymLink) {
   const base::FilePath kDirPath("sys/class/net/");
   const base::FilePath kLinkPath =
       base::FilePath("sys/firmware/dmi/tables/link");

   base::FilePath abs_path =
       temp_dir_.GetPath().Append(kDirPath).Append(kLinkPath);

   ASSERT_TRUE(CreateCyclicSymbolicLink(abs_path));

   auto file_dumps = system_files_service_.GetDirectoryDump(
       SystemFilesService::Directory::kSysClassNetwork);

   ASSERT_TRUE(file_dumps);
   EXPECT_EQ(file_dumps.value().size(), 0);
 }

 // Test that GetDirectoryDump() returns a single result when given a directory
 // containing a file and a symlink to that same file.
 TEST_F(SystemFilesServiceTest, DuplicateSymLink) {
   const base::FilePath kDirPath("sys/class/net/");
   const base::FilePath kFilePath("testf");
   const base::FilePath kLinkPath("linkf");

   base::FilePath abs_file_path =
       temp_dir_.GetPath().Append(kDirPath).Append(kFilePath);
   base::FilePath abs_link_path =
       temp_dir_.GetPath().Append(kDirPath).Append(kLinkPath);

   ASSERT_TRUE(WriteFileAndCreateSymbolicLink(abs_file_path, FakeFileContents(),
                                              abs_link_path));

   auto file_dumps = system_files_service_.GetDirectoryDump(
       SystemFilesService::Directory::kSysClassNetwork);

   ASSERT_TRUE(file_dumps);
   ASSERT_EQ(file_dumps.value().size(), 1);

   // The non-canonical path could be either |abs_file_path| or
   // |abs_link_path|. Dumping a directory uses base::FileIterator,
   // whose order is not guaranteed.
   EXPECT_THAT(
       file_dumps.value()[0]->path.value(),
       AnyOf(StrEq(abs_file_path.value()), StrEq(abs_link_path.value())));
   EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_file_path);
   EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());
 }

 TEST_F(SystemFilesServiceTest, ShouldNotFollowSymlink) {
   const base::FilePath kLinkPath("sys/firmware/dmi/tables/");
   const base::FilePath kFilePath("a.testf");

   base::ScopedTempDir other_dir;
   ASSERT_TRUE(other_dir.CreateUniqueTempDir());

   base::FilePath abs_file_path = other_dir.GetPath().Append(kFilePath);
   base::FilePath abs_link_path =
       temp_dir_.GetPath().Append(kLinkPath).Append(kFilePath);

   ASSERT_TRUE(WriteFileAndCreateSymbolicLink(abs_file_path, FakeFileContents(),
                                              abs_link_path));

   auto file_dumps = system_files_service_.GetDirectoryDump(
       SystemFilesService::Directory::kSysFirmwareDmiTables);

   ASSERT_TRUE(file_dumps);
   EXPECT_EQ(file_dumps.value().size(), 0);
 }

 // Ensure Location mapping is valid
 class SystemFilesServiceFileLocationTest
     : public SystemFilesServiceTest,
       public testing::WithParamInterface<
           std::tuple<SystemFilesService::File, std::string>> {
  public:
   SystemFilesServiceFileLocationTest() = default;
   SystemFilesServiceFileLocationTest(
       const SystemFilesServiceFileLocationTest&) = delete;
   SystemFilesServiceFileLocationTest& operator=(
       const SystemFilesServiceFileLocationTest&) = delete;

   ~SystemFilesServiceFileLocationTest() override = default;

  protected:
   SystemFilesService::File GetLocationParam() const {
     return std::get<0>(GetParam());
   }

   const std::string& GetPathParam() const { return std::get<1>(GetParam()); }

   base::FilePath GetAbsoluteTestFilePath() const {
     return temp_dir_.GetPath().Append(GetPathParam());
   }
   const std::string& GetTestFileContents() const { return GetPathParam(); }
 };

 TEST_P(SystemFilesServiceFileLocationTest, Path) {
   EXPECT_EQ(system_files_service_.GetPathForFile(GetLocationParam()).value(),
             GetPathParam());
 }

 TEST_P(SystemFilesServiceFileLocationTest, Dump) {
   ASSERT_TRUE(WriteFileAndCreateParentDirs(GetAbsoluteTestFilePath(),
                                            GetTestFileContents()));

   const auto file_dump = system_files_service_.GetFileDump(GetLocationParam());

   EXPECT_TRUE(file_dump);
   EXPECT_EQ(file_dump.value().path, GetAbsoluteTestFilePath());
   EXPECT_EQ(file_dump.value().canonical_path, GetAbsoluteTestFilePath());
   EXPECT_EQ(file_dump.value().contents, GetTestFileContents());
 }

 INSTANTIATE_TEST_SUITE_P(
     ,
     SystemFilesServiceFileLocationTest,
     testing::Values(
         std::make_tuple(SystemFilesService::File::kProcUptime, "proc/uptime"),
         std::make_tuple(SystemFilesService::File::kProcMeminfo, "proc/meminfo"),
         std::make_tuple(SystemFilesService::File::kProcLoadavg, "proc/loadavg"),
         std::make_tuple(SystemFilesService::File::kProcStat, "proc/stat"),
         std::make_tuple(SystemFilesService::File::kProcNetNetstat,
                         "proc/net/netstat"),
         std::make_tuple(SystemFilesService::File::kProcNetDev, "proc/net/dev"),
         std::make_tuple(SystemFilesService::File::kProcDiskstats,
                         "proc/diskstats"),
         std::make_tuple(SystemFilesService::File::kProcCpuinfo, "proc/cpuinfo"),
         std::make_tuple(SystemFilesService::File::kProcVmstat, "proc/vmstat")));

 class SystemFilesServiceDirectoryLocationTest
     : public SystemFilesServiceTest,
       public testing::WithParamInterface<
           std::tuple<SystemFilesService::Directory, std::string>> {
  public:
   SystemFilesServiceDirectoryLocationTest() = default;
   SystemFilesServiceDirectoryLocationTest(
       const SystemFilesServiceDirectoryLocationTest&) = delete;
   SystemFilesServiceDirectoryLocationTest& operator=(
       const SystemFilesServiceDirectoryLocationTest&) = delete;

  protected:
   SystemFilesService::Directory GetLocationParam() const {
     return std::get<0>(GetParam());
   }

   const std::string& GetPathParam() const { return std::get<1>(GetParam()); }

   base::FilePath GetAbsoluteTestFilePath() const {
     return temp_dir_.GetPath().Append(GetPathParam()).Append("f");
   }
   const std::string& GetTestFileContents() const { return GetPathParam(); }
 };

 TEST_P(SystemFilesServiceDirectoryLocationTest, Path) {
   EXPECT_EQ(
       system_files_service_.GetPathForDirectory(GetLocationParam()).value(),
       GetPathParam());
 }

 TEST_P(SystemFilesServiceDirectoryLocationTest, Dump) {
   ASSERT_TRUE(WriteFileAndCreateParentDirs(GetAbsoluteTestFilePath(),
                                            GetTestFileContents()));

   auto file_dumps = system_files_service_.GetDirectoryDump(GetLocationParam());

   ASSERT_TRUE(file_dumps);
   ASSERT_EQ(file_dumps.value().size(), 1);

   EXPECT_EQ(file_dumps.value()[0]->path, GetAbsoluteTestFilePath());
   EXPECT_EQ(file_dumps.value()[0]->canonical_path, GetAbsoluteTestFilePath());
   EXPECT_EQ(file_dumps.value()[0]->contents, GetTestFileContents());
 }

 INSTANTIATE_TEST_SUITE_P(
     ,
     SystemFilesServiceDirectoryLocationTest,
     testing::Values(
         std::make_tuple(SystemFilesService::Directory::kProcAcpiButton,
                         "proc/acpi/button/"),
         std::make_tuple(SystemFilesService::Directory::kSysClassHwmon,
                         "sys/class/hwmon/"),
         std::make_tuple(SystemFilesService::Directory::kSysClassThermal,
                         "sys/class/thermal/"),
         std::make_tuple(SystemFilesService::Directory::kSysFirmwareDmiTables,
                         "sys/firmware/dmi/tables/"),
         std::make_tuple(SystemFilesService::Directory::kSysClassPowerSupply,
                         "sys/class/power_supply/"),
         std::make_tuple(SystemFilesService::Directory::kSysClassBacklight,
                         "sys/class/backlight/"),
         std::make_tuple(SystemFilesService::Directory::kSysClassNetwork,
                         "sys/class/net/"),
         std::make_tuple(SystemFilesService::Directory::kSysDevicesSystemCpu,
                         "sys/devices/system/cpu/")));

 class SystemFilesServiceVpdFieldTest
     : public SystemFilesServiceTest,
       public testing::WithParamInterface<
           std::tuple<SystemFilesService::VpdField, std::string>> {
  public:
   SystemFilesServiceVpdFieldTest() = default;
   ~SystemFilesServiceVpdFieldTest() override = default;

   SystemFilesServiceVpdFieldTest(const SystemFilesServiceVpdFieldTest&) =
       delete;
   SystemFilesServiceVpdFieldTest& operator=(
       const SystemFilesServiceVpdFieldTest&) = delete;

  protected:
   SystemFilesService::VpdField GetVpdFieldParam() const {
     return std::get<0>(GetParam());
   }

   const std::string& GetPathParam() const { return std::get<1>(GetParam()); }

   base::FilePath GetAbsoluteTestFilePath() const {
     return temp_dir_.GetPath().Append(GetPathParam());
   }
   const std::string& GetTestFileContents() const { return GetPathParam(); }
 };

 TEST_P(SystemFilesServiceVpdFieldTest, Path) {
   EXPECT_EQ(
       system_files_service_.GetPathForVpdField(GetVpdFieldParam()).value(),
       GetPathParam());
 }

 TEST_P(SystemFilesServiceVpdFieldTest, Dump) {
   ASSERT_TRUE(WriteFileAndCreateParentDirs(GetAbsoluteTestFilePath(),
                                            GetTestFileContents()));

   auto vpd_field = system_files_service_.GetVpdField(GetVpdFieldParam());

   EXPECT_TRUE(vpd_field);
   EXPECT_EQ(vpd_field.value(), GetTestFileContents());
 }

 INSTANTIATE_TEST_SUITE_P(
     ,
     SystemFilesServiceVpdFieldTest,
     testing::Values(std::make_tuple(SystemFilesService::VpdField::kActivateDate,
                                     "run/wilco_dtc/vpd_fields/ActivateDate"),
                     std::make_tuple(SystemFilesService::VpdField::kAssetId,
                                     "run/wilco_dtc/vpd_fields/asset_id"),
                     std::make_tuple(SystemFilesService::VpdField::kMfgDate,
                                     "run/wilco_dtc/vpd_fields/mfg_date"),
                     std::make_tuple(SystemFilesService::VpdField::kModelName,
                                     "run/wilco_dtc/vpd_fields/model_name"),
                     std::make_tuple(SystemFilesService::VpdField::kSerialNumber,
                                     "run/wilco_dtc/vpd_fields/serial_number"),
                     std::make_tuple(SystemFilesService::VpdField::kSkuNumber,
                                     "run/wilco_dtc/vpd_fields/sku_number"),
                     std::make_tuple(SystemFilesService::VpdField::kSystemId,
                                     "run/wilco_dtc/vpd_fields/system_id"),
                     std::make_tuple(SystemFilesService::VpdField::kUuid,
                                     "run/wilco_dtc/vpd_fields/uuid_id")));

 }  // 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/wilco_dtc_supportd/telemetry/system_files_service_impl.h"

	#include <algorithm>
	#include <iterator>
	#include <memory>
	#include <string>
	#include <tuple>

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

	#include "diagnostics/common/file_test_utils.h"
	#include "diagnostics/wilco_dtc_supportd/telemetry/system_files_service.h"

	using testing::AnyOf;
	using testing::StrEq;

	namespace {
	std::string FakeFileContents() {
	constexpr char kFakeFileContents[] = "test1 \0 Œ test2/test3 \0 Ö";

	return std::string(std::begin(kFakeFileContents),
	std::end(kFakeFileContents));
	}
	} // namespace

	namespace diagnostics {

	// Tests for SystemFilesService
	class SystemFilesServiceTest : public testing::Test {
	public:
	SystemFilesServiceTest() = default;
	SystemFilesServiceTest(const SystemFilesServiceTest&) = delete;
	SystemFilesServiceTest& operator=(const SystemFilesServiceTest&) = delete;

	~SystemFilesServiceTest() override = default;

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

	system_files_service_.set_root_dir_for_testing(temp_dir_.GetPath());
	}

	protected:
	base::ScopedTempDir temp_dir_;
	SystemFilesServiceImpl system_files_service_;
	};

	// Test that GetFileDump() returns false when the file doesn't exist.
	TEST_F(SystemFilesServiceTest, NonExistingFile) {
	auto file_dump =
	system_files_service_.GetFileDump(SystemFilesService::File::kProcMeminfo);
	EXPECT_FALSE(file_dump);
	}

	// Test that GetFileDump() returns the requested file data when the file
	// exists.
	TEST_F(SystemFilesServiceTest, SimpleFile) {
	const base::FilePath kTestPath("proc/meminfo");

	base::FilePath abs_file = temp_dir_.GetPath().Append(kTestPath);

	ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file, FakeFileContents()));

	const auto file_dump =
	system_files_service_.GetFileDump(SystemFilesService::File::kProcMeminfo);

	EXPECT_TRUE(file_dump);
	EXPECT_EQ(file_dump.value().path, abs_file);
	EXPECT_EQ(file_dump.value().canonical_path, abs_file);
	EXPECT_EQ(file_dump.value().contents, FakeFileContents());
	}

	// Test that GetFileDump() returns the requested file data when the file
	// exists and is a symlink.
	TEST_F(SystemFilesServiceTest, Symlink) {
	const base::FilePath kTestPath("proc/meminfo");
	const base::FilePath kTestLinkPath("proc/loadavg");

	base::FilePath abs_file = temp_dir_.GetPath().Append(kTestPath);
	base::FilePath abs_link = temp_dir_.GetPath().Append(kTestLinkPath);

	ASSERT_TRUE(
	WriteFileAndCreateSymbolicLink(abs_file, FakeFileContents(), abs_link));

	const auto file_dump =
	system_files_service_.GetFileDump(SystemFilesService::File::kProcLoadavg);

	EXPECT_TRUE(file_dump);
	EXPECT_EQ(file_dump.value().path, abs_link);
	EXPECT_EQ(file_dump.value().canonical_path, abs_file);
	EXPECT_EQ(file_dump.value().contents, FakeFileContents());
	}

	// Test that GetVpdField() returns false when the VPD field doesn't exist.
	TEST_F(SystemFilesServiceTest, NoVpdField) {
	EXPECT_FALSE(system_files_service_.GetVpdField(
	SystemFilesService::VpdField::kSerialNumber));
	}

	// Test that GetVpdField() returns false when the VPD field contains non ASCII
	// symbols.
	TEST_F(SystemFilesServiceTest, NonASCIIVpdField) {
	constexpr char kNonASCIIContent[] = "test1 Œ test2 不 test3";

	base::FilePath abs_file =
	temp_dir_.GetPath().Append("run/wilco_dtc/vpd_fields/system_id");

	ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file, kNonASCIIContent));

	EXPECT_FALSE(system_files_service_.GetVpdField(
	SystemFilesService::VpdField::kSystemId));
	}

	// Test that GetVpdField() returns false when the VPD field is empty.
	TEST_F(SystemFilesServiceTest, EmptyVpdField) {
	base::FilePath abs_file =
	temp_dir_.GetPath().Append("run/wilco_dtc/vpd_fields/model_name");

	ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file, ""));

	EXPECT_FALSE(system_files_service_.GetVpdField(
	SystemFilesService::VpdField::kModelName));
	}

	// Test that GetVpdField() returns the requested trimmed VPD field when the VPD
	// field exists.
	TEST_F(SystemFilesServiceTest, TrimmedVpdField) {
	base::FilePath abs_file =
	temp_dir_.GetPath().Append("run/wilco_dtc/vpd_fields/ActivateDate");

	ASSERT_TRUE(
	WriteFileAndCreateParentDirs(abs_file, "\n \t 20 Apr 2020 \t\t \n\n"));

	auto vpd_field = system_files_service_.GetVpdField(
	SystemFilesService::VpdField::kActivateDate);

	EXPECT_TRUE(vpd_field);
	EXPECT_EQ(vpd_field.value(), "20 Apr 2020");
	}

	// Test that GetDirectoryDump() returns false when the directory doesn't
	// exist.
	TEST_F(SystemFilesServiceTest, NonExistingDirectory) {
	EXPECT_FALSE(system_files_service_.GetDirectoryDump(
	SystemFilesService::Directory::kSysFirmwareDmiTables));
	}

	// Test that GetDirectoryDump() returns a single file when called on a
	// directory containing a single file.
	TEST_F(SystemFilesServiceTest, SingleFileInDirectory) {
	const base::FilePath kDirPath("sys/firmware/dmi/tables/");
	const base::FilePath kFilePath("testf");

	base::FilePath abs_path =
	temp_dir_.GetPath().Append(kDirPath).Append(kFilePath);

	ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_path, FakeFileContents()));

	auto file_dumps = system_files_service_.GetDirectoryDump(
	SystemFilesService::Directory::kSysFirmwareDmiTables);

	ASSERT_TRUE(file_dumps);
	ASSERT_EQ(file_dumps.value().size(), 1);

	EXPECT_EQ(file_dumps.value()[0]->path, abs_path);
	EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_path);
	EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());
	}

	// Test that GetDirectoryDump returns correct file dumps for files in nested
	// directories.
	TEST_F(SystemFilesServiceTest, GetFileInNestedDirectory) {
	const base::FilePath kDirPath("sys/firmware/dmi/tables/");
	const base::FilePath kFilePath("a.testf");
	const base::FilePath kNestedPath("b.testn/testf");

	std::string nested_file_contents = FakeFileContents() + " nested";

	base::FilePath abs_file_path =
	temp_dir_.GetPath().Append(kDirPath).Append(kFilePath);
	base::FilePath abs_nested_path =
	temp_dir_.GetPath().Append(kDirPath).Append(kNestedPath);

	ASSERT_TRUE(
	WriteFileAndCreateParentDirs(abs_nested_path, nested_file_contents));
	ASSERT_TRUE(WriteFileAndCreateParentDirs(abs_file_path, FakeFileContents()));

	auto file_dumps = system_files_service_.GetDirectoryDump(
	SystemFilesService::Directory::kSysFirmwareDmiTables);

	ASSERT_TRUE(file_dumps);
	ASSERT_EQ(file_dumps.value().size(), 2);

	// We need to sort to ensure ordering for the next checks as file listing
	// is not deterministic
	std::sort(file_dumps.value().begin(), file_dumps.value().end(),
	[](const std::unique_ptr<SystemFilesService::FileDump>& a,
	const std::unique_ptr<SystemFilesService::FileDump>& b) {
	return a->path.value() < b->path.value();
	});

	EXPECT_EQ(file_dumps.value()[0]->path, abs_file_path);
	EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_file_path);
	EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());

	EXPECT_EQ(file_dumps.value()[1]->path, abs_nested_path);
	EXPECT_EQ(file_dumps.value()[1]->canonical_path, abs_nested_path);
	EXPECT_EQ(file_dumps.value()[1]->contents, nested_file_contents);
	}

	TEST_F(SystemFilesServiceTest, ShouldFollowSymlink) {
	const base::FilePath kLinkPath("sys/class/net/");
	const base::FilePath kFilePath("a.testf");

	base::ScopedTempDir other_dir;
	ASSERT_TRUE(other_dir.CreateUniqueTempDir());

	base::FilePath abs_file_path = other_dir.GetPath().Append(kFilePath);
	base::FilePath abs_link_path =
	temp_dir_.GetPath().Append(kLinkPath).Append(kFilePath);

	ASSERT_TRUE(WriteFileAndCreateSymbolicLink(abs_file_path, FakeFileContents(),
	abs_link_path));

	auto file_dumps = system_files_service_.GetDirectoryDump(
	SystemFilesService::Directory::kSysClassNetwork);

	ASSERT_TRUE(file_dumps);
	ASSERT_EQ(file_dumps.value().size(), 1);

	EXPECT_EQ(file_dumps.value()[0]->path, abs_link_path);
	EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_file_path);
	EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());
	}

	// Test that GetDirectoryDump() returns an empty result when given a directory
	// with only a cyclic symlink.
	TEST_F(SystemFilesServiceTest, CyclicSymLink) {
	const base::FilePath kDirPath("sys/class/net/");
	const base::FilePath kLinkPath =
	base::FilePath("sys/firmware/dmi/tables/link");

	base::FilePath abs_path =
	temp_dir_.GetPath().Append(kDirPath).Append(kLinkPath);

	ASSERT_TRUE(CreateCyclicSymbolicLink(abs_path));

	auto file_dumps = system_files_service_.GetDirectoryDump(
	SystemFilesService::Directory::kSysClassNetwork);

	ASSERT_TRUE(file_dumps);
	EXPECT_EQ(file_dumps.value().size(), 0);
	}

	// Test that GetDirectoryDump() returns a single result when given a directory
	// containing a file and a symlink to that same file.
	TEST_F(SystemFilesServiceTest, DuplicateSymLink) {
	const base::FilePath kDirPath("sys/class/net/");
	const base::FilePath kFilePath("testf");
	const base::FilePath kLinkPath("linkf");

	base::FilePath abs_file_path =
	temp_dir_.GetPath().Append(kDirPath).Append(kFilePath);
	base::FilePath abs_link_path =
	temp_dir_.GetPath().Append(kDirPath).Append(kLinkPath);

	ASSERT_TRUE(WriteFileAndCreateSymbolicLink(abs_file_path, FakeFileContents(),
	abs_link_path));

	auto file_dumps = system_files_service_.GetDirectoryDump(
	SystemFilesService::Directory::kSysClassNetwork);

	ASSERT_TRUE(file_dumps);
	ASSERT_EQ(file_dumps.value().size(), 1);

	// The non-canonical path could be either \|abs_file_path\| or
	// \|abs_link_path\|. Dumping a directory uses base::FileIterator,
	// whose order is not guaranteed.
	EXPECT_THAT(
	file_dumps.value()[0]->path.value(),
	AnyOf(StrEq(abs_file_path.value()), StrEq(abs_link_path.value())));
	EXPECT_EQ(file_dumps.value()[0]->canonical_path, abs_file_path);
	EXPECT_EQ(file_dumps.value()[0]->contents, FakeFileContents());
	}

	TEST_F(SystemFilesServiceTest, ShouldNotFollowSymlink) {
	const base::FilePath kLinkPath("sys/firmware/dmi/tables/");
	const base::FilePath kFilePath("a.testf");

	base::ScopedTempDir other_dir;
	ASSERT_TRUE(other_dir.CreateUniqueTempDir());

	base::FilePath abs_file_path = other_dir.GetPath().Append(kFilePath);
	base::FilePath abs_link_path =
	temp_dir_.GetPath().Append(kLinkPath).Append(kFilePath);

	ASSERT_TRUE(WriteFileAndCreateSymbolicLink(abs_file_path, FakeFileContents(),
	abs_link_path));

	auto file_dumps = system_files_service_.GetDirectoryDump(
	SystemFilesService::Directory::kSysFirmwareDmiTables);

	ASSERT_TRUE(file_dumps);
	EXPECT_EQ(file_dumps.value().size(), 0);
	}

	// Ensure Location mapping is valid
	class SystemFilesServiceFileLocationTest
	: public SystemFilesServiceTest,
	public testing::WithParamInterface<
	std::tuple<SystemFilesService::File, std::string>> {
	public:
	SystemFilesServiceFileLocationTest() = default;
	SystemFilesServiceFileLocationTest(
	const SystemFilesServiceFileLocationTest&) = delete;
	SystemFilesServiceFileLocationTest& operator=(
	const SystemFilesServiceFileLocationTest&) = delete;

	~SystemFilesServiceFileLocationTest() override = default;

	protected:
	SystemFilesService::File GetLocationParam() const {
	return std::get<0>(GetParam());
	}

	const std::string& GetPathParam() const { return std::get<1>(GetParam()); }

	base::FilePath GetAbsoluteTestFilePath() const {
	return temp_dir_.GetPath().Append(GetPathParam());
	}
	const std::string& GetTestFileContents() const { return GetPathParam(); }
	};

	TEST_P(SystemFilesServiceFileLocationTest, Path) {
	EXPECT_EQ(system_files_service_.GetPathForFile(GetLocationParam()).value(),
	GetPathParam());
	}

	TEST_P(SystemFilesServiceFileLocationTest, Dump) {
	ASSERT_TRUE(WriteFileAndCreateParentDirs(GetAbsoluteTestFilePath(),
	GetTestFileContents()));

	const auto file_dump = system_files_service_.GetFileDump(GetLocationParam());

	EXPECT_TRUE(file_dump);
	EXPECT_EQ(file_dump.value().path, GetAbsoluteTestFilePath());
	EXPECT_EQ(file_dump.value().canonical_path, GetAbsoluteTestFilePath());
	EXPECT_EQ(file_dump.value().contents, GetTestFileContents());
	}

	INSTANTIATE_TEST_SUITE_P(
	,
	SystemFilesServiceFileLocationTest,
	testing::Values(
	std::make_tuple(SystemFilesService::File::kProcUptime, "proc/uptime"),
	std::make_tuple(SystemFilesService::File::kProcMeminfo, "proc/meminfo"),
	std::make_tuple(SystemFilesService::File::kProcLoadavg, "proc/loadavg"),
	std::make_tuple(SystemFilesService::File::kProcStat, "proc/stat"),
	std::make_tuple(SystemFilesService::File::kProcNetNetstat,
	"proc/net/netstat"),
	std::make_tuple(SystemFilesService::File::kProcNetDev, "proc/net/dev"),
	std::make_tuple(SystemFilesService::File::kProcDiskstats,
	"proc/diskstats"),
	std::make_tuple(SystemFilesService::File::kProcCpuinfo, "proc/cpuinfo"),
	std::make_tuple(SystemFilesService::File::kProcVmstat, "proc/vmstat")));

	class SystemFilesServiceDirectoryLocationTest
	: public SystemFilesServiceTest,
	public testing::WithParamInterface<
	std::tuple<SystemFilesService::Directory, std::string>> {
	public:
	SystemFilesServiceDirectoryLocationTest() = default;
	SystemFilesServiceDirectoryLocationTest(
	const SystemFilesServiceDirectoryLocationTest&) = delete;
	SystemFilesServiceDirectoryLocationTest& operator=(
	const SystemFilesServiceDirectoryLocationTest&) = delete;

	protected:
	SystemFilesService::Directory GetLocationParam() const {
	return std::get<0>(GetParam());
	}

	const std::string& GetPathParam() const { return std::get<1>(GetParam()); }

	base::FilePath GetAbsoluteTestFilePath() const {
	return temp_dir_.GetPath().Append(GetPathParam()).Append("f");
	}
	const std::string& GetTestFileContents() const { return GetPathParam(); }
	};

	TEST_P(SystemFilesServiceDirectoryLocationTest, Path) {
	EXPECT_EQ(
	system_files_service_.GetPathForDirectory(GetLocationParam()).value(),
	GetPathParam());
	}

	TEST_P(SystemFilesServiceDirectoryLocationTest, Dump) {
	ASSERT_TRUE(WriteFileAndCreateParentDirs(GetAbsoluteTestFilePath(),
	GetTestFileContents()));

	auto file_dumps = system_files_service_.GetDirectoryDump(GetLocationParam());

	ASSERT_TRUE(file_dumps);
	ASSERT_EQ(file_dumps.value().size(), 1);

	EXPECT_EQ(file_dumps.value()[0]->path, GetAbsoluteTestFilePath());
	EXPECT_EQ(file_dumps.value()[0]->canonical_path, GetAbsoluteTestFilePath());
	EXPECT_EQ(file_dumps.value()[0]->contents, GetTestFileContents());
	}

	INSTANTIATE_TEST_SUITE_P(
	,
	SystemFilesServiceDirectoryLocationTest,
	testing::Values(
	std::make_tuple(SystemFilesService::Directory::kProcAcpiButton,
	"proc/acpi/button/"),
	std::make_tuple(SystemFilesService::Directory::kSysClassHwmon,
	"sys/class/hwmon/"),
	std::make_tuple(SystemFilesService::Directory::kSysClassThermal,
	"sys/class/thermal/"),
	std::make_tuple(SystemFilesService::Directory::kSysFirmwareDmiTables,
	"sys/firmware/dmi/tables/"),
	std::make_tuple(SystemFilesService::Directory::kSysClassPowerSupply,
	"sys/class/power_supply/"),
	std::make_tuple(SystemFilesService::Directory::kSysClassBacklight,
	"sys/class/backlight/"),
	std::make_tuple(SystemFilesService::Directory::kSysClassNetwork,
	"sys/class/net/"),
	std::make_tuple(SystemFilesService::Directory::kSysDevicesSystemCpu,
	"sys/devices/system/cpu/")));

	class SystemFilesServiceVpdFieldTest
	: public SystemFilesServiceTest,
	public testing::WithParamInterface<
	std::tuple<SystemFilesService::VpdField, std::string>> {
	public:
	SystemFilesServiceVpdFieldTest() = default;
	~SystemFilesServiceVpdFieldTest() override = default;

	SystemFilesServiceVpdFieldTest(const SystemFilesServiceVpdFieldTest&) =
	delete;
	SystemFilesServiceVpdFieldTest& operator=(
	const SystemFilesServiceVpdFieldTest&) = delete;

	protected:
	SystemFilesService::VpdField GetVpdFieldParam() const {
	return std::get<0>(GetParam());
	}

	const std::string& GetPathParam() const { return std::get<1>(GetParam()); }

	base::FilePath GetAbsoluteTestFilePath() const {
	return temp_dir_.GetPath().Append(GetPathParam());
	}
	const std::string& GetTestFileContents() const { return GetPathParam(); }
	};

	TEST_P(SystemFilesServiceVpdFieldTest, Path) {
	EXPECT_EQ(
	system_files_service_.GetPathForVpdField(GetVpdFieldParam()).value(),
	GetPathParam());
	}

	TEST_P(SystemFilesServiceVpdFieldTest, Dump) {
	ASSERT_TRUE(WriteFileAndCreateParentDirs(GetAbsoluteTestFilePath(),
	GetTestFileContents()));

	auto vpd_field = system_files_service_.GetVpdField(GetVpdFieldParam());

	EXPECT_TRUE(vpd_field);
	EXPECT_EQ(vpd_field.value(), GetTestFileContents());
	}

	INSTANTIATE_TEST_SUITE_P(
	,
	SystemFilesServiceVpdFieldTest,
	testing::Values(std::make_tuple(SystemFilesService::VpdField::kActivateDate,
	"run/wilco_dtc/vpd_fields/ActivateDate"),
	std::make_tuple(SystemFilesService::VpdField::kAssetId,
	"run/wilco_dtc/vpd_fields/asset_id"),
	std::make_tuple(SystemFilesService::VpdField::kMfgDate,
	"run/wilco_dtc/vpd_fields/mfg_date"),
	std::make_tuple(SystemFilesService::VpdField::kModelName,
	"run/wilco_dtc/vpd_fields/model_name"),
	std::make_tuple(SystemFilesService::VpdField::kSerialNumber,
	"run/wilco_dtc/vpd_fields/serial_number"),
	std::make_tuple(SystemFilesService::VpdField::kSkuNumber,
	"run/wilco_dtc/vpd_fields/sku_number"),
	std::make_tuple(SystemFilesService::VpdField::kSystemId,
	"run/wilco_dtc/vpd_fields/system_id"),
	std::make_tuple(SystemFilesService::VpdField::kUuid,
	"run/wilco_dtc/vpd_fields/uuid_id")));

	} // namespace diagnostics