diagnostics/telem/telem_connection_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2018 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 <utility>

 #include <base/message_loop/message_loop.h>
 #include <base/time/time.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include "diagnostics/telem/async_grpc_client_adapter.h"
 #include "diagnostics/telem/telem_connection.h"
 #include "diagnostics/telem/telemetry_item_enum.h"

 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::StrictMock;
 using ::testing::WithArg;

 namespace diagnostics {

 namespace {

 using ProcDataCallback = base::Callback<void(
     std::unique_ptr<grpc_api::GetProcDataResponse> response)>;
 using SysfsDataCallback = base::Callback<void(
     std::unique_ptr<grpc_api::GetSysfsDataResponse> response)>;

 constexpr char kFakeMeminfoFileContents[] =
     "MemTotal:      3906320 kB\nMemFree:      873180 kB\n";
 constexpr char kFakeBadMeminfoFileContents[] =
     "MemTotal:      3906320\nMemfree:      873180 kB\n";
 constexpr int kFakeMemTotalMebibytes = 3814;
 constexpr int kFakeMemFreeMebibytes = 852;
 constexpr char kFakeLoadavgFileContents[] = "0.82 0.61 0.52 2/370 30707\n";
 constexpr char kFakeBadLoadavgFileContents[] = "0.82 0.61 0.52 2 370 30707\n";
 constexpr int kFakeNumRunnableEntities = 2;
 constexpr int kFakeNumExistingEntities = 370;
 constexpr char kFakeStatFileContents[] =
     "cpu  0 0 0 165432156432413546\ncpu0 0 0 0 653435243543\ncpu1 0 0 0 "
     "235435413\nctxt 5345634354";
 constexpr char kFakeBadStatFileContents[] =
     "cpu  0 0 165432156432413546\npu0 0 0 0 653435243543\ncpu1 0 0 0 "
     "235435413\nctxt 5345634354";
 constexpr char kFakeTotalCPUIdleTime[] = "165432156432413546";
 char const* kFakePerCPUIdleTimes[] = {"653435243543", "235435413"};

 class MockAsyncGrpcClientAdapter : public AsyncGrpcClientAdapter {
  public:
   void Connect(const std::string& target_uri) override {}

   MOCK_CONST_METHOD0(IsConnected, bool());
   MOCK_METHOD1(Shutdown, void(const base::Closure& on_shutdown));
   MOCK_METHOD2(GetProcData,
                void(const grpc_api::GetProcDataRequest& request,
                     ProcDataCallback callback));
   MOCK_METHOD2(GetSysfsData,
                void(const grpc_api::GetSysfsDataRequest& request,
                     SysfsDataCallback callback));
 };

 }  // namespace

 class TelemConnectionTest : public ::testing::Test {
  protected:
   TelemConnectionTest() {
     EXPECT_CALL(mock_adapter_, Shutdown(_))
         .WillOnce(Invoke(
             [](const base::Closure& on_shutdown) { on_shutdown.Run(); }));
   }

   void SetConnection(std::unique_ptr<TelemConnection> connection) {
     connection_ = std::move(connection);
   }

   // Sets the MockAsyncGrpcClientAdapter to run the next callback with
   // a null pointer as its response.
   void SetNullptrProcDataResponse() {
     EXPECT_CALL(mock_adapter_, GetProcData(_, _))
         .WillOnce(WithArg<1>(
             Invoke([](ProcDataCallback callback) { callback.Run(nullptr); })));
   }

   // Sets the MockAsyncGrpcClientAdapter to run the next callback with a
   // fake file dump as its ProcDataResponse.
   void SetProcDataResponse(const std::string& file_contents) {
     std::unique_ptr<grpc_api::GetProcDataResponse> response =
         std::make_unique<grpc_api::GetProcDataResponse>();
     // response->mutable_file_dump()->Add()
     EXPECT_CALL(mock_adapter_, GetProcData(_, _))
         .WillRepeatedly(
             Invoke([file_contents](::testing::Unused,
                                    ProcDataCallback callback) mutable {
               std::unique_ptr<grpc_api::GetProcDataResponse> reply =
                   std::make_unique<grpc_api::GetProcDataResponse>();
               grpc_api::FileDump fake_file_dump;
               fake_file_dump.set_contents(file_contents);
               reply->mutable_file_dump()->Add()->Swap(&fake_file_dump);
               callback.Run(std::move(reply));
             }));
   }

   // Checks whether the response matches the expected response from a
   // GetItem(item) command. |item| must be expected as an integer.
   void CheckIntegerItemResponse(
       const base::Optional<base::Value>& actual_response,
       TelemetryItemEnum item) {
     int val;

     // Make sure that a value was returned, and that value has an integer
     // representation.
     ASSERT_TRUE(actual_response);
     ASSERT_TRUE(actual_response.value().GetAsInteger(&val));
     switch (item) {
       case TelemetryItemEnum::kMemTotalMebibytes:
         EXPECT_EQ(val, kFakeMemTotalMebibytes);
         break;
       case TelemetryItemEnum::kMemFreeMebibytes:
         EXPECT_EQ(val, kFakeMemFreeMebibytes);
         break;
       case TelemetryItemEnum::kNumRunnableEntities:
         EXPECT_EQ(val, kFakeNumRunnableEntities);
         break;
       case TelemetryItemEnum::kNumExistingEntities:
         EXPECT_EQ(val, kFakeNumExistingEntities);
         break;
       default:
         // We should never get here, because all items currently tested
         // which have integer representations are enumerated above. However,
         // we need this default case, because some TelemetryItemEnums
         // cannot be represented as integers and are not checked here.
         break;
     }
   }

   // Checks whether the response matches the expected response from a
   // GetItem(item) command. |item| must be expected as a string.
   void CheckStringItemResponse(
       const base::Optional<base::Value>& actual_response,
       TelemetryItemEnum item) {
     std::string val;

     // Make sure that a value was returned, and that value has a string
     // representation.
     ASSERT_TRUE(actual_response);
     ASSERT_TRUE(actual_response.value().GetAsString(&val));
     switch (item) {
       case TelemetryItemEnum::kTotalIdleTimeUserHz:
         EXPECT_EQ(val, kFakeTotalCPUIdleTime);
         break;
       default:
         // We should never get here, because all items currently tested
         // which have string representations are enumerated above. However,
         // we need this default case, because some TelemetryItemEnums
         // cannot be represented as strings and are not checked here.
         break;
     }
   }

   // Checks whether the response matches the expected response from a
   // GetItem(item) command. |item| must be expected as a list.
   void CheckListItemResponse(const base::Optional<base::Value>& actual_response,
                              TelemetryItemEnum item) {
     const base::ListValue* list_val;
     std::string val;

     // Make sure that a value was returned, and that value has a list
     // representation.
     ASSERT_TRUE(actual_response);
     ASSERT_TRUE(actual_response.value().GetAsList(&list_val));
     switch (item) {
       case TelemetryItemEnum::kIdleTimePerCPUUserHz: {
         for (int i = 0; i < list_val->GetSize(); i++) {
           ASSERT_TRUE(list_val->GetString(i, &val));
           EXPECT_EQ(val, kFakePerCPUIdleTimes[i]);
         }
         break;
       }
       default: {
         // We should never get here, because all items currently tested
         // which have list representations are enumerated above. However,
         // we need this default case, because some TelemetryItemEnums
         // cannot be represented as lists and are not checked here.
         break;
       }
     }
   }

   // Checks whether the response matches the expected response
   // from a GetGroup(TelemetryGroupEnum::kDisk) command.
   void CheckDiskGroupResponse(
       const std::vector<
           std::pair<TelemetryItemEnum, const base::Optional<base::Value>>>&
           actual_response) {
     // Indices where we expect MemTotal and MemFree to occur in the response.
     constexpr int kMemTotalIndex = 0;
     constexpr int kMemFreeIndex = 1;
     // Number of items in the kDisk group.
     constexpr int kNumDiskItems = 2;

     int val;

     EXPECT_EQ(actual_response.size(), kNumDiskItems);
     ASSERT_EQ(actual_response[kMemTotalIndex].first,
               TelemetryItemEnum::kMemTotalMebibytes);
     ASSERT_TRUE(actual_response[kMemTotalIndex].second);
     ASSERT_TRUE(
         actual_response[kMemTotalIndex].second.value().GetAsInteger(&val));
     EXPECT_EQ(val, kFakeMemTotalMebibytes);
     EXPECT_EQ(actual_response[kMemFreeIndex].first,
               TelemetryItemEnum::kMemFreeMebibytes);
     ASSERT_TRUE(actual_response[kMemFreeIndex].second);
     ASSERT_TRUE(
         actual_response[kMemFreeIndex].second.value().GetAsInteger(&val));
     EXPECT_EQ(val, kFakeMemFreeMebibytes);
   }

   TelemConnection* connection() { return connection_.get(); }

  private:
   base::MessageLoopForIO message_loop_;
   StrictMock<MockAsyncGrpcClientAdapter> mock_adapter_;
   std::unique_ptr<TelemConnection> connection_ =
       std::make_unique<TelemConnection>(&mock_adapter_);

   DISALLOW_COPY_AND_ASSIGN(TelemConnectionTest);
 };

 // Test that we catch an error response.
 TEST_F(TelemConnectionTest, NullptrResponse) {
   SetNullptrProcDataResponse();

   EXPECT_EQ(connection()->GetItem(TelemetryItemEnum::kMemTotalMebibytes,
                                   base::TimeDelta()),
             base::nullopt);
 }

 // Test that we can retrieve kMemTotalMebibytes.
 TEST_F(TelemConnectionTest, GetMemTotal) {
   SetProcDataResponse(kFakeMeminfoFileContents);

   auto mem_total = connection()->GetItem(TelemetryItemEnum::kMemTotalMebibytes,
                                          base::TimeDelta());
   CheckIntegerItemResponse(mem_total, TelemetryItemEnum::kMemTotalMebibytes);
 }

 // Test that we can retrieve kMemFreeMebibytes.
 TEST_F(TelemConnectionTest, GetMemFree) {
   SetProcDataResponse(kFakeMeminfoFileContents);

   auto mem_free = connection()->GetItem(TelemetryItemEnum::kMemFreeMebibytes,
                                         base::TimeDelta());
   CheckIntegerItemResponse(mem_free, TelemetryItemEnum::kMemFreeMebibytes);
 }

 // Test that an incorrectly formatted /proc/meminfo will fail to parse.
 TEST_F(TelemConnectionTest, GetBadMeminfo) {
   SetProcDataResponse(kFakeBadMeminfoFileContents);

   auto mem_total = connection()->GetItem(TelemetryItemEnum::kMemTotalMebibytes,
                                          base::TimeDelta());
   EXPECT_EQ(mem_total, base::nullopt);
   auto mem_free = connection()->GetItem(TelemetryItemEnum::kMemFreeMebibytes,
                                         base::TimeDelta());
   EXPECT_EQ(mem_free, base::nullopt);
 }

 // Test that we can retrieve kNumRunnableEntities.
 TEST_F(TelemConnectionTest, GetRunnableEntities) {
   SetProcDataResponse(kFakeLoadavgFileContents);

   auto runnable_entities = connection()->GetItem(
       TelemetryItemEnum::kNumRunnableEntities, base::TimeDelta());
   CheckIntegerItemResponse(runnable_entities,
                            TelemetryItemEnum::kNumRunnableEntities);
 }

 // Test that we can retrieve kNumExistingEntities.
 TEST_F(TelemConnectionTest, GetExistingEntities) {
   SetProcDataResponse(kFakeLoadavgFileContents);

   auto existing_entities = connection()->GetItem(
       TelemetryItemEnum::kNumExistingEntities, base::TimeDelta());
   CheckIntegerItemResponse(existing_entities,
                            TelemetryItemEnum::kNumExistingEntities);
 }

 // Test that an incorrectly formatted /proc/loadavg will fail to parse.
 TEST_F(TelemConnectionTest, GetBadLoadAvg) {
   SetProcDataResponse(kFakeBadLoadavgFileContents);

   auto runnable_entities = connection()->GetItem(
       TelemetryItemEnum::kNumRunnableEntities, base::TimeDelta());
   EXPECT_EQ(runnable_entities, base::nullopt);
   auto existing_entities = connection()->GetItem(
       TelemetryItemEnum::kNumExistingEntities, base::TimeDelta());
   EXPECT_EQ(existing_entities, base::nullopt);
 }

 // Test that we can retrieve kTotalIdleTime.
 TEST_F(TelemConnectionTest, GetTotalIdleTime) {
   SetProcDataResponse(kFakeStatFileContents);

   auto idle_time = connection()->GetItem(
       TelemetryItemEnum::kTotalIdleTimeUserHz, base::TimeDelta());
   CheckStringItemResponse(idle_time, TelemetryItemEnum::kTotalIdleTimeUserHz);
 }

 // Test that we can retrieve kIdleTimePerCPU.
 TEST_F(TelemConnectionTest, GetIdleTimePerCPU) {
   SetProcDataResponse(kFakeStatFileContents);

   auto idle_times = connection()->GetItem(
       TelemetryItemEnum::kIdleTimePerCPUUserHz, base::TimeDelta());
   CheckListItemResponse(idle_times, TelemetryItemEnum::kIdleTimePerCPUUserHz);
 }

 // Test that an incorrectly formatted /proc/stat will fail to parse.
 TEST_F(TelemConnectionTest, GetBadStat) {
   SetProcDataResponse(kFakeBadStatFileContents);

   auto total_idle_time = connection()->GetItem(
       TelemetryItemEnum::kTotalIdleTimeUserHz, base::TimeDelta());
   EXPECT_EQ(total_idle_time, base::nullopt);
   auto idle_times_per_cpu = connection()->GetItem(
       TelemetryItemEnum::kIdleTimePerCPUUserHz, base::TimeDelta());
   EXPECT_EQ(idle_times_per_cpu, base::nullopt);
 }

 // Test that we can retrieve a group of telemetry items.
 TEST_F(TelemConnectionTest, GetDiskGroup) {
   SetProcDataResponse(kFakeMeminfoFileContents);

   auto disk_group =
       connection()->GetGroup(TelemetryGroupEnum::kDisk, base::TimeDelta());
   CheckDiskGroupResponse(disk_group);
 }

 }  // namespace diagnostics
	// Copyright 2018 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 <utility>

	#include <base/message_loop/message_loop.h>
	#include <base/time/time.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include "diagnostics/telem/async_grpc_client_adapter.h"
	#include "diagnostics/telem/telem_connection.h"
	#include "diagnostics/telem/telemetry_item_enum.h"

	using ::testing::_;
	using ::testing::Invoke;
	using ::testing::StrictMock;
	using ::testing::WithArg;

	namespace diagnostics {

	namespace {

	using ProcDataCallback = base::Callback<void(
	std::unique_ptr<grpc_api::GetProcDataResponse> response)>;
	using SysfsDataCallback = base::Callback<void(
	std::unique_ptr<grpc_api::GetSysfsDataResponse> response)>;

	constexpr char kFakeMeminfoFileContents[] =
	"MemTotal: 3906320 kB\nMemFree: 873180 kB\n";
	constexpr char kFakeBadMeminfoFileContents[] =
	"MemTotal: 3906320\nMemfree: 873180 kB\n";
	constexpr int kFakeMemTotalMebibytes = 3814;
	constexpr int kFakeMemFreeMebibytes = 852;
	constexpr char kFakeLoadavgFileContents[] = "0.82 0.61 0.52 2/370 30707\n";
	constexpr char kFakeBadLoadavgFileContents[] = "0.82 0.61 0.52 2 370 30707\n";
	constexpr int kFakeNumRunnableEntities = 2;
	constexpr int kFakeNumExistingEntities = 370;
	constexpr char kFakeStatFileContents[] =
	"cpu 0 0 0 165432156432413546\ncpu0 0 0 0 653435243543\ncpu1 0 0 0 "
	"235435413\nctxt 5345634354";
	constexpr char kFakeBadStatFileContents[] =
	"cpu 0 0 165432156432413546\npu0 0 0 0 653435243543\ncpu1 0 0 0 "
	"235435413\nctxt 5345634354";
	constexpr char kFakeTotalCPUIdleTime[] = "165432156432413546";
	char const* kFakePerCPUIdleTimes[] = {"653435243543", "235435413"};

	class MockAsyncGrpcClientAdapter : public AsyncGrpcClientAdapter {
	public:
	void Connect(const std::string& target_uri) override {}

	MOCK_CONST_METHOD0(IsConnected, bool());
	MOCK_METHOD1(Shutdown, void(const base::Closure& on_shutdown));
	MOCK_METHOD2(GetProcData,
	void(const grpc_api::GetProcDataRequest& request,
	ProcDataCallback callback));
	MOCK_METHOD2(GetSysfsData,
	void(const grpc_api::GetSysfsDataRequest& request,
	SysfsDataCallback callback));
	};

	} // namespace

	class TelemConnectionTest : public ::testing::Test {
	protected:
	TelemConnectionTest() {
	EXPECT_CALL(mock_adapter_, Shutdown(_))
	.WillOnce(Invoke(
	[](const base::Closure& on_shutdown) { on_shutdown.Run(); }));
	}

	void SetConnection(std::unique_ptr<TelemConnection> connection) {
	connection_ = std::move(connection);
	}

	// Sets the MockAsyncGrpcClientAdapter to run the next callback with
	// a null pointer as its response.
	void SetNullptrProcDataResponse() {
	EXPECT_CALL(mock_adapter_, GetProcData(_, _))
	.WillOnce(WithArg<1>(
	Invoke([](ProcDataCallback callback) { callback.Run(nullptr); })));
	}

	// Sets the MockAsyncGrpcClientAdapter to run the next callback with a
	// fake file dump as its ProcDataResponse.
	void SetProcDataResponse(const std::string& file_contents) {
	std::unique_ptr<grpc_api::GetProcDataResponse> response =
	std::make_unique<grpc_api::GetProcDataResponse>();
	// response->mutable_file_dump()->Add()
	EXPECT_CALL(mock_adapter_, GetProcData(_, _))
	.WillRepeatedly(
	Invoke([file_contents](::testing::Unused,
	ProcDataCallback callback) mutable {
	std::unique_ptr<grpc_api::GetProcDataResponse> reply =
	std::make_unique<grpc_api::GetProcDataResponse>();
	grpc_api::FileDump fake_file_dump;
	fake_file_dump.set_contents(file_contents);
	reply->mutable_file_dump()->Add()->Swap(&fake_file_dump);
	callback.Run(std::move(reply));
	}));
	}

	// Checks whether the response matches the expected response from a
	// GetItem(item) command. \|item\| must be expected as an integer.
	void CheckIntegerItemResponse(
	const base::Optional<base::Value>& actual_response,
	TelemetryItemEnum item) {
	int val;

	// Make sure that a value was returned, and that value has an integer
	// representation.
	ASSERT_TRUE(actual_response);
	ASSERT_TRUE(actual_response.value().GetAsInteger(&val));
	switch (item) {
	case TelemetryItemEnum::kMemTotalMebibytes:
	EXPECT_EQ(val, kFakeMemTotalMebibytes);
	break;
	case TelemetryItemEnum::kMemFreeMebibytes:
	EXPECT_EQ(val, kFakeMemFreeMebibytes);
	break;
	case TelemetryItemEnum::kNumRunnableEntities:
	EXPECT_EQ(val, kFakeNumRunnableEntities);
	break;
	case TelemetryItemEnum::kNumExistingEntities:
	EXPECT_EQ(val, kFakeNumExistingEntities);
	break;
	default:
	// We should never get here, because all items currently tested
	// which have integer representations are enumerated above. However,
	// we need this default case, because some TelemetryItemEnums
	// cannot be represented as integers and are not checked here.
	break;
	}
	}

	// Checks whether the response matches the expected response from a
	// GetItem(item) command. \|item\| must be expected as a string.
	void CheckStringItemResponse(
	const base::Optional<base::Value>& actual_response,
	TelemetryItemEnum item) {
	std::string val;

	// Make sure that a value was returned, and that value has a string
	// representation.
	ASSERT_TRUE(actual_response);
	ASSERT_TRUE(actual_response.value().GetAsString(&val));
	switch (item) {
	case TelemetryItemEnum::kTotalIdleTimeUserHz:
	EXPECT_EQ(val, kFakeTotalCPUIdleTime);
	break;
	default:
	// We should never get here, because all items currently tested
	// which have string representations are enumerated above. However,
	// we need this default case, because some TelemetryItemEnums
	// cannot be represented as strings and are not checked here.
	break;
	}
	}

	// Checks whether the response matches the expected response from a
	// GetItem(item) command. \|item\| must be expected as a list.
	void CheckListItemResponse(const base::Optional<base::Value>& actual_response,
	TelemetryItemEnum item) {
	const base::ListValue* list_val;
	std::string val;

	// Make sure that a value was returned, and that value has a list
	// representation.
	ASSERT_TRUE(actual_response);
	ASSERT_TRUE(actual_response.value().GetAsList(&list_val));
	switch (item) {
	case TelemetryItemEnum::kIdleTimePerCPUUserHz: {
	for (int i = 0; i < list_val->GetSize(); i++) {
	ASSERT_TRUE(list_val->GetString(i, &val));
	EXPECT_EQ(val, kFakePerCPUIdleTimes[i]);
	}
	break;
	}
	default: {
	// We should never get here, because all items currently tested
	// which have list representations are enumerated above. However,
	// we need this default case, because some TelemetryItemEnums
	// cannot be represented as lists and are not checked here.
	break;
	}
	}
	}

	// Checks whether the response matches the expected response
	// from a GetGroup(TelemetryGroupEnum::kDisk) command.
	void CheckDiskGroupResponse(
	const std::vector<
	std::pair<TelemetryItemEnum, const base::Optional<base::Value>>>&
	actual_response) {
	// Indices where we expect MemTotal and MemFree to occur in the response.
	constexpr int kMemTotalIndex = 0;
	constexpr int kMemFreeIndex = 1;
	// Number of items in the kDisk group.
	constexpr int kNumDiskItems = 2;

	int val;

	EXPECT_EQ(actual_response.size(), kNumDiskItems);
	ASSERT_EQ(actual_response[kMemTotalIndex].first,
	TelemetryItemEnum::kMemTotalMebibytes);
	ASSERT_TRUE(actual_response[kMemTotalIndex].second);
	ASSERT_TRUE(
	actual_response[kMemTotalIndex].second.value().GetAsInteger(&val));
	EXPECT_EQ(val, kFakeMemTotalMebibytes);
	EXPECT_EQ(actual_response[kMemFreeIndex].first,
	TelemetryItemEnum::kMemFreeMebibytes);
	ASSERT_TRUE(actual_response[kMemFreeIndex].second);
	ASSERT_TRUE(
	actual_response[kMemFreeIndex].second.value().GetAsInteger(&val));
	EXPECT_EQ(val, kFakeMemFreeMebibytes);
	}

	TelemConnection* connection() { return connection_.get(); }

	private:
	base::MessageLoopForIO message_loop_;
	StrictMock<MockAsyncGrpcClientAdapter> mock_adapter_;
	std::unique_ptr<TelemConnection> connection_ =
	std::make_unique<TelemConnection>(&mock_adapter_);

	DISALLOW_COPY_AND_ASSIGN(TelemConnectionTest);
	};

	// Test that we catch an error response.
	TEST_F(TelemConnectionTest, NullptrResponse) {
	SetNullptrProcDataResponse();

	EXPECT_EQ(connection()->GetItem(TelemetryItemEnum::kMemTotalMebibytes,
	base::TimeDelta()),
	base::nullopt);
	}

	// Test that we can retrieve kMemTotalMebibytes.
	TEST_F(TelemConnectionTest, GetMemTotal) {
	SetProcDataResponse(kFakeMeminfoFileContents);

	auto mem_total = connection()->GetItem(TelemetryItemEnum::kMemTotalMebibytes,
	base::TimeDelta());
	CheckIntegerItemResponse(mem_total, TelemetryItemEnum::kMemTotalMebibytes);
	}

	// Test that we can retrieve kMemFreeMebibytes.
	TEST_F(TelemConnectionTest, GetMemFree) {
	SetProcDataResponse(kFakeMeminfoFileContents);

	auto mem_free = connection()->GetItem(TelemetryItemEnum::kMemFreeMebibytes,
	base::TimeDelta());
	CheckIntegerItemResponse(mem_free, TelemetryItemEnum::kMemFreeMebibytes);
	}

	// Test that an incorrectly formatted /proc/meminfo will fail to parse.
	TEST_F(TelemConnectionTest, GetBadMeminfo) {
	SetProcDataResponse(kFakeBadMeminfoFileContents);

	auto mem_total = connection()->GetItem(TelemetryItemEnum::kMemTotalMebibytes,
	base::TimeDelta());
	EXPECT_EQ(mem_total, base::nullopt);
	auto mem_free = connection()->GetItem(TelemetryItemEnum::kMemFreeMebibytes,
	base::TimeDelta());
	EXPECT_EQ(mem_free, base::nullopt);
	}

	// Test that we can retrieve kNumRunnableEntities.
	TEST_F(TelemConnectionTest, GetRunnableEntities) {
	SetProcDataResponse(kFakeLoadavgFileContents);

	auto runnable_entities = connection()->GetItem(
	TelemetryItemEnum::kNumRunnableEntities, base::TimeDelta());
	CheckIntegerItemResponse(runnable_entities,
	TelemetryItemEnum::kNumRunnableEntities);
	}

	// Test that we can retrieve kNumExistingEntities.
	TEST_F(TelemConnectionTest, GetExistingEntities) {
	SetProcDataResponse(kFakeLoadavgFileContents);

	auto existing_entities = connection()->GetItem(
	TelemetryItemEnum::kNumExistingEntities, base::TimeDelta());
	CheckIntegerItemResponse(existing_entities,
	TelemetryItemEnum::kNumExistingEntities);
	}

	// Test that an incorrectly formatted /proc/loadavg will fail to parse.
	TEST_F(TelemConnectionTest, GetBadLoadAvg) {
	SetProcDataResponse(kFakeBadLoadavgFileContents);

	auto runnable_entities = connection()->GetItem(
	TelemetryItemEnum::kNumRunnableEntities, base::TimeDelta());
	EXPECT_EQ(runnable_entities, base::nullopt);
	auto existing_entities = connection()->GetItem(
	TelemetryItemEnum::kNumExistingEntities, base::TimeDelta());
	EXPECT_EQ(existing_entities, base::nullopt);
	}

	// Test that we can retrieve kTotalIdleTime.
	TEST_F(TelemConnectionTest, GetTotalIdleTime) {
	SetProcDataResponse(kFakeStatFileContents);

	auto idle_time = connection()->GetItem(
	TelemetryItemEnum::kTotalIdleTimeUserHz, base::TimeDelta());
	CheckStringItemResponse(idle_time, TelemetryItemEnum::kTotalIdleTimeUserHz);
	}

	// Test that we can retrieve kIdleTimePerCPU.
	TEST_F(TelemConnectionTest, GetIdleTimePerCPU) {
	SetProcDataResponse(kFakeStatFileContents);

	auto idle_times = connection()->GetItem(
	TelemetryItemEnum::kIdleTimePerCPUUserHz, base::TimeDelta());
	CheckListItemResponse(idle_times, TelemetryItemEnum::kIdleTimePerCPUUserHz);
	}

	// Test that an incorrectly formatted /proc/stat will fail to parse.
	TEST_F(TelemConnectionTest, GetBadStat) {
	SetProcDataResponse(kFakeBadStatFileContents);

	auto total_idle_time = connection()->GetItem(
	TelemetryItemEnum::kTotalIdleTimeUserHz, base::TimeDelta());
	EXPECT_EQ(total_idle_time, base::nullopt);
	auto idle_times_per_cpu = connection()->GetItem(
	TelemetryItemEnum::kIdleTimePerCPUUserHz, base::TimeDelta());
	EXPECT_EQ(idle_times_per_cpu, base::nullopt);
	}

	// Test that we can retrieve a group of telemetry items.
	TEST_F(TelemConnectionTest, GetDiskGroup) {
	SetProcDataResponse(kFakeMeminfoFileContents);

	auto disk_group =
	connection()->GetGroup(TelemetryGroupEnum::kDisk, base::TimeDelta());
	CheckDiskGroupResponse(disk_group);
	}

	} // namespace diagnostics