rgb_keyboard_manager_unittest.cc 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265
  1. // Copyright 2022 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ash/rgb_keyboard/rgb_keyboard_manager.h"
  5. #include <stdint.h>
  6. #include <memory>
  7. #include "ash/constants/ash_features.h"
  8. #include "ash/ime/ime_controller_impl.h"
  9. #include "ash/rgb_keyboard/histogram_util.h"
  10. #include "base/memory/raw_ptr.h"
  11. #include "base/strings/strcat.h"
  12. #include "base/test/metrics/histogram_tester.h"
  13. #include "base/test/scoped_feature_list.h"
  14. #include "chromeos/ash/components/dbus/rgbkbd/fake_rgbkbd_client.h"
  15. #include "chromeos/ash/components/dbus/rgbkbd/rgbkbd_client.h"
  16. #include "rgb_keyboard_util.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. namespace ash {
  19. class RgbKeyboardManagerTest : public testing::Test {
  20. public:
  21. RgbKeyboardManagerTest() {
  22. scoped_feature_list_.InitWithFeatures(
  23. /*enabled_features=*/{features::kRgbKeyboard,
  24. features::kExperimentalRgbKeyboardPatterns},
  25. /*disabled_features=*/{});
  26. // ImeControllerImpl must be initialized before RgbKeyboardManager.
  27. ime_controller_ = std::make_unique<ImeControllerImpl>();
  28. // This is instantiating a global instance that will be deallocated in
  29. // the destructor of RgbKeyboardManagerTest.
  30. RgbkbdClient::InitializeFake();
  31. client_ = static_cast<FakeRgbkbdClient*>(RgbkbdClient::Get());
  32. // Default capabilities to 'RgbKeyboardCapabilities::kIndividualKey'
  33. InitializeManagerWithCapability(
  34. rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
  35. }
  36. RgbKeyboardManagerTest(const RgbKeyboardManagerTest&) = delete;
  37. RgbKeyboardManagerTest& operator=(const RgbKeyboardManagerTest&) = delete;
  38. ~RgbKeyboardManagerTest() override {
  39. // Ordering for deletion is Manger -> Client -> IME Controller
  40. manager_.reset();
  41. RgbkbdClient::Shutdown();
  42. ime_controller_.reset();
  43. };
  44. protected:
  45. void InitializeManagerWithCapability(
  46. rgbkbd::RgbKeyboardCapabilities capability) {
  47. client_->set_rgb_keyboard_capabilities(capability);
  48. // |ime_controller_| is initialized in RgbKeyboardManagerTest's ctor.
  49. DCHECK(ime_controller_);
  50. manager_.reset();
  51. manager_ = std::make_unique<RgbKeyboardManager>(ime_controller_.get());
  52. }
  53. // ImeControllerImpl must be destroyed after RgbKeyboardManager.
  54. std::unique_ptr<ImeControllerImpl> ime_controller_;
  55. std::unique_ptr<RgbKeyboardManager> manager_;
  56. raw_ptr<FakeRgbkbdClient> client_;
  57. private:
  58. base::test::ScopedFeatureList scoped_feature_list_;
  59. };
  60. TEST_F(RgbKeyboardManagerTest, GetKeyboardCapabilities) {
  61. // kIndividualKey is the default for this test suite.
  62. EXPECT_EQ(rgbkbd::RgbKeyboardCapabilities::kIndividualKey,
  63. client_->get_rgb_keyboard_capabilities());
  64. }
  65. class KeyboardCapabilityHistogramEmittedTest
  66. : public RgbKeyboardManagerTest,
  67. public testing::WithParamInterface<
  68. std::pair<rgbkbd::RgbKeyboardCapabilities,
  69. ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType>> {
  70. public:
  71. KeyboardCapabilityHistogramEmittedTest() {
  72. std::tie(capability_, metric_) = GetParam();
  73. }
  74. protected:
  75. rgbkbd::RgbKeyboardCapabilities capability_;
  76. ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType metric_;
  77. };
  78. INSTANTIATE_TEST_SUITE_P(
  79. All,
  80. KeyboardCapabilityHistogramEmittedTest,
  81. testing::Values(
  82. std::make_pair(
  83. rgbkbd::RgbKeyboardCapabilities::kNone,
  84. ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::kNone),
  85. std::make_pair(rgbkbd::RgbKeyboardCapabilities::kIndividualKey,
  86. ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
  87. kIndividualKey),
  88. std::make_pair(rgbkbd::RgbKeyboardCapabilities::kFourZoneFortyLed,
  89. ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
  90. kFourZoneFortyLed),
  91. std::make_pair(rgbkbd::RgbKeyboardCapabilities::kFourZoneTwelveLed,
  92. ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
  93. kFourZoneTwelveLed),
  94. std::make_pair(rgbkbd::RgbKeyboardCapabilities::kFourZoneFourLed,
  95. ash::rgb_keyboard::metrics::RgbKeyboardCapabilityType::
  96. kFourZoneFourLed)));
  97. TEST_P(KeyboardCapabilityHistogramEmittedTest,
  98. KeyboardCapabilityHistogramEmitted) {
  99. base::HistogramTester histogram_tester;
  100. InitializeManagerWithCapability(capability_);
  101. EXPECT_EQ(capability_, client_->get_rgb_keyboard_capabilities());
  102. histogram_tester.ExpectBucketCount(
  103. rgb_keyboard::metrics::kRgbKeyboardCapabilityTypeHistogramName, metric_,
  104. 1);
  105. }
  106. class RgbChangeTypeHistogramEmittedTest
  107. : public RgbKeyboardManagerTest,
  108. public testing::WithParamInterface<rgbkbd::RgbKeyboardCapabilities> {
  109. public:
  110. RgbChangeTypeHistogramEmittedTest() = default;
  111. };
  112. INSTANTIATE_TEST_SUITE_P(
  113. All,
  114. RgbChangeTypeHistogramEmittedTest,
  115. testing::Values(rgbkbd::RgbKeyboardCapabilities::kIndividualKey,
  116. rgbkbd::RgbKeyboardCapabilities::kFourZoneFortyLed,
  117. rgbkbd::RgbKeyboardCapabilities::kFourZoneTwelveLed,
  118. rgbkbd::RgbKeyboardCapabilities::kFourZoneFourLed));
  119. TEST_P(RgbChangeTypeHistogramEmittedTest, RgbChangeTypeHistogramEmitted) {
  120. base::HistogramTester histogram_tester;
  121. const auto capability = GetParam();
  122. const auto name =
  123. std::string(ash::rgb_keyboard::metrics::kRgbKeyboardHistogramPrefix +
  124. ash::rgb_keyboard::metrics::GetCapabilityTypeStr(capability));
  125. InitializeManagerWithCapability(capability);
  126. manager_->SetStaticBackgroundColor(/*r=*/1, /*g=*/2, /*b=*/3);
  127. histogram_tester.ExpectBucketCount(
  128. name,
  129. ash::rgb_keyboard::metrics::RgbKeyboardBacklightChangeType::
  130. kStaticBackgroundColorChanged,
  131. 1);
  132. manager_->SetRainbowMode();
  133. histogram_tester.ExpectBucketCount(
  134. name,
  135. ash::rgb_keyboard::metrics::RgbKeyboardBacklightChangeType::
  136. kRainbowModeSelected,
  137. 1);
  138. }
  139. TEST_F(RgbKeyboardManagerTest, SetStaticRgbValues) {
  140. const uint8_t expected_r = 1;
  141. const uint8_t expected_g = 2;
  142. const uint8_t expected_b = 3;
  143. manager_->SetStaticBackgroundColor(expected_r, expected_g, expected_b);
  144. const RgbColor& rgb_values = client_->recently_sent_rgb();
  145. EXPECT_EQ(expected_r, std::get<0>(rgb_values));
  146. EXPECT_EQ(expected_g, std::get<1>(rgb_values));
  147. EXPECT_EQ(expected_b, std::get<2>(rgb_values));
  148. }
  149. TEST_F(RgbKeyboardManagerTest, SetRainbowMode) {
  150. EXPECT_FALSE(client_->is_rainbow_mode_set());
  151. manager_->SetRainbowMode();
  152. EXPECT_TRUE(client_->is_rainbow_mode_set());
  153. }
  154. TEST_F(RgbKeyboardManagerTest, RainbowModeResetsStatic) {
  155. EXPECT_FALSE(client_->is_rainbow_mode_set());
  156. const uint8_t expected_r = 1;
  157. const uint8_t expected_g = 2;
  158. const uint8_t expected_b = 3;
  159. manager_->SetStaticBackgroundColor(expected_r, expected_g, expected_b);
  160. const RgbColor& rgb_values = client_->recently_sent_rgb();
  161. EXPECT_EQ(expected_r, std::get<0>(rgb_values));
  162. EXPECT_EQ(expected_g, std::get<1>(rgb_values));
  163. EXPECT_EQ(expected_b, std::get<2>(rgb_values));
  164. manager_->SetRainbowMode();
  165. EXPECT_TRUE(client_->is_rainbow_mode_set());
  166. const RgbColor& updated_rgb_values = client_->recently_sent_rgb();
  167. EXPECT_EQ(0u, std::get<0>(updated_rgb_values));
  168. EXPECT_EQ(0u, std::get<1>(updated_rgb_values));
  169. EXPECT_EQ(0u, std::get<2>(updated_rgb_values));
  170. }
  171. TEST_F(RgbKeyboardManagerTest, StaticResetRainbowMode) {
  172. EXPECT_FALSE(client_->is_rainbow_mode_set());
  173. manager_->SetRainbowMode();
  174. EXPECT_TRUE(client_->is_rainbow_mode_set());
  175. const uint8_t expected_r = 1;
  176. const uint8_t expected_g = 2;
  177. const uint8_t expected_b = 3;
  178. manager_->SetStaticBackgroundColor(expected_r, expected_g, expected_b);
  179. const RgbColor& rgb_values = client_->recently_sent_rgb();
  180. EXPECT_FALSE(client_->is_rainbow_mode_set());
  181. EXPECT_EQ(expected_r, std::get<0>(rgb_values));
  182. EXPECT_EQ(expected_g, std::get<1>(rgb_values));
  183. EXPECT_EQ(expected_b, std::get<2>(rgb_values));
  184. }
  185. TEST_F(RgbKeyboardManagerTest, OnCapsLockChanged) {
  186. InitializeManagerWithCapability(
  187. rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
  188. ime_controller_->UpdateCapsLockState(/*caps_enabled=*/true);
  189. EXPECT_TRUE(client_->get_caps_lock_state());
  190. ime_controller_->UpdateCapsLockState(/*caps_enabled=*/false);
  191. EXPECT_FALSE(client_->get_caps_lock_state());
  192. }
  193. TEST_F(RgbKeyboardManagerTest, OnLoginCapsLock) {
  194. // Simulate CapsLock enabled upon login.
  195. ime_controller_->SetCapsLockEnabled(/*caps_enabled=*/true);
  196. // Simulate RgbKeyboardManager starting up on login.
  197. InitializeManagerWithCapability(
  198. rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
  199. EXPECT_TRUE(client_->get_caps_lock_state());
  200. }
  201. // TODO(jimmyxgong): This is just a stub test, there is only one enum available
  202. // so just check num times the function has been called.
  203. TEST_F(RgbKeyboardManagerTest, SetAnimationMode) {
  204. EXPECT_EQ(0, client_->animation_mode_call_count());
  205. manager_->SetAnimationMode(rgbkbd::RgbAnimationMode::kBasicTestPattern);
  206. EXPECT_EQ(1, client_->animation_mode_call_count());
  207. }
  208. TEST_F(RgbKeyboardManagerTest, SetCapsLockStateDisallowedForZonedKeyboards) {
  209. InitializeManagerWithCapability(
  210. rgbkbd::RgbKeyboardCapabilities::kFourZoneFortyLed);
  211. EXPECT_FALSE(client_->get_caps_lock_state());
  212. ime_controller_->UpdateCapsLockState(/*caps_enabled=*/true);
  213. // Caps lock state should still be false since RgbKeyboardManager should have
  214. // prevented the call to SetCapsLockState.
  215. EXPECT_FALSE(client_->get_caps_lock_state());
  216. }
  217. TEST_F(RgbKeyboardManagerTest, SetCapsLockStateAllowedForPerKeyKeboards) {
  218. InitializeManagerWithCapability(
  219. rgbkbd::RgbKeyboardCapabilities::kIndividualKey);
  220. EXPECT_FALSE(client_->get_caps_lock_state());
  221. ime_controller_->UpdateCapsLockState(/*caps_enabled=*/true);
  222. EXPECT_TRUE(client_->get_caps_lock_state());
  223. }
  224. } // namespace ash