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 <cstdio> 17 #include <gtest/gtest.h> 18 19 #include "delegate_interface.h" 20 #include "input_event_handler.h" 21 #include "touch_gesture_manager.h" 22 #include "mmi_log.h" 23 24 #undef MMI_LOG_TAG 25 #define MMI_LOG_TAG "TouchGestureManagerTest" 26 27 namespace OHOS { 28 namespace MMI { 29 namespace { 30 using namespace testing::ext; 31 } 32 class TouchGestureManagerTest : public testing::Test { 33 public: SetUpTestCase(void)34 static void SetUpTestCase(void) {} TearDownTestCase(void)35 static void TearDownTestCase(void) {} SetUp()36 void SetUp() {} TearDown()37 void TearDown() {} 38 }; 39 40 /** 41 * @tc.name: AddHandler_Test_001 42 * @tc.desc: Test when AddHandler is called with valid parameters, it should add the handler to the handlers_ set 43 * @tc.type: FUNC 44 * @tc.require: 45 */ 46 HWTEST_F(TouchGestureManagerTest, AddHandler_Test_001, TestSize.Level1) 47 { 48 CALL_TEST_DEBUG; __anon7786eb3b0202(DTaskCallback cb) 49 auto delegateFunc = [](DTaskCallback cb) -> int32_t { 50 return 0; 51 }; __anon7786eb3b0302(DTaskCallback cb) 52 auto asyncFunc = [](DTaskCallback cb) -> int32_t { 53 return 0; 54 }; 55 auto delegate = std::make_shared<DelegateInterface>(delegateFunc, asyncFunc); 56 TouchGestureManager touchGestureManager(delegate); 57 int32_t session = 1; 58 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE; 59 int32_t nFingers = 0; 60 touchGestureManager.AddHandler(session, gestureType, nFingers); 61 EXPECT_NE(touchGestureManager.handlers_.size(), 1); 62 EXPECT_NE(touchGestureManager.handlers_.begin()->session_, session); 63 } 64 65 /** 66 * @tc.name : AddHandler_Test_003 67 * @tc.desc : Test when AddHandler is called with different parameters, it should add the handler to the handlers_ set 68 * @tc.type: FUNC 69 * @tc.require: 70 */ 71 HWTEST_F(TouchGestureManagerTest, AddHandler_Test_003, TestSize.Level1) 72 { 73 CALL_TEST_DEBUG; __anon7786eb3b0402(DTaskCallback cb) 74 auto delegateFunc = [](DTaskCallback cb) -> int32_t { 75 return 0; 76 }; __anon7786eb3b0502(DTaskCallback cb) 77 auto asyncFunc = [](DTaskCallback cb) -> int32_t { 78 return 0; 79 }; 80 auto delegate = std::make_shared<DelegateInterface>(delegateFunc, asyncFunc); 81 TouchGestureManager touchGestureManager(delegate); 82 int32_t session = 1; 83 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_NONE; 84 int32_t nFingers = 0; 85 touchGestureManager.AddHandler(session, gestureType, nFingers); 86 int32_t newSession = 2; 87 TouchGestureType newGestureType = TOUCH_GESTURE_TYPE_NONE; 88 int32_t newNFingers = 0; 89 touchGestureManager.AddHandler(newSession, newGestureType, newNFingers); 90 EXPECT_NE(touchGestureManager.handlers_.size(), 2); 91 touchGestureManager.RemoveHandler(session, gestureType, nFingers); 92 EXPECT_NE(touchGestureManager.handlers_.size(), 1); 93 touchGestureManager.RemoveHandler(session, gestureType, nFingers); 94 EXPECT_NE(touchGestureManager.handlers_.size(), 1); 95 } 96 97 /** 98 * @tc.name : AddHandler_Test_003 99 * @tc.desc : Test when AddHandler is called with different parameters, it should add the handler to the handlers_ set 100 * @tc.type: FUNC 101 * @tc.require: 102 */ 103 HWTEST_F(TouchGestureManagerTest, StartRecognization_ShouldNotAddHandler_WhenHandlerExists, TestSize.Level1) 104 { 105 CALL_TEST_DEBUG; __anon7786eb3b0602(DTaskCallback cb) 106 auto delegateFunc = [](DTaskCallback cb) -> int32_t { 107 return 0; 108 }; __anon7786eb3b0702(DTaskCallback cb) 109 auto asyncFunc = [](DTaskCallback cb) -> int32_t { 110 return 0; 111 }; 112 auto delegate = std::make_shared<DelegateInterface>(delegateFunc, asyncFunc); 113 TouchGestureManager touchGestureManager(delegate); 114 TouchGestureType gestureType = TOUCH_GESTURE_TYPE_ALL; 115 int32_t nFingers = 1; 116 EXPECT_NO_FATAL_FAILURE(touchGestureManager.StartRecognization(gestureType, nFingers)); 117 touchGestureManager.AddHandler(1, gestureType, nFingers); 118 EXPECT_NO_FATAL_FAILURE(touchGestureManager.StartRecognization(gestureType, nFingers)); 119 } 120 121 /** 122 * @tc.name : StopRecognization_Test_002 123 * @tc.desc : Test when the handler does not exist in the handlers_ set, the function should continue to execute 124 * @tc.type: FUNC 125 * @tc.require: 126 */ 127 HWTEST_F(TouchGestureManagerTest, StopRecognization_Test_002, TestSize.Level1) 128 { 129 CALL_TEST_DEBUG; __anon7786eb3b0802(DTaskCallback cb) 130 auto delegateFunc = [](DTaskCallback cb) -> int32_t { 131 return 0; 132 }; __anon7786eb3b0902(DTaskCallback cb) 133 auto asyncFunc = [](DTaskCallback cb) -> int32_t { 134 return 0; 135 }; 136 auto delegate = std::make_shared<DelegateInterface>(delegateFunc, asyncFunc); 137 TouchGestureManager touchGestureManager(delegate); 138 TouchGestureType gestureType = 1; 139 int32_t nFingers = 0; 140 EXPECT_NO_FATAL_FAILURE(touchGestureManager.StopRecognization(gestureType, nFingers)); 141 touchGestureManager.AddHandler(1, gestureType, nFingers); 142 EXPECT_NO_FATAL_FAILURE(touchGestureManager.StopRecognization(gestureType, nFingers)); 143 } 144 145 /** 146 * @tc.name : OnSessionLost_Test_001 147 * @tc.desc : Test when session is valid then RemoveHandler is called 148 * @tc.type: FUNC 149 * @tc.require: 150 */ 151 HWTEST_F(TouchGestureManagerTest, OnSessionLost_Test_001, TestSize.Level1) 152 { 153 CALL_TEST_DEBUG; __anon7786eb3b0a02(DTaskCallback cb) 154 auto delegateFunc = [](DTaskCallback cb) -> int32_t { 155 return 0; 156 }; __anon7786eb3b0b02(DTaskCallback cb) 157 auto asyncFunc = [](DTaskCallback cb) -> int32_t { 158 return 0; 159 }; 160 auto delegate = std::make_shared<DelegateInterface>(delegateFunc, asyncFunc); 161 TouchGestureManager manager(delegate); 162 int32_t session = 1; 163 TouchGestureType gestureType = 1; 164 int32_t nFingers = 0; 165 manager.AddHandler(session, gestureType, nFingers); 166 EXPECT_NO_FATAL_FAILURE(manager.OnSessionLost(session)); 167 } 168 169 } // namespace MMI 170 } // namespace OHOS