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 18 #include "tablet_event_input_subscribe_manager.h" 19 #include <cinttypes> 20 #include "bytrace_adapter.h" 21 #include "define_multimodal.h" 22 #include "error_multimodal.h" 23 #include "multimodal_event_handler.h" 24 25 #undef MMI_LOG_TAG 26 #define MMI_LOG_TAG "TabletEventInputSubscribeManagerTest" 27 28 namespace OHOS { 29 namespace MMI { 30 namespace { 31 constexpr int32_t INVALID_SUBSCRIBE_ID { -1 }; 32 using namespace testing::ext; 33 } // namespace 34 35 class TabletEventInputSubscribeManagerTest : public testing::Test { 36 public: SetUpTestCase(void)37 static void SetUpTestCase(void) {} TearDownTestCase(void)38 static void TearDownTestCase(void) {} 39 }; 40 41 /** 42 * @tc.name: TabletEventInputSubscribeManagerTest_SubscribeNormal 43 * @tc.desc: Verify SubscribeTabletProximity 44 * @tc.type: FUNC 45 * @tc.require: 46 */ 47 HWTEST_F(TabletEventInputSubscribeManagerTest, TabletEventInputSubscribeManagerTest_SubscribeTabletProximity001, 48 TestSize.Level1) 49 { 50 TabletEventInputSubscribeManager manager; __anon76abb6dc0202(std::shared_ptr<PointerEvent> event) 51 auto callback = [](std::shared_ptr<PointerEvent> event) {}; 52 int32_t ret = manager.SubscribeTabletProximity(callback); 53 EXPECT_GE(ret, 0); 54 55 manager.subscribeManagerId_ = INT_MAX; 56 ret = manager.SubscribeTabletProximity(callback); 57 EXPECT_GE(ret, INVALID_SUBSCRIBE_ID); 58 59 manager.subscribeManagerId_ = -1; 60 ret = manager.SubscribeTabletProximity(callback); 61 EXPECT_GE(ret, INVALID_SUBSCRIBE_ID); 62 } 63 64 /** 65 * @tc.name: TabletEventInputSubscribeManagerTest_SubscribeWithNullCallback 66 * @tc.desc: Verify SubscribeTabletProximity 67 * @tc.type: FUNC 68 * @tc.require: 69 */ 70 HWTEST_F(TabletEventInputSubscribeManagerTest, TabletEventInputSubscribeManagerTest_SubscribeTabletProximity002, 71 TestSize.Level1) 72 { 73 TabletEventInputSubscribeManager manager; 74 int32_t ret = manager.SubscribeTabletProximity(nullptr); 75 EXPECT_EQ(ret, ERROR_NULL_POINTER); 76 } 77 78 /** 79 * @tc.name: TabletEventInputSubscribeManagerTest_UnsubscribeValid 80 * @tc.desc: Verify UnsubscribetabletProximity 81 * @tc.type: FUNC 82 * @tc.require: 83 */ 84 HWTEST_F(TabletEventInputSubscribeManagerTest, TabletEventInputSubscribeManagerTest_UnSubscribeTabletProximity001, 85 TestSize.Level1) 86 { 87 TabletEventInputSubscribeManager manager; __anon76abb6dc0302(std::shared_ptr<PointerEvent> event) 88 auto callback = [](std::shared_ptr<PointerEvent> event) {}; 89 int32_t subscribeId = manager.SubscribeTabletProximity(callback); 90 EXPECT_EQ(manager.UnsubscribetabletProximity(subscribeId), RET_OK); 91 } 92 93 /** 94 * @tc.name: TabletEventInputSubscribeManagerTest_UnsubscribeInvalid 95 * @tc.desc: Verify UnsubscribetabletProximity 96 * @tc.type: FUNC 97 * @tc.require: 98 */ 99 HWTEST_F(TabletEventInputSubscribeManagerTest, TabletEventInputSubscribeManagerTest_UnSubscribeTabletProximity002, 100 TestSize.Level1) 101 { 102 TabletEventInputSubscribeManager manager; 103 EXPECT_EQ(manager.UnsubscribetabletProximity(-1), RET_ERR); 104 } 105 106 /** 107 * @tc.name: TabletEventInputSubscribeManagerTest_CallbackExecution 108 * @tc.desc: Verify callback OnSubscribeTabletProximity 109 * @tc.type: FUNC 110 * @tc.require: 111 */ 112 HWTEST_F(TabletEventInputSubscribeManagerTest, TabletEventInputSubscribeManagerTest_OnSubscribeTabletProximity001, 113 TestSize.Level1) 114 { 115 TabletEventInputSubscribeManager manager; 116 bool callbackExecuted = false; __anon76abb6dc0402(std::shared_ptr<PointerEvent> event) 117 auto callback = [&callbackExecuted](std::shared_ptr<PointerEvent> event) { 118 callbackExecuted = true; 119 }; 120 121 int32_t subscribeId = manager.SubscribeTabletProximity(callback); 122 auto event = std::make_shared<PointerEvent>(PointerEvent::POINTER_ACTION_PROXIMITY_IN); 123 auto ret = manager.OnSubscribeTabletProximityCallback(event, subscribeId); 124 EXPECT_EQ(ret, RET_OK); 125 EXPECT_TRUE(callbackExecuted); 126 127 EXPECT_EQ(manager.UnsubscribetabletProximity(subscribeId), RET_OK); 128 ret = manager.OnSubscribeTabletProximityCallback(event, subscribeId); 129 EXPECT_EQ(ret, ERROR_NULL_POINTER); 130 131 ret = manager.OnSubscribeTabletProximityCallback(nullptr, subscribeId); 132 EXPECT_EQ(ret, ERROR_NULL_POINTER); 133 134 subscribeId = -1; 135 ret = manager.OnSubscribeTabletProximityCallback(event, subscribeId); 136 EXPECT_EQ(ret, RET_ERR); 137 } 138 139 /** 140 * @tc.name: TabletEventInputSubscribeManagerTest_DoubleUnsubscribe 141 * @tc.desc: Verify UnsubscribetabletProximity 142 * @tc.type: FUNC 143 * @tc.require: 144 */ 145 HWTEST_F(TabletEventInputSubscribeManagerTest, TabletEventInputSubscribeManagerTest_DoubleUnsubscribe, 146 TestSize.Level1) 147 { 148 TabletEventInputSubscribeManager manager; __anon76abb6dc0502(std::shared_ptr<PointerEvent> event) 149 auto callback = [](std::shared_ptr<PointerEvent> event) {}; 150 int32_t subscribeId1 = manager.SubscribeTabletProximity(callback); 151 int32_t subscribeId2 = manager.SubscribeTabletProximity(callback); 152 EXPECT_EQ(manager.UnsubscribetabletProximity(subscribeId1), RET_OK); 153 EXPECT_EQ(manager.UnsubscribetabletProximity(subscribeId1), RET_ERR); 154 155 EXPECT_EQ(manager.UnsubscribetabletProximity(subscribeId2), RET_OK); 156 EXPECT_EQ(manager.UnsubscribetabletProximity(subscribeId2), RET_ERR); 157 } 158 } // namespace MMI 159 } // namespace OHOS