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