blob: 1fe0cd8c3f057ede4697067c57354b2e0eef392a [file] [log] [blame]
// Copyright 2020 The Chromium 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 "chromeos/components/telemetry_extension_ui/probe_service_converters.h"
#include <cstdint>
#include <vector>
#include "chromeos/components/telemetry_extension_ui/mojom/probe_service.mojom.h"
#include "chromeos/services/cros_healthd/public/mojom/cros_healthd_probe.mojom.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using testing::ElementsAre;
namespace chromeos {
namespace probe_service_converters {
TEST(ProbeServiceConvertors, ProbeCategoryEnum) {
EXPECT_EQ(Convert(health::mojom::ProbeCategoryEnum::kBattery),
cros_healthd::mojom::ProbeCategoryEnum::kBattery);
}
TEST(ProbeServiceConvertors, ProbeCategoryEnumVector) {
const std::vector<health::mojom::ProbeCategoryEnum> kInput{
health::mojom::ProbeCategoryEnum::kBattery};
EXPECT_THAT(Convert(kInput),
ElementsAre(cros_healthd::mojom::ProbeCategoryEnum::kBattery));
}
TEST(ProbeServiceConvertors, ErrorType) {
EXPECT_EQ(Convert(cros_healthd::mojom::ErrorType::kFileReadError),
health::mojom::ErrorType::kFileReadError);
EXPECT_EQ(Convert(cros_healthd::mojom::ErrorType::kParseError),
health::mojom::ErrorType::kParseError);
EXPECT_EQ(Convert(cros_healthd::mojom::ErrorType::kSystemUtilityError),
health::mojom::ErrorType::kSystemUtilityError);
}
TEST(ProbeServiceConvertors, ProbeErrorPtrNull) {
EXPECT_TRUE(Convert(cros_healthd::mojom::ProbeErrorPtr()).is_null());
}
TEST(ProbeServiceConvertors, ProbeErrorPtr) {
constexpr char kMsg[] = "file not found";
EXPECT_EQ(Convert(cros_healthd::mojom::ProbeError::New(
cros_healthd::mojom::ErrorType::kFileReadError, kMsg)),
health::mojom::ProbeError::New(
health::mojom::ErrorType::kFileReadError, kMsg));
}
TEST(ProbeServiceConvertors, DoubleValuePtr) {
constexpr double kValue = 100500.500100;
EXPECT_EQ(Convert(kValue), health::mojom::DoubleValue::New(kValue));
}
TEST(ProbeServiceConvertors, Int64ValuePtr) {
constexpr int64_t kValue = 100500;
EXPECT_EQ(Convert(kValue), health::mojom::Int64Value::New(kValue));
}
TEST(ProbeServiceConvertors, UInt64ValuePtrNull) {
EXPECT_TRUE(Convert(cros_healthd::mojom::UInt64ValuePtr()).is_null());
}
TEST(ProbeServiceConvertors, UInt64ValuePtr) {
constexpr uint64_t kValue = -100500;
EXPECT_EQ(Convert(cros_healthd::mojom::UInt64Value::New(kValue)),
health::mojom::UInt64Value::New(kValue));
}
TEST(ProbeServiceConvertors, BatteryInfoPtrNull) {
EXPECT_TRUE(Convert(cros_healthd::mojom::BatteryInfoPtr()).is_null());
}
TEST(ProbeServiceConvertors, BatteryInfoPtr) {
constexpr int64_t kCycleCount = 512;
constexpr double kVoltageNow = 10.2;
constexpr char kVendor[] = "Google";
constexpr char kSerialNumber[] = "ABCDEF123456";
constexpr double kChargeFullDesign = 1000.3;
constexpr double kChargeFull = 999.0;
constexpr double kVoltageMinDesign = 41.1;
constexpr char kModelName[] = "Google Battery";
constexpr double kChargeNow = 20.1;
constexpr double kCurrentNow = 15.2;
constexpr char kTechnology[] = "FastCharge";
constexpr char kStatus[] = "Charging";
constexpr char kManufactureDate[] = "2018-10-01";
constexpr uint64_t kTemperature = 3097;
// Here we don't use cros_healthd::mojom::BatteryInfo::New because BatteryInfo
// may contain some fields that we don't use yet.
auto battery_info = cros_healthd::mojom::BatteryInfo::New();
battery_info->cycle_count = kCycleCount;
battery_info->voltage_now = kVoltageNow;
battery_info->vendor = kVendor;
battery_info->serial_number = kSerialNumber;
battery_info->charge_full_design = kChargeFullDesign;
battery_info->charge_full = kChargeFull;
battery_info->voltage_min_design = kVoltageMinDesign;
battery_info->model_name = kModelName;
battery_info->charge_now = kChargeNow;
battery_info->current_now = kCurrentNow;
battery_info->technology = kTechnology;
battery_info->status = kStatus;
battery_info->manufacture_date = kManufactureDate;
battery_info->temperature =
cros_healthd::mojom::UInt64Value::New(kTemperature);
// Here we intentionaly use health::mojom::BatteryInfo::New to don't
// forget to test new fields.
EXPECT_EQ(
Convert(battery_info.Clone()),
health::mojom::BatteryInfo::New(
health::mojom::Int64Value::New(kCycleCount),
health::mojom::DoubleValue::New(kVoltageNow), kVendor, kSerialNumber,
health::mojom::DoubleValue::New(kChargeFullDesign),
health::mojom::DoubleValue::New(kChargeFull),
health::mojom::DoubleValue::New(kVoltageMinDesign), kModelName,
health::mojom::DoubleValue::New(kChargeNow),
health::mojom::DoubleValue::New(kCurrentNow), kTechnology, kStatus,
kManufactureDate, health::mojom::UInt64Value::New(kTemperature)));
}
TEST(ProbeServiceConvertors, BatteryResultPtrNull) {
EXPECT_TRUE(Convert(cros_healthd::mojom::BatteryResultPtr()).is_null());
}
TEST(ProbeServiceConvertors, BatteryResultPtrInfo) {
const health::mojom::BatteryResultPtr ptr =
Convert(cros_healthd::mojom::BatteryResult::NewBatteryInfo(nullptr));
ASSERT_TRUE(ptr);
EXPECT_TRUE(ptr->is_battery_info());
}
TEST(ProbeServiceConvertors, BatteryResultPtrError) {
const health::mojom::BatteryResultPtr ptr =
Convert(cros_healthd::mojom::BatteryResult::NewError(nullptr));
ASSERT_TRUE(ptr);
EXPECT_TRUE(ptr->is_error());
}
TEST(ProbeServiceConvertors, TelemetryInfoPtrHasBatteryResult) {
constexpr int64_t kCycleCount = 1;
auto battery_info_input = cros_healthd::mojom::BatteryInfo::New();
battery_info_input->cycle_count = kCycleCount;
auto telemetry_info_input = cros_healthd::mojom::TelemetryInfo::New();
telemetry_info_input->battery_result =
cros_healthd::mojom::BatteryResult::NewBatteryInfo(
std::move(battery_info_input));
const health::mojom::TelemetryInfoPtr telemetry_info_output =
Convert(std::move(telemetry_info_input));
ASSERT_TRUE(telemetry_info_output);
ASSERT_TRUE(telemetry_info_output->battery_result);
ASSERT_TRUE(telemetry_info_output->battery_result->is_battery_info());
ASSERT_TRUE(telemetry_info_output->battery_result->get_battery_info());
ASSERT_TRUE(
telemetry_info_output->battery_result->get_battery_info()->cycle_count);
EXPECT_EQ(telemetry_info_output->battery_result->get_battery_info()
->cycle_count->value,
kCycleCount);
}
TEST(ProbeServiceConvertors, TelemetryInfoPtrWithNullFields) {
const health::mojom::TelemetryInfoPtr telemetry_info_output =
Convert(cros_healthd::mojom::TelemetryInfo::New());
ASSERT_TRUE(telemetry_info_output);
EXPECT_FALSE(telemetry_info_output->battery_result);
}
TEST(ProbeServiceConvertors, TelemetryInfoPtrNull) {
EXPECT_TRUE(Convert(cros_healthd::mojom::TelemetryInfoPtr()).is_null());
}
} // namespace probe_service_converters
} // namespace chromeos