1 /* 2 * Copyright (c) 2024 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 18 #include "error_multimodal.h" 19 #include "event_log_helper.h" 20 #include "input_manager_impl.h" 21 #include "switch_event_input_subscribe_manager.h" 22 #include "multimodal_input_connect_manager.h" 23 24 #undef MMI_LOG_TAG 25 #define MMI_LOG_TAG "SwitchEventInputSubscribeManagerTest" 26 27 namespace OHOS { 28 namespace MMI { 29 namespace { 30 using namespace testing::ext; 31 constexpr int32_t INVAID_VALUE { -1 }; 32 constexpr int32_t SUBSCRIBER_ID { 0 }; 33 constexpr int32_t MIN_SUBSCRIBER_ID { 0 }; 34 } // namespace 35 36 class SwitchEventInputSubscribeManagerTest : public testing::Test { 37 public: SetUpTestCase(void)38 static void SetUpTestCase(void) {} TearDownTestCase(void)39 static void TearDownTestCase(void) {} 40 }; 41 42 class MyEventFilter : public IRemoteStub<IEventFilter> { 43 public: HandleKeyEvent(const std::shared_ptr<KeyEvent> & event,bool & resultValue)44 ErrCode HandleKeyEvent(const std::shared_ptr<KeyEvent>& event, bool &resultValue) override 45 { 46 resultValue = true; 47 return ERR_OK; 48 } HandlePointerEvent(const std::shared_ptr<PointerEvent> & event,bool & resultValue)49 ErrCode HandlePointerEvent(const std::shared_ptr<PointerEvent>& event, bool &resultValue) override 50 { 51 resultValue = true; 52 return ERR_OK; 53 } 54 }; 55 56 /** 57 * @tc.name: SwitchEventInputSubscribeManagerTest_SubscribeSwitchEvent_001 58 * @tc.desc: Verify SubscribeSwitchEvent 59 * @tc.type: FUNC 60 * @tc.require: 61 */ 62 HWTEST_F(SwitchEventInputSubscribeManagerTest, 63 SwitchEventInputSubscribeManagerTest_SubscribeSwitchEvent_001, TestSize.Level1) 64 { __anon2fc82cf20202(std::shared_ptr<SwitchEvent> event) 65 auto func = [](std::shared_ptr<SwitchEvent> event) { 66 MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d", 67 event->GetSwitchType(), event->GetSwitchValue()); 68 }; 69 70 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(INVAID_VALUE, func), RET_ERR); 71 int32_t subscribeId = 72 SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func); 73 ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID); 74 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK); 75 } 76 77 /** 78 * @tc.name: SwitchEventInputSubscribeManagerTest_UnsubscribeSwitchEvent_001 79 * @tc.desc: Verify UnsubscribeSwitchEvent 80 * @tc.type: FUNC 81 * @tc.require: 82 */ 83 HWTEST_F(SwitchEventInputSubscribeManagerTest, 84 SwitchEventInputSubscribeManagerTest_UnsubscribeSwitchEvent_001, TestSize.Level2) 85 { __anon2fc82cf20302(std::shared_ptr<SwitchEvent> event) 86 auto func = [](std::shared_ptr<SwitchEvent> event) { 87 MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d", 88 event->GetSwitchType(), event->GetSwitchValue()); 89 }; 90 91 ASSERT_NE(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(INVAID_VALUE), RET_OK); 92 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(SUBSCRIBER_ID), RET_ERR); 93 int32_t subscribeId = 94 SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func); 95 ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID); 96 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK); 97 } 98 99 /** 100 * @tc.name: SwitchEventInputSubscribeManagerTest_QuerySwitchStatus_001 101 * @tc.desc: Verify QuerySwitchStatus 102 * @tc.type: FUNC 103 * @tc.require: 104 */ 105 HWTEST_F(SwitchEventInputSubscribeManagerTest, 106 SwitchEventInputSubscribeManagerTest_QuerySwitchStatus_001, TestSize.Level2) 107 { 108 int32_t state = 0; 109 int32_t retCode = 110 MULTIMODAL_INPUT_CONNECT_MGR->QuerySwitchStatus(SwitchEvent::SwitchType::SWITCH_DEFAULT, state); 111 ASSERT_EQ(retCode, RET_ERR); 112 retCode = 113 MULTIMODAL_INPUT_CONNECT_MGR->QuerySwitchStatus(SwitchEvent::SwitchType::SWITCH_LID, state); 114 ASSERT_EQ(retCode, RET_ERR); 115 } 116 117 /** 118 * @tc.name: SwitchEventInputSubscribeManagerTest_OnSubscribeSwitchEventCallback_001 119 * @tc.desc: Verify OnSubscribeSwitchEventCallback 120 * @tc.type: FUNC 121 * @tc.require: 122 */ 123 HWTEST_F(SwitchEventInputSubscribeManagerTest, 124 SwitchEventInputSubscribeManagerTest_OnSubscribeSwitchEventCallback_001, TestSize.Level2) 125 { __anon2fc82cf20402(std::shared_ptr<SwitchEvent> event) 126 auto func = [](std::shared_ptr<SwitchEvent> event) { 127 MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d", 128 event->GetSwitchType(), event->GetSwitchValue()); 129 }; 130 auto switchEvent = std::make_shared<SwitchEvent>(INVAID_VALUE); 131 ASSERT_NE(switchEvent, nullptr); 132 133 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback( 134 nullptr, SUBSCRIBER_ID), ERROR_NULL_POINTER); 135 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback( 136 switchEvent, INVAID_VALUE), RET_ERR); 137 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback( 138 switchEvent, SUBSCRIBER_ID), ERROR_NULL_POINTER); 139 int32_t subscribeId = 140 SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func); 141 ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID); 142 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnSubscribeSwitchEventCallback( 143 switchEvent, subscribeId), RET_OK); 144 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK); 145 } 146 147 /** 148 * @tc.name: SwitchEventInputSubscribeManagerTest_OnConnected_001 149 * @tc.desc: Verify OnConnected 150 * @tc.type: FUNC 151 * @tc.require: 152 */ 153 HWTEST_F(SwitchEventInputSubscribeManagerTest, 154 SwitchEventInputSubscribeManagerTest_OnConnected_001, TestSize.Level1) 155 { __anon2fc82cf20502(std::shared_ptr<SwitchEvent> event) 156 auto func = [](std::shared_ptr<SwitchEvent> event) { 157 MMI_HILOGD("Subscribe switch event success, type:%{public}d, value:%{public}d", 158 event->GetSwitchType(), event->GetSwitchValue()); 159 }; 160 161 SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnConnected(); 162 int32_t subscribeId = 163 SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.SubscribeSwitchEvent(SwitchEvent::SwitchType::SWITCH_DEFAULT, func); 164 ASSERT_GE(subscribeId, MIN_SUBSCRIBER_ID); 165 SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.OnConnected(); 166 ASSERT_EQ(SWITCH_EVENT_INPUT_SUBSCRIBE_MGR.UnsubscribeSwitchEvent(subscribeId), RET_OK); 167 } 168 169 /** 170 * @tc.name: SwitchEventInputSubscribeManagerTest_OnDisconnected_001 171 * @tc.desc: Verify OnDisconnected 172 * @tc.type: FUNC 173 * @tc.require: 174 */ 175 HWTEST_F(SwitchEventInputSubscribeManagerTest, 176 SwitchEventInputSubscribeManagerTest_OnDisconnected_001, TestSize.Level1) 177 { 178 InputManagerImpl inputManager; 179 EXPECT_NO_FATAL_FAILURE(inputManager.OnDisconnected()); 180 } 181 182 /** 183 * @tc.name: SwitchEventInputSubscribeManagerTest_ReAddInputEventFilter_001 184 * @tc.desc: Verify ReAddInputEventFilter 185 * @tc.type: FUNC 186 * @tc.require: 187 */ 188 HWTEST_F(SwitchEventInputSubscribeManagerTest, 189 SwitchEventInputSubscribeManagerTest_ReAddInputEventFilter_001, TestSize.Level1) 190 { 191 InputManagerImpl inputManager; 192 EXPECT_NO_FATAL_FAILURE(inputManager.ReAddInputEventFilter()); 193 } 194 195 /** 196 * @tc.name: SwitchEventInputSubscribeManagerTest_SetTouchpadScrollSwitch_001 197 * @tc.desc: Verify SetTouchpadScrollSwitch 198 * @tc.type: FUNC 199 * @tc.require: 200 */ 201 HWTEST_F(SwitchEventInputSubscribeManagerTest, 202 SwitchEventInputSubscribeManagerTest_SetTouchpadScrollSwitch_001, TestSize.Level1) 203 { 204 InputManagerImpl inputManager; 205 bool switchFlag = true; 206 int32_t ret = inputManager.SetTouchpadScrollSwitch(switchFlag); 207 ASSERT_EQ(ret, RET_OK); 208 switchFlag = false; 209 ret = inputManager.SetTouchpadScrollSwitch(switchFlag); 210 ASSERT_EQ(ret, RET_OK); 211 } 212 213 /** 214 * @tc.name: SwitchEventInputSubscribeManagerTest_GetTouchpadScrollSwitch_001 215 * @tc.desc: Verify GetTouchpadScrollSwitch 216 * @tc.type: FUNC 217 * @tc.require: 218 */ 219 HWTEST_F(SwitchEventInputSubscribeManagerTest, 220 SwitchEventInputSubscribeManagerTest_GetTouchpadScrollSwitch_001, TestSize.Level3) 221 { 222 InputManagerImpl inputManager; 223 bool switchFlag = true; 224 int32_t ret = inputManager.GetTouchpadScrollSwitch(switchFlag); 225 ASSERT_EQ(ret, RET_OK); 226 switchFlag = false; 227 ret = inputManager.GetTouchpadScrollSwitch(switchFlag); 228 ASSERT_EQ(ret, RET_OK); 229 } 230 231 /** 232 * @tc.name: SwitchEventInputSubscribeManagerTest_SetPixelMapData_001 233 * @tc.desc: Test the funcation SetPixelMapData 234 * @tc.type: FUNC 235 * @tc.require: 236 */ 237 HWTEST_F(SwitchEventInputSubscribeManagerTest, 238 SwitchEventInputSubscribeManagerTest_SetPixelMapData_001, TestSize.Level1) 239 { 240 CALL_TEST_DEBUG; 241 InputManagerImpl inputManagerImpl; 242 int32_t infoId = -1; 243 void* pixelMap = nullptr; 244 EXPECT_NO_FATAL_FAILURE(inputManagerImpl.SetPixelMapData(infoId, pixelMap)); 245 infoId = 1; 246 EXPECT_NO_FATAL_FAILURE(inputManagerImpl.SetPixelMapData(infoId, pixelMap)); 247 } 248 249 /** 250 * @tc.name: SwitchEventInputSubscribeManagerTest_ReAddInputEventFilter_002 251 * @tc.desc: Test the funcation ReAddInputEventFilter 252 * @tc.type: FUNC 253 * @tc.require: 254 */ 255 HWTEST_F(SwitchEventInputSubscribeManagerTest, 256 SwitchEventInputSubscribeManagerTest_ReAddInputEventFilter_002, TestSize.Level1) 257 { 258 InputManagerImpl inputManager; 259 sptr<IEventFilter> filter1 = new (std::nothrow) MyEventFilter(); 260 std::tuple<sptr<IEventFilter>, int32_t, uint32_t> value1(filter1, 10, 20); 261 inputManager.eventFilterServices_.insert(std::make_pair(1, value1)); 262 EXPECT_NO_FATAL_FAILURE(inputManager.ReAddInputEventFilter()); 263 sptr<IEventFilter> filter2 = new (std::nothrow) MyEventFilter(); 264 std::tuple<sptr<IEventFilter>, int32_t, uint32_t> value2(filter2, 20, 30); 265 inputManager.eventFilterServices_.insert(std::make_pair(2, value1)); 266 sptr<IEventFilter> filter3 = new (std::nothrow) MyEventFilter(); 267 std::tuple<sptr<IEventFilter>, int32_t, uint32_t> value3(filter3, 30, 40); 268 inputManager.eventFilterServices_.insert(std::make_pair(3, value3)); 269 sptr<IEventFilter> filter4 = new (std::nothrow) MyEventFilter(); 270 std::tuple<sptr<IEventFilter>, int32_t, uint32_t> value4(filter4, 40, 50); 271 inputManager.eventFilterServices_.insert(std::make_pair(4, value4)); 272 sptr<IEventFilter> filter5 = new (std::nothrow) MyEventFilter(); 273 std::tuple<sptr<IEventFilter>, int32_t, uint32_t> value5(filter5, 50, 60); 274 inputManager.eventFilterServices_.insert(std::make_pair(5, value5)); 275 EXPECT_NO_FATAL_FAILURE(inputManager.ReAddInputEventFilter()); 276 } 277 } // namespace MMI 278 } // namespace OHOS 279