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_subscribe_manager.h" 18 #include "input_handler_type.h" 19 #include "mmi_log.h" 20 #include "multimodal_event_handler.h" 21 #include "multimodal_input_connect_manager.h" 22 23 #undef MMI_LOG_TAG 24 #define MMI_LOG_TAG "InputActiveSubscribeManagerTest" 25 26 namespace OHOS { 27 namespace MMI { 28 namespace { 29 using namespace testing::ext; 30 } // namespace 31 32 class InputActiveSubscribeManagerTest : public testing::Test { 33 public: SetUpTestCase(void)34 static void SetUpTestCase(void) {} TearDownTestCase(void)35 static void TearDownTestCase(void) {} 36 }; 37 38 class TestInputEventConsumer : public IInputEventConsumer { 39 public: 40 TestInputEventConsumer() = default; 41 ~TestInputEventConsumer() = default; OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const42 void OnInputEvent(std::shared_ptr<KeyEvent> keyEvent) const override 43 { 44 MMI_HILOGI("OnInputEvent KeyEvent enter"); 45 } OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const46 void OnInputEvent(std::shared_ptr<PointerEvent> pointerEvent) const override 47 { 48 MMI_HILOGI("OnInputEvent PointerEvent enter"); 49 } OnInputEvent(std::shared_ptr<AxisEvent> axisEvent) const50 void OnInputEvent(std::shared_ptr<AxisEvent> axisEvent) const override 51 {} 52 }; 53 54 /** 55 * @tc.name: SubscribeInputActive_Test_001 56 * @tc.desc: Test SubscribeInputActive 57 * @tc.type: FUNC 58 * @tc.require: 59 */ 60 HWTEST_F(InputActiveSubscribeManagerTest, SubscribeInputActive_Test_001, TestSize.Level1) 61 { 62 CALL_TEST_DEBUG; 63 std::shared_ptr<TestInputEventConsumer> inputEventConsumer = std::make_shared<TestInputEventConsumer>(); 64 EXPECT_NE(inputEventConsumer, nullptr); 65 int64_t interval = 500; // ms 66 int32_t subscriberId = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive( 67 std::static_pointer_cast<IInputEventConsumer>(inputEventConsumer), interval); 68 EXPECT_GE(subscriberId, 0); 69 int32_t subscriberId1 = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive( 70 std::static_pointer_cast<IInputEventConsumer>(inputEventConsumer), interval); 71 EXPECT_LT(subscriberId1, 0); 72 int32_t result = INPUT_ACTIVE_SUBSCRIBE_MGR.UnsubscribeInputActive(subscriberId); 73 EXPECT_EQ(result, RET_OK); 74 result = INPUT_ACTIVE_SUBSCRIBE_MGR.UnsubscribeInputActive(subscriberId); 75 EXPECT_NE(result, RET_OK); 76 } 77 78 /** 79 * @tc.name: SubscribeInputActive_Test_002 80 * @tc.desc: Test SubscribeInputActive 81 * @tc.type: FUNC 82 * @tc.require: 83 */ 84 HWTEST_F(InputActiveSubscribeManagerTest, SubscribeInputActive_Test_002, TestSize.Level1) 85 { 86 CALL_TEST_DEBUG; 87 int64_t interval = 500; // ms 88 int32_t subscriberInput = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive(nullptr, interval); 89 EXPECT_LT(subscriberInput, 0); 90 subscriberInput = 2; 91 int32_t result = INPUT_ACTIVE_SUBSCRIBE_MGR.UnsubscribeInputActive(subscriberInput); 92 EXPECT_NE(result, RET_OK); 93 } 94 95 /** 96 * @tc.name: OnSubscribeInputActiveCallback_Test_001 97 * @tc.desc: Test OnSubscribeInputActiveCallback 98 * @tc.type: FUNC 99 * @tc.require: 100 */ 101 HWTEST_F(InputActiveSubscribeManagerTest, OnSubscribeInputActiveCallback_Test_001, TestSize.Level1) 102 { 103 CALL_TEST_DEBUG; 104 std::shared_ptr<TestInputEventConsumer> inputEventConsumer = std::make_shared<TestInputEventConsumer>(); 105 EXPECT_NE(inputEventConsumer, nullptr); 106 int64_t interval = 500; // ms 107 int32_t subscriberInput = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive( 108 std::static_pointer_cast<IInputEventConsumer>(inputEventConsumer), interval); 109 EXPECT_GE(subscriberInput, 0); 110 111 std::shared_ptr<KeyEvent> keyEvent = KeyEvent::Create(); 112 ASSERT_NE(keyEvent, nullptr); 113 int32_t result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(keyEvent, subscriberInput); 114 EXPECT_EQ(result, RET_OK); 115 result = INPUT_ACTIVE_SUBSCRIBE_MGR.UnsubscribeInputActive(subscriberInput); 116 EXPECT_EQ(result, RET_OK); 117 result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(keyEvent, subscriberInput); 118 EXPECT_NE(result, RET_OK); 119 } 120 121 /** 122 * @tc.name: OnSubscribeInputActiveCallback_Test_002 123 * @tc.desc: Test OnSubscribeInputActiveCallback 124 * @tc.type: FUNC 125 * @tc.require: 126 */ 127 HWTEST_F(InputActiveSubscribeManagerTest, OnSubscribeInputActiveCallback_Test_002, TestSize.Level1) 128 { 129 CALL_TEST_DEBUG; 130 std::shared_ptr<TestInputEventConsumer> inputEventConsumer = std::make_shared<TestInputEventConsumer>(); 131 EXPECT_NE(inputEventConsumer, nullptr); 132 int64_t interval = 500; // ms 133 int32_t subscriberInput = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive( 134 std::static_pointer_cast<IInputEventConsumer>(inputEventConsumer), interval); 135 EXPECT_GE(subscriberInput, 0); 136 137 auto pointerEvent = PointerEvent::Create(); 138 ASSERT_NE(pointerEvent, nullptr); 139 int32_t result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(pointerEvent, subscriberInput); 140 EXPECT_EQ(result, RET_OK); 141 result = INPUT_ACTIVE_SUBSCRIBE_MGR.UnsubscribeInputActive(subscriberInput); 142 EXPECT_EQ(result, RET_OK); 143 result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(pointerEvent, subscriberInput); 144 EXPECT_NE(result, RET_OK); 145 } 146 147 /** 148 * @tc.name: OnSubscribeInputActiveCallback_Test_003 149 * @tc.desc: Test OnSubscribeInputActiveCallback 150 * @tc.type: FUNC 151 * @tc.require: 152 */ 153 HWTEST_F(InputActiveSubscribeManagerTest, OnSubscribeInputActiveCallback_Test_003, TestSize.Level1) 154 { 155 CALL_TEST_DEBUG; 156 std::shared_ptr<TestInputEventConsumer> inputEventConsumer = std::make_shared<TestInputEventConsumer>(); 157 EXPECT_NE(inputEventConsumer, nullptr); 158 int64_t interval = 500; // ms 159 int32_t subscriberInput = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive( 160 std::static_pointer_cast<IInputEventConsumer>(inputEventConsumer), interval); 161 EXPECT_GE(subscriberInput, 0); 162 163 std::shared_ptr<KeyEvent> keyEvent = nullptr; 164 int32_t result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(keyEvent, subscriberInput); 165 EXPECT_NE(result, RET_OK); 166 keyEvent = KeyEvent::Create(); 167 result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(keyEvent, -1); 168 EXPECT_NE(result, RET_OK); 169 result = INPUT_ACTIVE_SUBSCRIBE_MGR.UnsubscribeInputActive(subscriberInput); 170 EXPECT_EQ(result, RET_OK); 171 } 172 173 /** 174 * @tc.name: OnSubscribeInputActiveCallback_Test_004 175 * @tc.desc: Test OnSubscribeInputActiveCallback 176 * @tc.type: FUNC 177 * @tc.require: 178 */ 179 HWTEST_F(InputActiveSubscribeManagerTest, OnSubscribeInputActiveCallback_Test_004, TestSize.Level1) 180 { 181 CALL_TEST_DEBUG; 182 std::shared_ptr<TestInputEventConsumer> inputEventConsumer = std::make_shared<TestInputEventConsumer>(); 183 EXPECT_NE(inputEventConsumer, nullptr); 184 int64_t interval = 500; // ms 185 int32_t subscriberInput = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive( 186 std::static_pointer_cast<IInputEventConsumer>(inputEventConsumer), interval); 187 EXPECT_GE(subscriberInput, 0); 188 189 std::shared_ptr<PointerEvent> pointerEvent = nullptr; 190 int32_t result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(pointerEvent, subscriberInput); 191 EXPECT_NE(result, RET_OK); 192 pointerEvent = PointerEvent::Create(); 193 result = INPUT_ACTIVE_SUBSCRIBE_MGR.OnSubscribeInputActiveCallback(pointerEvent, -1); 194 EXPECT_NE(result, RET_OK); 195 result = INPUT_ACTIVE_SUBSCRIBE_MGR.UnsubscribeInputActive(subscriberInput); 196 EXPECT_EQ(result, RET_OK); 197 } 198 199 /** 200 * @tc.name: OnConnectedTest 201 * @tc.desc: OnConnected 202 * @tc.type: FUNC 203 * @tc.require: 204 */ 205 HWTEST_F(InputActiveSubscribeManagerTest, OnConnectedTest, TestSize.Level1) 206 { 207 CALL_TEST_DEBUG; 208 INPUT_ACTIVE_SUBSCRIBE_MGR.OnConnected(); 209 std::shared_ptr<TestInputEventConsumer> inputEventConsumer = std::make_shared<TestInputEventConsumer>(); 210 EXPECT_NE(inputEventConsumer, nullptr); 211 int64_t interval = 500; // ms 212 int32_t subscriberInput = INPUT_ACTIVE_SUBSCRIBE_MGR.SubscribeInputActive( 213 std::static_pointer_cast<IInputEventConsumer>(inputEventConsumer), interval); 214 EXPECT_GE(subscriberInput, 0); 215 INPUT_ACTIVE_SUBSCRIBE_MGR.OnConnected(); 216 } 217 } // namespace MMI 218 } // namespace OHOS