1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include "input_active_subscriber_handler.h" 18 #include "key_gesture_manager.h" 19 20 #undef MMI_LOG_TAG 21 #define MMI_LOG_TAG "InputActiveSubscriberHandlerTest" 22 23 namespace OHOS { 24 namespace MMI { 25 namespace { 26 using namespace testing::ext; 27 } // namespace 28 29 class InputActiveSubscriberHandlerTest : public testing::Test { 30 public: SetUpTestCase(void)31 static void SetUpTestCase(void) {} TearDownTestCase(void)32 static void TearDownTestCase(void) {} 33 }; 34 35 /** 36 * @tc.name: InputActiveSubscriberHandlerTest_SubscribeInputActive_001 37 * @tc.desc: Verify SubscribeInputActive 38 * @tc.type: FUNC 39 * @tc.require: 40 */ 41 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_SubscribeInputActive_001, TestSize.Level1) 42 { 43 InputActiveSubscriberHandler handler; 44 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 45 ASSERT_NE(session, nullptr); 46 auto ret = handler.SubscribeInputActive(session, -1, 500); 47 EXPECT_NE(ret, RET_OK); 48 int32_t subscribeId = 0; 49 ret = handler.SubscribeInputActive(session, subscribeId, 500); 50 EXPECT_EQ(ret, RET_OK); 51 ret = handler.UnsubscribeInputActive(session, subscribeId); 52 EXPECT_EQ(ret, RET_OK); 53 subscribeId = 1; 54 ret = handler.SubscribeInputActive(session, subscribeId, 500); 55 EXPECT_EQ(ret, RET_OK); 56 ret = handler.UnsubscribeInputActive(session, subscribeId); 57 EXPECT_EQ(ret, RET_OK); 58 } 59 60 /** 61 * @tc.name: InputActiveSubscriberHandlerTest_UnsubscribeInputActive_001 62 * @tc.desc: Verify UnsubscribeInputActive 63 * @tc.type: FUNC 64 * @tc.require: 65 */ 66 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_UnsubscribeInputActive_001, TestSize.Level1) 67 { 68 InputActiveSubscriberHandler handler; 69 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 70 ASSERT_NE(session, nullptr); 71 auto ret = handler.SubscribeInputActive(session, -1, 500); 72 EXPECT_NE(ret, RET_OK); 73 int32_t subscribeId = 1; 74 ret = handler.SubscribeInputActive(session, subscribeId, 500); 75 EXPECT_EQ(ret, RET_OK); 76 subscribeId = 2; 77 ret = handler.UnsubscribeInputActive(session, subscribeId); 78 EXPECT_NE(ret, RET_OK); 79 } 80 81 /** 82 * @tc.name: InputActiveSubscriberHandlerTest_OnSubscribeInputActive_001 83 * @tc.desc: Verify OnSubscribeInputActive 84 * @tc.type: FUNC 85 * @tc.require: 86 */ 87 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_OnSubscribeInputActive_001, TestSize.Level1) 88 { 89 InputActiveSubscriberHandler handler; 90 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 91 ASSERT_NE(keyEvent, nullptr); 92 handler.HandleKeyEvent(keyEvent); 93 #ifdef OHOS_BUILD_ENABLE_SWITCH 94 handler.HandleSwitchEvent(nullptr); 95 #endif 96 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 97 ASSERT_NE(session, nullptr); 98 int32_t subscribeId = 0; 99 auto ret = handler.SubscribeInputActive(session, subscribeId, 500); 100 EXPECT_EQ(ret, RET_OK); 101 handler.subscribers_.push_back(nullptr); 102 handler.OnSubscribeInputActive(keyEvent); 103 handler.OnSubscribeInputActive(keyEvent); 104 } 105 106 /** 107 * @tc.name: InputActiveSubscriberHandlerTest_OnSubscribeInputActive_002 108 * @tc.desc: Verify OnSubscribeInputActive 109 * @tc.type: FUNC 110 * @tc.require: 111 */ 112 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_OnSubscribeInputActive_002, TestSize.Level1) 113 { 114 InputActiveSubscriberHandler handler; 115 std::shared_ptr<PointerEvent> pointerEvent = 116 std::make_shared<PointerEvent>(PointerEvent::POINTER_ACTION_PROXIMITY_IN); 117 ASSERT_NE(pointerEvent, nullptr); 118 handler.HandlePointerEvent(pointerEvent); 119 handler.HandleTouchEvent(pointerEvent); 120 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 121 ASSERT_NE(session, nullptr); 122 int32_t subscribeId = 0; 123 auto ret = handler.SubscribeInputActive(session, subscribeId, 500); 124 EXPECT_EQ(ret, RET_OK); 125 handler.subscribers_.push_back(nullptr); 126 handler.OnSubscribeInputActive(pointerEvent); 127 handler.OnSubscribeInputActive(pointerEvent); 128 } 129 130 /** 131 * @tc.name: InputActiveSubscriberHandlerTest_IsImmediateNotifySubscriber_001 132 * @tc.desc: Verify IsImmediateNotifySubscriber 133 * @tc.type: FUNC 134 * @tc.require: 135 */ 136 HWTEST_F(InputActiveSubscriberHandlerTest, 137 InputActiveSubscriberHandlerTest_IsImmediateNotifySubscriber_001, TestSize.Level1) 138 { 139 InputActiveSubscriberHandler handler; 140 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 141 ASSERT_NE(session, nullptr); 142 std::shared_ptr<InputActiveSubscriberHandler::Subscriber> subscriber = 143 std::make_shared<InputActiveSubscriberHandler::Subscriber>(0, session, 0); 144 ASSERT_NE(subscriber, nullptr); 145 int64_t currentTime = 0; 146 bool result = handler.IsImmediateNotifySubscriber(subscriber, currentTime); 147 EXPECT_EQ(result, true); 148 subscriber->sendEventLastTime_ = 0; 149 subscriber->interval_ = 500; 150 result = handler.IsImmediateNotifySubscriber(subscriber, currentTime); 151 EXPECT_EQ(result, true); 152 currentTime = 300; 153 subscriber->sendEventLastTime_ = 500; 154 result = handler.IsImmediateNotifySubscriber(subscriber, currentTime); 155 EXPECT_EQ(result, true); 156 EXPECT_EQ(subscriber->sendEventLastTime_, 0); 157 currentTime = 1200; 158 subscriber->sendEventLastTime_ = 500; 159 result = handler.IsImmediateNotifySubscriber(subscriber, currentTime); 160 EXPECT_EQ(result, true); 161 currentTime = 800; 162 subscriber->sendEventLastTime_ = 500; 163 result = handler.IsImmediateNotifySubscriber(subscriber, currentTime); 164 EXPECT_EQ(result, false); 165 } 166 167 /** 168 * @tc.name: InputActiveSubscriberHandlerTest_InsertSubscriber_001 169 * @tc.desc: Verify InsertSubscriber 170 * @tc.type: FUNC 171 * @tc.require: 172 */ 173 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_InsertSubscriber_001, TestSize.Level1) 174 { 175 InputActiveSubscriberHandler handler; 176 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 177 ASSERT_NE(session, nullptr); 178 std::shared_ptr<InputActiveSubscriberHandler::Subscriber> subscriber = 179 std::make_shared<InputActiveSubscriberHandler::Subscriber>(0, session, 0); 180 ASSERT_NE(subscriber, nullptr); 181 handler.InsertSubscriber(subscriber); 182 handler.InsertSubscriber(subscriber); 183 session = std::make_shared<UDSSession>("test_program1", 2, 124, 3000, 4000); 184 ASSERT_NE(session, nullptr); 185 subscriber = std::make_shared<InputActiveSubscriberHandler::Subscriber>(1, session, 0); 186 ASSERT_NE(subscriber, nullptr); 187 handler.InsertSubscriber(subscriber); 188 subscriber = std::make_shared<InputActiveSubscriberHandler::Subscriber>(1, nullptr, 0); 189 ASSERT_NE(subscriber, nullptr); 190 handler.InsertSubscriber(subscriber); 191 std::vector<std::string> args; 192 handler.Dump(1, args); 193 handler.OnSessionDelete(session); 194 handler.callbackInitialized_ = true; 195 handler.InitSessionDeleteCallback(); 196 handler.callbackInitialized_ = false; 197 } 198 199 /** 200 * @tc.name: InputActiveSubscriberHandlerTest_StartIntervalTimer_001 201 * @tc.desc: Verify StartIntervalTimer 202 * @tc.type: FUNC 203 * @tc.require: 204 */ 205 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_StartIntervalTimer_001, TestSize.Level1) 206 { 207 InputActiveSubscriberHandler handler; 208 std::shared_ptr<PointerEvent> pointerEvent = 209 std::make_shared<PointerEvent>(PointerEvent::POINTER_ACTION_PROXIMITY_IN); 210 ASSERT_NE(pointerEvent, nullptr); 211 handler.HandlePointerEvent(pointerEvent); 212 handler.HandleTouchEvent(pointerEvent); 213 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 214 ASSERT_NE(session, nullptr); 215 std::shared_ptr<InputActiveSubscriberHandler::Subscriber> subscriber = 216 std::make_shared<InputActiveSubscriberHandler::Subscriber>(0, session, 500); 217 ASSERT_NE(subscriber, nullptr); 218 subscriber->sendEventLastTime_ = 401; 219 subscriber->lastEventType_ = InputActiveSubscriberHandler::EVENTTYPE_POINTER; 220 subscriber->pointerEvent_ = pointerEvent; 221 int64_t currTime = 880; 222 handler.StartIntervalTimer(subscriber, currTime); 223 std::this_thread::sleep_for(std::chrono::milliseconds(50)); 224 subscriber->lastEventType_ = InputActiveSubscriberHandler::EVENTTYPE_KEY; 225 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 226 ASSERT_NE(keyEvent, nullptr); 227 subscriber->keyEvent_ = keyEvent; 228 handler.StartIntervalTimer(subscriber, currTime); 229 handler.CleanSubscribeInfo(subscriber, currTime); 230 std::this_thread::sleep_for(std::chrono::milliseconds(50)); 231 } 232 233 /** 234 * @tc.name: InputActiveSubscriberHandlerTest_NotifySubscriber_001 235 * @tc.desc: Verify NotifySubscriber 236 * @tc.type: FUNC 237 * @tc.require: 238 */ 239 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_NotifySubscriber_001, TestSize.Level1) 240 { 241 InputActiveSubscriberHandler handler; 242 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 243 ASSERT_NE(session, nullptr); 244 std::shared_ptr<InputActiveSubscriberHandler::Subscriber> subscriber = 245 std::make_shared<InputActiveSubscriberHandler::Subscriber>(0, nullptr, 0); 246 ASSERT_NE(subscriber, nullptr); 247 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 248 ASSERT_NE(keyEvent, nullptr); 249 handler.NotifySubscriber(keyEvent, subscriber); 250 std::shared_ptr<PointerEvent> pointerEvent = 251 std::make_shared<PointerEvent>(PointerEvent::POINTER_ACTION_PROXIMITY_IN); 252 ASSERT_NE(pointerEvent, nullptr); 253 handler.NotifySubscriber(pointerEvent, subscriber); 254 } 255 256 /** 257 * @tc.name: InputActiveSubscriberHandlerTest_SubscribeInputActive_002 258 * @tc.desc: Verify SubscribeInputActive 259 * @tc.type: FUNC 260 * @tc.require: 261 */ 262 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_SubscribeInputActive_002, TestSize.Level1) 263 { 264 InputActiveSubscriberHandler handler; 265 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 266 auto session2 = std::make_shared<UDSSession>("test_program2", 1, 123, 1000, 2000); 267 auto session3 = std::make_shared<UDSSession>("test_program3", 1, 123, 1000, 2000); 268 auto session4 = std::make_shared<UDSSession>("test_program4", 1, 123, 1000, 2000); 269 ASSERT_NE(session, nullptr); 270 ASSERT_NE(session2, nullptr); 271 ASSERT_NE(session3, nullptr); 272 ASSERT_NE(session4, nullptr); 273 auto ret = handler.SubscribeInputActive(session, -1, 500); 274 EXPECT_NE(ret, RET_OK); 275 int32_t subscribeId = 0; 276 ret = handler.SubscribeInputActive(session, subscribeId, 500); 277 EXPECT_EQ(ret, RET_OK); 278 handler.SubscribeInputActive(session, subscribeId, 500); 279 handler.SubscribeInputActive(session, subscribeId + 1, 500); 280 handler.SubscribeInputActive(session2, subscribeId, 500); 281 handler.SubscribeInputActive(session2, subscribeId + 1, 500); 282 handler.SubscribeInputActive(session2, subscribeId + 2, -1); 283 handler.SubscribeInputActive(nullptr, subscribeId, 500); 284 handler.subscribers_.push_back(nullptr); 285 handler.SubscribeInputActive(session4, subscribeId, 500); 286 handler.subscribers_.back()->sess_ = nullptr; 287 std::vector<std::string> args; 288 handler.Dump(1, args); 289 290 int32_t size = handler.subscribers_.size(); 291 EXPECT_NE(size, 0); 292 ret = handler.UnsubscribeInputActive(session, subscribeId); 293 EXPECT_EQ(handler.subscribers_.size(), size - 1); 294 ret = handler.UnsubscribeInputActive(session3, subscribeId); 295 EXPECT_EQ(handler.subscribers_.size(), size - 1); 296 ret = handler.UnsubscribeInputActive(session, subscribeId + 1); 297 EXPECT_EQ(handler.subscribers_.size(), size - 2); 298 ret = handler.UnsubscribeInputActive(session2, subscribeId); 299 EXPECT_EQ(handler.subscribers_.size(), size - 3); 300 ret = handler.UnsubscribeInputActive(session2, subscribeId + 1); 301 EXPECT_EQ(handler.subscribers_.size(), size - 4); 302 303 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 304 ASSERT_NE(keyEvent, nullptr); 305 handler.HandleKeyEvent(keyEvent); 306 handler.SubscribeInputActive(session, subscribeId, -1); 307 handler.subscribers_.push_back(nullptr); 308 EXPECT_NO_FATAL_FAILURE(handler.OnSubscribeInputActive(keyEvent)); 309 std::shared_ptr<PointerEvent> pointerEvent = 310 std::make_shared<PointerEvent>(PointerEvent::POINTER_ACTION_PROXIMITY_IN); 311 ASSERT_NE(pointerEvent, nullptr); 312 EXPECT_NO_FATAL_FAILURE(handler.OnSubscribeInputActive(pointerEvent)); 313 } 314 315 /** 316 * @tc.name: InputActiveSubscriberHandlerTest_OnSessionDelete_001 317 * @tc.desc: Verify OnSessionDelete 318 * @tc.type: FUNC 319 * @tc.require: 320 */ 321 HWTEST_F(InputActiveSubscriberHandlerTest, InputActiveSubscriberHandlerTest_OnSessionDelete_001, TestSize.Level1) 322 { 323 InputActiveSubscriberHandler handler; 324 auto session = std::make_shared<UDSSession>("test_program", 1, 123, 1000, 2000); 325 auto session2 = std::make_shared<UDSSession>("test_program2", 1, 123, 1000, 2000); 326 ASSERT_NE(session, nullptr); 327 ASSERT_NE(session2, nullptr); 328 int32_t subscribeId = 0; 329 handler.SubscribeInputActive(session, subscribeId, 500); 330 EXPECT_EQ(handler.subscribers_.size(), 1); 331 handler.OnSessionDelete(session); 332 EXPECT_EQ(handler.subscribers_.size(), 0); 333 handler.SubscribeInputActive(session, subscribeId, 500); 334 handler.subscribers_.push_back(nullptr); 335 EXPECT_EQ(handler.subscribers_.size(), 2); 336 handler.OnSessionDelete(session2); 337 EXPECT_EQ(handler.subscribers_.size(), 2); 338 handler.callbackInitialized_ = true; 339 auto ret = handler.InitSessionDeleteCallback(); 340 EXPECT_TRUE(ret); 341 } 342 343 /** 344 * @tc.name: InputActiveSubscriberHandlerTest 345 * @tc.desc: Test the funcation ResetTimer 346 * @tc.type: FUNC 347 * @tc.require: 348 */ 349 HWTEST_F(InputActiveSubscriberHandlerTest, KeyGestureManagerTest_ResetTimer, TestSize.Level1) 350 { 351 CALL_TEST_DEBUG; 352 KeyGestureManager::Handler handler(1, 2, 3000, nullptr); 353 handler.timerId_ = -1; 354 ASSERT_NO_FATAL_FAILURE(handler.ResetTimer()); 355 handler.timerId_ = 0; 356 ASSERT_NO_FATAL_FAILURE(handler.ResetTimer()); 357 } 358 359 /** 360 * @tc.name: KeyGestureManagerTest_Trigger 361 * @tc.desc: Test the funcation Trigger 362 * @tc.type: FUNC 363 * @tc.require: 364 */ 365 HWTEST_F(InputActiveSubscriberHandlerTest, KeyGestureManagerTest_Trigger, TestSize.Level1) 366 { 367 CALL_TEST_DEBUG; 368 KeyGestureManager::Handler handler(1, 2, 3000, nullptr); 369 handler.timerId_ = -1; 370 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 371 ASSERT_NO_FATAL_FAILURE(handler.Trigger(keyEvent)); 372 handler.timerId_ = 0; 373 ASSERT_NO_FATAL_FAILURE(handler.Trigger(keyEvent)); 374 } 375 376 /** 377 * @tc.name: KeyGestureManagerTest_Run 378 * @tc.desc: Test the funcation Run 379 * @tc.type: FUNC 380 * @tc.require: 381 */ 382 HWTEST_F(InputActiveSubscriberHandlerTest, KeyGestureManagerTest_Run, TestSize.Level1) 383 { 384 CALL_TEST_DEBUG; 385 KeyGestureManager::Handler handler(1, 2, 3000, nullptr); 386 handler.keyEvent_ = nullptr; 387 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 388 ASSERT_NO_FATAL_FAILURE(handler.Run(keyEvent)); 389 ASSERT_NO_FATAL_FAILURE(handler.RunPending()); 390 std::function<void(std::shared_ptr<KeyEvent>)> myCallback; 391 handler.callback_ = myCallback; 392 handler.keyEvent_ = keyEvent; 393 ASSERT_NO_FATAL_FAILURE(handler.Run(keyEvent)); 394 ASSERT_NO_FATAL_FAILURE(handler.RunPending()); 395 } 396 } // namespace MMI 397 } // namespace OHOS