// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/rgb_keyboard/rgb_keyboard_manager.h"
#include <stdint.h>
#include <memory>
#include <optional>
#include "ash/constants/ash_features.h"
#include "ash/ime/ime_controller_impl.h"
#include "ash/rgb_keyboard/histogram_util.h"
#include "base/memory/raw_ptr.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "chromeos/ash/components/dbus/rgbkbd/fake_rgbkbd_client.h"
#include "chromeos/ash/components/dbus/rgbkbd/rgbkbd_client.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ash {
class RgbKeyboardManagerTest : public testing::Test {
public:
RgbKeyboardManagerTest() {
scoped_feature_list_.InitWithFeatures(
/*enabled_features=*/{features::kExperimentalRgbKeyboardPatterns},
/*disabled_features=*/{});
// ImeControllerImpl must be initialized before RgbKeyboardManager.
ime_controller_ = std::make_unique<ImeControllerImpl>();
// This is instantiating a global instance that will be deallocated in
// the destructor of RgbKeyboardManagerTest.
RgbkbdClient::InitializeFake();
client_ = static_cast<FakeRgbkbdClient*>(RgbkbdClient::Get());
// Default capabilities to 'RgbKeyboardCapabilities::kIndividualKey'
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
}
RgbKeyboardManagerTest(const RgbKeyboardManagerTest&) = delete;
RgbKeyboardManagerTest& operator=(const RgbKeyboardManagerTest&) = delete;
~RgbKeyboardManagerTest() override {
// Ordering for deletion is Manger -> Client -> IME Controller
manager_.reset();
RgbkbdClient::Shutdown();
ime_controller_.reset();
}
protected:
void InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities capability) {
client_->set_rgb_keyboard_capabilities(capability);
// |ime_controller_| is initialized in RgbKeyboardManagerTest's ctor.
DCHECK(ime_controller_);
manager_.reset();
manager_ = std::make_unique<RgbKeyboardManager>(ime_controller_.get());
}
// ImeControllerImpl must be destroyed after RgbKeyboardManager.
std::unique_ptr<ImeControllerImpl> ime_controller_;
std::unique_ptr<RgbKeyboardManager> manager_;
raw_ptr<FakeRgbkbdClient, DanglingUntriaged> client_;
private:
base::test::ScopedFeatureList scoped_feature_list_;
};
TEST_F(RgbKeyboardManagerTest, GetKeyboardCapabilities) {
// kIndividualKey is the default for this test suite.
EXPECT_EQ(rgbkbd::RgbKeyboardCapabilities::kIndividualKey,
client_->get_rgb_keyboard_capabilities());
}
class KeyboardCapabilityHistogramEmittedTest
: public RgbKeyboardManagerTest,
public testing::WithParamInterface<
std::pair<rgbkbd::RgbKeyboardCapabilities,
ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType>> {
public:
KeyboardCapabilityHistogramEmittedTest() {
std::tie(capability_, metric_) = GetParam();
}
protected:
rgbkbd::RgbKeyboardCapabilities capability_;
ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType metric_;
};
INSTANTIATE_TEST_SUITE_P(
All,
KeyboardCapabilityHistogramEmittedTest,
testing::Values(
std::make_pair(
rgbkbd::RgbKeyboardCapabilities::kNone,
ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::kNone),
std::make_pair(rgbkbd::RgbKeyboardCapabilities::kIndividualKey,
ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
kIndividualKey),
std::make_pair(rgbkbd::RgbKeyboardCapabilities::kFourZoneFortyLed,
ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
kFourZoneFortyLed),
std::make_pair(rgbkbd::RgbKeyboardCapabilities::kFourZoneTwelveLed,
ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
kFourZoneTwelveLed),
std::make_pair(rgbkbd::RgbKeyboardCapabilities::kFourZoneFourLed,
ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
kFourZoneFourLed)));
TEST_P(KeyboardCapabilityHistogramEmittedTest,
KeyboardCapabilityHistogramEmitted) {
base::HistogramTester histogram_tester;
InitializeManagerWithCapability(capability_);
EXPECT_EQ(capability_, client_->get_rgb_keyboard_capabilities());
histogram_tester.ExpectBucketCount(
rgb_keyboard::metrics::kRgbKeyboardCapabilityTypeHistogramName, metric_,
1);
}
class RgbChangeTypeHistogramEmittedTest
: public RgbKeyboardManagerTest,
public testing::WithParamInterface<rgbkbd::RgbKeyboardCapabilities> {
public:
RgbChangeTypeHistogramEmittedTest() = default;
};
INSTANTIATE_TEST_SUITE_P(
All,
RgbChangeTypeHistogramEmittedTest,
testing::Values(rgbkbd::RgbKeyboardCapabilities::kIndividualKey,
rgbkbd::RgbKeyboardCapabilities::kFourZoneFortyLed,
rgbkbd::RgbKeyboardCapabilities::kFourZoneTwelveLed,
rgbkbd::RgbKeyboardCapabilities::kFourZoneFourLed));
TEST_P(RgbChangeTypeHistogramEmittedTest, RgbChangeTypeHistogramEmitted) {
base::HistogramTester histogram_tester;
const auto capability = GetParam();
const auto name =
std::string(ash::rgb_keyboard::metrics::kRgbKeyboardHistogramPrefix +
ash::rgb_keyboard::metrics::GetCapabilityTypeStr(capability));
InitializeManagerWithCapability(capability);
manager_->SetStaticBackgroundColor(/*r=*/1, /*g=*/2, /*b=*/3);
histogram_tester.ExpectBucketCount(
name,
ash::rgb_keyboard::metrics::RgbKeyboardBacklightChangeType::
kStaticBackgroundColorChanged,
1);
manager_->SetRainbowMode();
histogram_tester.ExpectBucketCount(
name,
ash::rgb_keyboard::metrics::RgbKeyboardBacklightChangeType::
kRainbowModeSelected,
1);
manager_->SetZoneColor(/*zone=*/0, /*r=*/1, /*g=*/2, /*b=*/3);
histogram_tester.ExpectBucketCount(
name,
ash::rgb_keyboard::metrics::RgbKeyboardBacklightChangeType::
kStaticZoneColorChanged,
1);
}
TEST_F(RgbKeyboardManagerTest, ZoneCountIsCorrect) {
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
EXPECT_EQ(5, manager_->GetZoneCount());
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kFourZoneFortyLed);
EXPECT_EQ(4, manager_->GetZoneCount());
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kFourZoneTwelveLed);
EXPECT_EQ(4, manager_->GetZoneCount());
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kFourZoneFourLed);
EXPECT_EQ(4, manager_->GetZoneCount());
InitializeManagerWithCapability(rgbkbd::RgbKeyboardCapabilities::kNone);
EXPECT_EQ(0, manager_->GetZoneCount());
}
TEST_F(RgbKeyboardManagerTest, SetStaticRgbValues) {
const uint8_t expected_r = 1;
const uint8_t expected_g = 2;
const uint8_t expected_b = 3;
manager_->SetStaticBackgroundColor(expected_r, expected_g, expected_b);
const RgbColor& rgb_values = client_->recently_sent_rgb();
EXPECT_EQ(expected_r, std::get<0>(rgb_values));
EXPECT_EQ(expected_g, std::get<1>(rgb_values));
EXPECT_EQ(expected_b, std::get<2>(rgb_values));
}
TEST_F(RgbKeyboardManagerTest, SetZoneRgbValues) {
const int zone_1 = 0;
const uint8_t expected_r_1 = 1;
const uint8_t expected_g_1 = 2;
const uint8_t expected_b_1 = 3;
const int zone_2 = 3;
const uint8_t expected_r_2 = 4;
const uint8_t expected_g_2 = 5;
const uint8_t expected_b_2 = 6;
manager_->SetZoneColor(zone_1, expected_r_1, expected_g_1, expected_b_1);
manager_->SetZoneColor(zone_2, expected_r_2, expected_g_2, expected_b_2);
auto zone_colors = client_->get_zone_colors();
EXPECT_EQ(2u, zone_colors.size());
EXPECT_EQ(zone_colors[zone_1],
std::make_tuple(expected_r_1, expected_g_1, expected_b_1));
EXPECT_EQ(zone_colors[zone_2],
std::make_tuple(expected_r_2, expected_g_2, expected_b_2));
}
TEST_F(RgbKeyboardManagerTest, SetInvalidZoneId) {
const int invalid_zone = 100;
const uint8_t expected_r = 1;
const uint8_t expected_g = 2;
const uint8_t expected_b = 3;
manager_->SetZoneColor(invalid_zone, expected_r, expected_g, expected_b);
auto zone_colors = client_->get_zone_colors();
EXPECT_EQ(0u, zone_colors.size());
const int valid_zone = 0;
manager_->SetZoneColor(valid_zone, expected_r, expected_g, expected_b);
zone_colors = client_->get_zone_colors();
EXPECT_EQ(1u, zone_colors.size());
EXPECT_EQ(zone_colors[valid_zone],
std::make_tuple(expected_r, expected_g, expected_b));
}
TEST_F(RgbKeyboardManagerTest, SetRainbowMode) {
EXPECT_FALSE(client_->is_rainbow_mode_set());
manager_->SetRainbowMode();
EXPECT_TRUE(client_->is_rainbow_mode_set());
}
TEST_F(RgbKeyboardManagerTest, RainbowModeResetsStatic) {
EXPECT_FALSE(client_->is_rainbow_mode_set());
const uint8_t expected_r = 1;
const uint8_t expected_g = 2;
const uint8_t expected_b = 3;
manager_->SetStaticBackgroundColor(expected_r, expected_g, expected_b);
const RgbColor& rgb_values = client_->recently_sent_rgb();
EXPECT_EQ(expected_r, std::get<0>(rgb_values));
EXPECT_EQ(expected_g, std::get<1>(rgb_values));
EXPECT_EQ(expected_b, std::get<2>(rgb_values));
manager_->SetRainbowMode();
EXPECT_TRUE(client_->is_rainbow_mode_set());
const RgbColor& updated_rgb_values = client_->recently_sent_rgb();
EXPECT_EQ(0u, std::get<0>(updated_rgb_values));
EXPECT_EQ(0u, std::get<1>(updated_rgb_values));
EXPECT_EQ(0u, std::get<2>(updated_rgb_values));
}
TEST_F(RgbKeyboardManagerTest, StaticResetRainbowMode) {
EXPECT_FALSE(client_->is_rainbow_mode_set());
manager_->SetRainbowMode();
EXPECT_TRUE(client_->is_rainbow_mode_set());
const uint8_t expected_r = 1;
const uint8_t expected_g = 2;
const uint8_t expected_b = 3;
manager_->SetStaticBackgroundColor(expected_r, expected_g, expected_b);
const RgbColor& rgb_values = client_->recently_sent_rgb();
EXPECT_FALSE(client_->is_rainbow_mode_set());
EXPECT_EQ(expected_r, std::get<0>(rgb_values));
EXPECT_EQ(expected_g, std::get<1>(rgb_values));
EXPECT_EQ(expected_b, std::get<2>(rgb_values));
}
TEST_F(RgbKeyboardManagerTest, OnCapsLockChanged) {
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
ime_controller_->UpdateCapsLockState(/*caps_enabled=*/true);
EXPECT_TRUE(client_->get_caps_lock_state());
ime_controller_->UpdateCapsLockState(/*caps_enabled=*/false);
EXPECT_FALSE(client_->get_caps_lock_state());
}
TEST_F(RgbKeyboardManagerTest, OnLoginCapsLock) {
// Simulate CapsLock enabled upon login.
ime_controller_->SetCapsLockEnabled(/*caps_enabled=*/true);
// Simulate RgbKeyboardManager starting up on login.
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
EXPECT_TRUE(client_->get_caps_lock_state());
}
// TODO(jimmyxgong): This is just a stub test, there is only one enum available
// so just check num times the function has been called.
TEST_F(RgbKeyboardManagerTest, SetAnimationMode) {
EXPECT_EQ(0, client_->animation_mode_call_count());
manager_->SetAnimationMode(rgbkbd::RgbAnimationMode::kBasicTestPattern);
EXPECT_EQ(1, client_->animation_mode_call_count());
}
TEST_F(RgbKeyboardManagerTest, SetCapsLockStateDisallowedForZonedKeyboards) {
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kFourZoneFortyLed);
EXPECT_FALSE(client_->get_caps_lock_state());
ime_controller_->UpdateCapsLockState(/*caps_enabled=*/true);
// Caps lock state should still be false since RgbKeyboardManager should have
// prevented the call to SetCapsLockState.
EXPECT_FALSE(client_->get_caps_lock_state());
}
TEST_F(RgbKeyboardManagerTest, SetCapsLockStateAllowedForPerKeyKeboards) {
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
EXPECT_FALSE(client_->get_caps_lock_state());
ime_controller_->UpdateCapsLockState(/*caps_enabled=*/true);
EXPECT_TRUE(client_->get_caps_lock_state());
}
// Following `RaceCondition*` tests verify that if a keyboard backlight color is
// set before `RgbKeyboardManager` is ready, that the color is set once
// `RgbKeyboardManager` is finally ready.
TEST_F(RgbKeyboardManagerTest, RaceConditionStaticSingleColor) {
const uint8_t expected_r = 1;
const uint8_t expected_g = 2;
const uint8_t expected_b = 3;
client_->set_should_run_rgb_keyboard_capabilities_callback(
/*should_run_callback=*/false);
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
manager_->SetStaticBackgroundColor(expected_r, expected_g, expected_b);
{
const RgbColor& rgb_values = client_->recently_sent_rgb();
EXPECT_NE(expected_r, std::get<0>(rgb_values));
EXPECT_NE(expected_g, std::get<1>(rgb_values));
EXPECT_NE(expected_b, std::get<2>(rgb_values));
}
client_->set_should_run_rgb_keyboard_capabilities_callback(
/*should_run_callback=*/true);
client_->attempt_run_rgb_keyboard_capabilities_callback();
{
const RgbColor& rgb_values = client_->recently_sent_rgb();
EXPECT_EQ(expected_r, std::get<0>(rgb_values));
EXPECT_EQ(expected_g, std::get<1>(rgb_values));
EXPECT_EQ(expected_b, std::get<2>(rgb_values));
}
}
TEST_F(RgbKeyboardManagerTest, RaceConditionStaticZoneColor) {
const int zone_1 = 0;
const uint8_t expected_r_1 = 1;
const uint8_t expected_g_1 = 2;
const uint8_t expected_b_1 = 3;
const int zone_2 = 3;
const uint8_t expected_r_2 = 4;
const uint8_t expected_g_2 = 5;
const uint8_t expected_b_2 = 6;
client_->set_should_run_rgb_keyboard_capabilities_callback(
/*should_run_callback=*/false);
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
manager_->SetZoneColor(zone_1, expected_r_1, expected_g_1, expected_b_1);
manager_->SetZoneColor(zone_2, expected_r_2, expected_g_2, expected_b_2);
{
auto zone_colors = client_->get_zone_colors();
EXPECT_EQ(0u, zone_colors.size());
}
client_->set_should_run_rgb_keyboard_capabilities_callback(
/*should_run_callback=*/true);
client_->attempt_run_rgb_keyboard_capabilities_callback();
{
auto zone_colors = client_->get_zone_colors();
EXPECT_EQ(2u, zone_colors.size());
EXPECT_EQ(zone_colors[zone_1],
std::make_tuple(expected_r_1, expected_g_1, expected_b_1));
EXPECT_EQ(zone_colors[zone_2],
std::make_tuple(expected_r_2, expected_g_2, expected_b_2));
}
}
TEST_F(RgbKeyboardManagerTest, RaceConditionStaticRainbow) {
client_->set_should_run_rgb_keyboard_capabilities_callback(
/*should_run_callback=*/false);
InitializeManagerWithCapability(
rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
manager_->SetRainbowMode();
EXPECT_FALSE(client_->is_rainbow_mode_set());
client_->set_should_run_rgb_keyboard_capabilities_callback(
/*should_run_callback=*/true);
client_->attempt_run_rgb_keyboard_capabilities_callback();
EXPECT_TRUE(client_->is_rainbow_mode_set());
}
} // namespace ash
Codebase Browser
chromium