gamepad_unittest.cc 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328
  1. // Copyright 2020 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 "components/exo/gamepad.h"
  5. #include "ash/constants/ash_features.h"
  6. #include "base/test/scoped_feature_list.h"
  7. #include "base/test/task_environment.h"
  8. #include "testing/gmock/include/gmock/gmock.h"
  9. #include "testing/gtest/include/gtest/gtest.h"
  10. namespace exo {
  11. namespace {
  12. constexpr int64_t kDurationMillis = 0x8000;
  13. constexpr base::TimeDelta kPendingTaskDuration =
  14. base::Milliseconds(kDurationMillis);
  15. constexpr base::TimeDelta kPendingMaxTaskDuration =
  16. base::Milliseconds(kMaxDurationMillis);
  17. constexpr uint8_t kAmplitude = 128;
  18. class TestGamepad : public Gamepad {
  19. public:
  20. TestGamepad(const ui::GamepadDevice& device)
  21. : Gamepad(device),
  22. send_vibrate_count_(0),
  23. send_cancel_vibration_count_(0) {}
  24. TestGamepad(const TestGamepad&) = delete;
  25. TestGamepad& operator=(const TestGamepad& other) = delete;
  26. void SendVibrate(uint8_t amplitude, int64_t duration_millis) override {
  27. send_vibrate_count_++;
  28. last_vibrate_amplitude_ = amplitude;
  29. last_vibrate_duration_ = duration_millis;
  30. }
  31. void SendCancelVibration() override { send_cancel_vibration_count_++; }
  32. uint8_t last_vibrate_amplitude_;
  33. int64_t last_vibrate_duration_;
  34. int send_vibrate_count_;
  35. int send_cancel_vibration_count_;
  36. };
  37. class MockGamepadObserver : public GamepadObserver {
  38. public:
  39. MockGamepadObserver() {}
  40. // Overridden from GamepadObserver:
  41. MOCK_METHOD(void, OnGamepadDestroying, (Gamepad * gamepad), (override));
  42. };
  43. class MockGamepadDelegate : public GamepadDelegate {
  44. public:
  45. MockGamepadDelegate() {}
  46. // Overridden from GamepadDelegate:
  47. MOCK_METHOD(void, OnRemoved, (), (override));
  48. MOCK_METHOD(void,
  49. OnAxis,
  50. (int axis, double value, base::TimeTicks timestamp),
  51. (override));
  52. MOCK_METHOD(void,
  53. OnButton,
  54. (int button, bool pressed, base::TimeTicks timestamp),
  55. (override));
  56. MOCK_METHOD(void, OnFrame, (base::TimeTicks timestamp), (override));
  57. };
  58. class GamepadTest : public testing::Test {
  59. public:
  60. GamepadTest() {
  61. ui::GamepadDevice device(
  62. ui::InputDevice(0, ui::InputDeviceType::INPUT_DEVICE_USB, "gamepad"),
  63. std::vector<ui::GamepadDevice::Axis>(), true);
  64. gamepad_ = std::make_unique<TestGamepad>(device);
  65. }
  66. GamepadTest(const GamepadTest&) = delete;
  67. GamepadTest& operator=(const GamepadTest&) = delete;
  68. void SetUp() override {
  69. testing::Test::SetUp();
  70. // Allow test to signal to gamepad that it can vibrate.
  71. scoped_feature_list_.InitAndEnableFeature(
  72. chromeos::features::kGamepadVibration);
  73. gamepad_->OnGamepadFocused();
  74. }
  75. std::unique_ptr<TestGamepad> gamepad_;
  76. base::test::TaskEnvironment task_environment_{
  77. base::test::TaskEnvironment::TimeSource::MOCK_TIME};
  78. base::test::ScopedFeatureList scoped_feature_list_;
  79. };
  80. TEST_F(GamepadTest, OneShotVibrationTest) {
  81. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  82. EXPECT_EQ(0, gamepad_->send_cancel_vibration_count_);
  83. gamepad_->Vibrate({kDurationMillis}, {kAmplitude}, -1);
  84. task_environment_.FastForwardBy(base::Milliseconds(kDurationMillis / 2));
  85. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  86. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  87. EXPECT_EQ(kDurationMillis, gamepad_->last_vibrate_duration_);
  88. // Cancel vibration when it's halfway through.
  89. gamepad_->CancelVibration();
  90. EXPECT_EQ(1, gamepad_->send_cancel_vibration_count_);
  91. }
  92. TEST_F(GamepadTest, OneShotVibrationTooLongTest) {
  93. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  94. gamepad_->Vibrate({kMaxDurationMillis * 3}, {kAmplitude}, -1);
  95. task_environment_.RunUntilIdle();
  96. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  97. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  98. EXPECT_EQ(kMaxDurationMillis, gamepad_->last_vibrate_duration_);
  99. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  100. task_environment_.FastForwardBy(kPendingMaxTaskDuration);
  101. EXPECT_EQ(2, gamepad_->send_vibrate_count_);
  102. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  103. EXPECT_EQ(kMaxDurationMillis, gamepad_->last_vibrate_duration_);
  104. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  105. task_environment_.FastForwardBy(kPendingMaxTaskDuration);
  106. EXPECT_EQ(3, gamepad_->send_vibrate_count_);
  107. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  108. EXPECT_EQ(kMaxDurationMillis, gamepad_->last_vibrate_duration_);
  109. // Complete the last vibration and make sure no more vibration is scheduled.
  110. task_environment_.FastForwardBy(kPendingMaxTaskDuration);
  111. EXPECT_FALSE(task_environment_.NextTaskIsDelayed());
  112. }
  113. TEST_F(GamepadTest, WaveformVibrationTest) {
  114. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  115. gamepad_->Vibrate({kDurationMillis, kDurationMillis}, {kAmplitude, 0}, -1);
  116. task_environment_.RunUntilIdle();
  117. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  118. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  119. EXPECT_EQ(kDurationMillis, gamepad_->last_vibrate_duration_);
  120. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  121. task_environment_.FastForwardBy(kPendingTaskDuration);
  122. EXPECT_EQ(2, gamepad_->send_vibrate_count_);
  123. EXPECT_EQ(0, gamepad_->last_vibrate_amplitude_);
  124. EXPECT_EQ(kDurationMillis, gamepad_->last_vibrate_duration_);
  125. // Complete the last vibration and make sure no more vibration is scheduled.
  126. task_environment_.FastForwardBy(kPendingTaskDuration);
  127. EXPECT_FALSE(task_environment_.NextTaskIsDelayed());
  128. }
  129. TEST_F(GamepadTest, VibrationWithRepeatTest) {
  130. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  131. EXPECT_EQ(0, gamepad_->send_cancel_vibration_count_);
  132. gamepad_->Vibrate({kMaxDurationMillis, kDurationMillis}, {kAmplitude, 0}, 0);
  133. task_environment_.RunUntilIdle();
  134. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  135. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  136. EXPECT_EQ(kMaxDurationMillis, gamepad_->last_vibrate_duration_);
  137. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  138. task_environment_.FastForwardBy(kPendingMaxTaskDuration);
  139. EXPECT_EQ(2, gamepad_->send_vibrate_count_);
  140. EXPECT_EQ(0, gamepad_->last_vibrate_amplitude_);
  141. EXPECT_EQ(kDurationMillis, gamepad_->last_vibrate_duration_);
  142. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  143. task_environment_.FastForwardBy(kPendingTaskDuration);
  144. EXPECT_EQ(3, gamepad_->send_vibrate_count_);
  145. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  146. EXPECT_EQ(kMaxDurationMillis, gamepad_->last_vibrate_duration_);
  147. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  148. task_environment_.FastForwardBy(kPendingTaskDuration);
  149. gamepad_->CancelVibration();
  150. EXPECT_EQ(1, gamepad_->send_cancel_vibration_count_);
  151. EXPECT_EQ(3, gamepad_->send_vibrate_count_);
  152. }
  153. TEST_F(GamepadTest, OverrideVibrationTest) {
  154. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  155. gamepad_->Vibrate({kDurationMillis, kDurationMillis}, {kAmplitude, 0}, -1);
  156. task_environment_.RunUntilIdle();
  157. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  158. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  159. EXPECT_EQ(kDurationMillis, gamepad_->last_vibrate_duration_);
  160. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  161. task_environment_.FastForwardBy(kPendingTaskDuration / 2);
  162. // At this point, we're halfway through the first OneShot vibration in the
  163. // duration vector.
  164. gamepad_->Vibrate({kMaxDurationMillis}, {kAmplitude / 2}, -1);
  165. task_environment_.RunUntilIdle();
  166. EXPECT_EQ(2, gamepad_->send_vibrate_count_);
  167. EXPECT_EQ(kAmplitude / 2, gamepad_->last_vibrate_amplitude_);
  168. EXPECT_EQ(kMaxDurationMillis, gamepad_->last_vibrate_duration_);
  169. // Make sure that the remaining vibration from the first call is no longer in
  170. // the queue.
  171. task_environment_.FastForwardBy(kPendingMaxTaskDuration);
  172. EXPECT_FALSE(task_environment_.NextTaskIsDelayed());
  173. // Verify that no extra vibration calls were made.
  174. EXPECT_EQ(2, gamepad_->send_vibrate_count_);
  175. }
  176. TEST_F(GamepadTest, NoFocusTest) {
  177. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  178. gamepad_->OnGamepadFocusLost();
  179. gamepad_->Vibrate({kDurationMillis}, {kAmplitude}, -1);
  180. task_environment_.RunUntilIdle();
  181. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  182. }
  183. TEST_F(GamepadTest, FocusLostTest) {
  184. EXPECT_EQ(0, gamepad_->send_vibrate_count_);
  185. EXPECT_EQ(0, gamepad_->send_cancel_vibration_count_);
  186. gamepad_->Vibrate({kDurationMillis, kDurationMillis}, {kAmplitude, 0}, -1);
  187. task_environment_.RunUntilIdle();
  188. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  189. EXPECT_EQ(kAmplitude, gamepad_->last_vibrate_amplitude_);
  190. EXPECT_EQ(kDurationMillis, gamepad_->last_vibrate_duration_);
  191. EXPECT_TRUE(task_environment_.NextTaskIsDelayed());
  192. gamepad_->OnGamepadFocusLost();
  193. task_environment_.FastForwardBy(kPendingTaskDuration);
  194. // When focus is lost, CancelVibration is sent, and no more vibration can be
  195. // scheduled.
  196. EXPECT_EQ(1, gamepad_->send_cancel_vibration_count_);
  197. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  198. // While focus is not regained, gamepad cannot vibrate.
  199. gamepad_->Vibrate({kDurationMillis}, {kAmplitude}, -1);
  200. task_environment_.RunUntilIdle();
  201. EXPECT_EQ(1, gamepad_->send_vibrate_count_);
  202. // If focus is regained, gamepad can vibrate again.
  203. gamepad_->OnGamepadFocused();
  204. gamepad_->Vibrate({kDurationMillis / 2}, {kAmplitude / 2}, -1);
  205. task_environment_.RunUntilIdle();
  206. EXPECT_EQ(2, gamepad_->send_vibrate_count_);
  207. EXPECT_EQ(kAmplitude / 2, gamepad_->last_vibrate_amplitude_);
  208. EXPECT_EQ(kDurationMillis / 2, gamepad_->last_vibrate_duration_);
  209. }
  210. TEST_F(GamepadTest, GamepadObserverTest) {
  211. MockGamepadObserver observer1;
  212. MockGamepadObserver observer2;
  213. gamepad_->AddObserver(&observer1);
  214. gamepad_->AddObserver(&observer2);
  215. EXPECT_TRUE(gamepad_->HasObserver(&observer1));
  216. EXPECT_TRUE(gamepad_->HasObserver(&observer2));
  217. gamepad_->RemoveObserver(&observer1);
  218. EXPECT_FALSE(gamepad_->HasObserver(&observer1));
  219. EXPECT_TRUE(gamepad_->HasObserver(&observer2));
  220. EXPECT_CALL(observer1, OnGamepadDestroying(gamepad_.get())).Times(0);
  221. EXPECT_CALL(observer2, OnGamepadDestroying(gamepad_.get()));
  222. gamepad_.reset();
  223. }
  224. TEST_F(GamepadTest, GamepadDelegateTest) {
  225. auto delegate = std::make_unique<MockGamepadDelegate>();
  226. EXPECT_CALL(*delegate, OnRemoved()).Times(1);
  227. gamepad_->SetDelegate(std::move(delegate));
  228. gamepad_.reset();
  229. }
  230. TEST_F(GamepadTest, OnGamepadEventTest) {
  231. constexpr int gamepad_id = 0;
  232. constexpr uint16_t code = 310;
  233. constexpr double value = 1;
  234. base::TimeTicks expected_time = base::TimeTicks::Now();
  235. auto delegate = std::make_unique<MockGamepadDelegate>();
  236. EXPECT_CALL(*delegate, OnButton(code, value, expected_time)).Times(1);
  237. EXPECT_CALL(*delegate, OnAxis(code, value, expected_time)).Times(1);
  238. EXPECT_CALL(*delegate, OnFrame(expected_time)).Times(1);
  239. EXPECT_CALL(*delegate, OnRemoved()).Times(1);
  240. gamepad_->SetDelegate(std::move(delegate));
  241. gamepad_->OnGamepadEvent(ui::GamepadEvent(
  242. gamepad_id, ui::GamepadEventType::BUTTON, code, value, expected_time));
  243. gamepad_->OnGamepadEvent(ui::GamepadEvent(
  244. gamepad_id, ui::GamepadEventType::AXIS, code, value, expected_time));
  245. gamepad_->OnGamepadEvent(ui::GamepadEvent(
  246. gamepad_id, ui::GamepadEventType::FRAME, code, value, expected_time));
  247. gamepad_.reset();
  248. }
  249. TEST_F(GamepadTest, GamepadDestroyedTest) {
  250. MockGamepadObserver observer1;
  251. MockGamepadObserver observer2;
  252. gamepad_->AddObserver(&observer1);
  253. gamepad_->AddObserver(&observer2);
  254. EXPECT_TRUE(gamepad_->HasObserver(&observer1));
  255. EXPECT_TRUE(gamepad_->HasObserver(&observer2));
  256. auto delegate = std::make_unique<MockGamepadDelegate>();
  257. EXPECT_CALL(*delegate, OnRemoved()).Times(1);
  258. gamepad_->SetDelegate(std::move(delegate));
  259. EXPECT_CALL(observer1, OnGamepadDestroying(gamepad_.get())).Times(1);
  260. EXPECT_CALL(observer2, OnGamepadDestroying(gamepad_.get())).Times(1);
  261. gamepad_.reset();
  262. }
  263. } // namespace
  264. } // namespace exo