diff --git a/interfaces/kits/c/ohinput.ndk.json b/interfaces/kits/c/ohinput.ndk.json
index 276f28fc6702449bc2e9aa360a3bb4b652d0acaa..5760ca5a8d0fba321befd72791659249647156f6 100644
--- a/interfaces/kits/c/ohinput.ndk.json
+++ b/interfaces/kits/c/ohinput.ndk.json
@@ -501,7 +501,7 @@
     },
     {
         "first_introduced": "20",
-        "name": "OH_Input_GetMaxMultiTouchPointNum"
+        "name": "OH_Input_QueryMaxTouchPoints"
     },
     {
         "first_introduced": "20",
diff --git a/service/touch_event_normalize/src/touch_gesture_detector.cpp b/service/touch_event_normalize/src/touch_gesture_detector.cpp
index 9211b6a56cb6196a7b07989348baf71c372ef8f8..023d963888f1035ff4f88b28e81cb9664297f381 100644
--- a/service/touch_event_normalize/src/touch_gesture_detector.cpp
+++ b/service/touch_event_normalize/src/touch_gesture_detector.cpp
@@ -789,11 +789,14 @@ void TouchGestureDetector::OnGestureSendEvent(std::shared_ptr<PointerEvent> even
 std::string TouchGestureDetector::DumpTouches() const
 {
     std::ostringstream output;
-    output << "[" << downPoint_.size() << "]";
 
-    for (const auto &[id, downPt] : downPoint_) {
-        output << "(" << id << "," << downPt.time << "," << downPt.x
-               << "," << downPt.y << ")";
+    if (auto iter = downPoint_.cbegin(); iter != downPoint_.cend()) {
+        output << "(" << iter->first;
+
+        for (++iter; iter != downPoint_.cend(); ++iter) {
+            output << "," << iter->first;
+        }
+        output << ")";
     }
     return std::move(output).str();
 }
diff --git a/service/touch_event_normalize/test/src/touch_event_normalize_test.cpp b/service/touch_event_normalize/test/src/touch_event_normalize_test.cpp
index 4bd9d5e57367c5cec7be3f357e900fcab1a28d8e..0945fbad7622f06ee9ec21eb955200bd97114c80 100644
--- a/service/touch_event_normalize/test/src/touch_event_normalize_test.cpp
+++ b/service/touch_event_normalize/test/src/touch_event_normalize_test.cpp
@@ -109,7 +109,6 @@ HWTEST_F(TouchEventNormalizeTest, TouchEventNormalizeTest_MakeTransformProcessor
     ASSERT_NE(TOUCH_EVENT_HDR->MakeTransformProcessor(deviceId, TouchEventNormalize::DeviceType::GESTURE), nullptr);
     ASSERT_NE(TOUCH_EVENT_HDR->MakeTransformProcessor(deviceId, TouchEventNormalize::DeviceType::REMOTE_CONTROL),
         nullptr);
-    ASSERT_NE(TOUCH_EVENT_HDR->MakeTransformProcessor(deviceId, TouchEventNormalize::DeviceType::JOYSTICK), nullptr);
     ASSERT_EQ(TOUCH_EVENT_HDR->MakeTransformProcessor(deviceId, TouchEventNormalize::DeviceType::KNUCKLE), nullptr);
 }
 
diff --git a/service/touch_event_normalize/test/src/touch_gesture_adapter_test.cpp b/service/touch_event_normalize/test/src/touch_gesture_adapter_test.cpp
index 3031311bf82d7771ba937e1c6d59a121763ff7dc..9a6cc14c7ff3e1ed2cba33d85c20fdf6bfff89ca 100644
--- a/service/touch_event_normalize/test/src/touch_gesture_adapter_test.cpp
+++ b/service/touch_event_normalize/test/src/touch_gesture_adapter_test.cpp
@@ -80,6 +80,57 @@ HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_process_001, TestSize.
     ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->process(event));
 }
 
+/**
+ * @tc.name: TouchGestureAdapterTest_process_002
+ * @tc.desc: Test TouchGestureAdapter::process
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_process_002, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto nextAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_PINCH, nullptr);
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nextAdapter);
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->process(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureAdapterTest_process_003
+ * @tc.desc: Test TouchGestureAdapter::process
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_process_003, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto nextAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_PINCH, nullptr);
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nextAdapter);
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_UNKNOWN);
+    touchGestureAdapter->shouldDeliverToNext_ = false;
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->process(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureAdapterTest_process_004
+ * @tc.desc: Test TouchGestureAdapter::process
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_process_004, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->process(pointerEvent));
+}
+
 /**
  * @tc.name: TouchGestureAdapterTest_Init_001
  * @tc.desc: Test the funcation Init
@@ -340,5 +391,85 @@ HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_OnTouchEvent_003, Test
     event->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
     ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->OnTouchEvent(event));
 }
+
+/**
+ * @tc.name: TouchGestureAdapterTest_LogTouchEvent_01
+ * @tc.desc: Test TouchGestureAdapter::LogTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_LogTouchEvent_01, TestSize.Level1)
+{
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->LogTouchEvent(nullptr));
+}
+
+/**
+ * @tc.name: TouchGestureAdapterTest_LogTouchEvent_02
+ * @tc.desc: Test TouchGestureAdapter::LogTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_LogTouchEvent_02, TestSize.Level1)
+{
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->LogTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureAdapterTest_LogTouchEvent_03
+ * @tc.desc: Test TouchGestureAdapter::LogTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_LogTouchEvent_03, TestSize.Level1)
+{
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->LogTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureAdapterTest_LogTouchEvent_04
+ * @tc.desc: Test TouchGestureAdapter::LogTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_LogTouchEvent_04, TestSize.Level1)
+{
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->LogTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureAdapterTest_LogTouchEvent_05
+ * @tc.desc: Test TouchGestureAdapter::LogTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureAdapterTest, TouchGestureAdapterTest_LogTouchEvent_05, TestSize.Level1)
+{
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
+    int32_t pointerId = 1;
+    PointerEvent::PointerItem pointerItem {};
+    pointerItem.SetPointerId(pointerId);
+    pointerEvent->AddPointerItem(pointerItem);
+    pointerEvent->SetPointerId(pointerId);
+    auto touchGestureAdapter = std::make_shared<TouchGestureAdapter>(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    ASSERT_NO_FATAL_FAILURE(touchGestureAdapter->LogTouchEvent(pointerEvent));
+}
 } // namespace MMI
 } // namespace OHOS
\ No newline at end of file
diff --git a/service/touch_event_normalize/test/src/touch_gesture_detector_test.cpp b/service/touch_event_normalize/test/src/touch_gesture_detector_test.cpp
index 92ef0d174d1ba2ef4b442551dfd33d37c403476c..657cc535e5dfae2f79df2ea2bccd5632be7aae26 100644
--- a/service/touch_event_normalize/test/src/touch_gesture_detector_test.cpp
+++ b/service/touch_event_normalize/test/src/touch_gesture_detector_test.cpp
@@ -114,6 +114,164 @@ HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_02, Tes
     EXPECT_FALSE(detector.OnTouchEvent(pointerEvent));
 }
 
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_05
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_05, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(nullptr));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_06
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_06, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_MOUSE);
+
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_07
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_07, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_DOWN);
+
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    int32_t fingerCnt = 3;
+    detector.AddGestureFingers(fingerCnt);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_08
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_08, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_MOVE);
+
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    int32_t fingerCnt = 3;
+    detector.AddGestureFingers(fingerCnt);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_09
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_09, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
+
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    int32_t fingerCnt = 3;
+    detector.AddGestureFingers(fingerCnt);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_10
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_10, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_CANCEL);
+
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    int32_t fingerCnt = 3;
+    detector.AddGestureFingers(fingerCnt);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_11
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_11, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_PULL_UP);
+
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    int32_t fingerCnt = 3;
+    detector.AddGestureFingers(fingerCnt);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_OnTouchEvent_12
+ * @tc.desc: Test OnTouchEvent
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_OnTouchEvent_12, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto pointerEvent = PointerEvent::Create();
+    ASSERT_NE(pointerEvent, nullptr);
+    pointerEvent->SetSourceType(PointerEvent::SOURCE_TYPE_TOUCHSCREEN);
+    pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UNKNOWN);
+
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, listener);
+    int32_t fingerCnt = 3;
+    detector.AddGestureFingers(fingerCnt);
+    ASSERT_NO_FATAL_FAILURE(detector.OnTouchEvent(pointerEvent));
+}
+
 /**
  * @tc.name: TouchGestureDetectorTest_HandleDownEvent_01
  * @tc.desc: Test HandleDownEvent
@@ -418,7 +576,7 @@ HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_WhetherDiscardTouchE
     pointerEvent->bitwise_ = 0;
     pointerEvent->SetPointerId(7);
     pointerEvent->targetDisplayId_ = INT32_MAX - 1;
-    EXPECT_FALSE(detector.WhetherDiscardTouchEvent(pointerEvent));
+    EXPECT_TRUE(detector.WhetherDiscardTouchEvent(pointerEvent));
 
     detector.gestureDisplayId_ = INT32_MAX;
     pointerEvent->SetPointerAction(PointerEvent::POINTER_ACTION_UP);
@@ -542,6 +700,58 @@ HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_
     ASSERT_NO_FATAL_FAILURE(detector.GetMaxFingerSpacing());
 }
 
+/**
+ * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_03
+ * @tc.desc: Test GetMaxFingerSpacing
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_03, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
+    TouchGestureDetector detector(type, listener);
+    EXPECT_FLOAT_EQ(detector.GetMaxFingerSpacing(), 0.0f);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_04
+ * @tc.desc: Test GetMaxFingerSpacing
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_04, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
+    TouchGestureDetector detector(type, listener);
+    detector.downPoint_[1] = Point(1.0f, 1.0f);
+    detector.downPoint_[2] = Point(2.0f, 2.0f);
+    detector.downPoint_[3] = Point(3.0f, 3.0f);
+    EXPECT_FLOAT_EQ(detector.GetMaxFingerSpacing(), std::hypot(2.0f, 2.0f));
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_GetMaxFingerSpacing_05
+ * @tc.desc: Test GetMaxFingerSpacing
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetMaxFingerSpacing_05, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    auto listener = std::make_shared<MyGestureListener>();
+    TouchGestureType type = TOUCH_GESTURE_TYPE_SWIPE;
+    TouchGestureDetector detector(type, listener);
+    detector.downPoint_[1] = Point(1.0f, 1.0f);
+    detector.downPoint_[2] = Point(2.0f, 2.0f);
+    detector.downPoint_[3] = Point(3.0f, 3.0f);
+    detector.downPoint_[4] = Point(4.0f, 4.0f);
+    EXPECT_FLOAT_EQ(detector.GetMaxFingerSpacing(), std::hypot(3.0f, 3.0f));
+}
+
 /**
  * @tc.name: TouchGestureDetectorTest_GetMaxDownInterval_01
  * @tc.desc: Test GetMaxDownInterval
@@ -1053,6 +1263,58 @@ HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_01
     ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
 }
 
+/**
+ * @tc.name: TouchGestureDetectorTest_AddGestureFingers_02
+ * @tc.desc: Test AddGestureFingers
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_02, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    int32_t fingers = 5;
+    ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
+    EXPECT_TRUE(detector.gestureEnable_);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_AddGestureFingers_03
+ * @tc.desc: Test AddGestureFingers
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_03, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    int32_t fingers = 5;
+    ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
+    EXPECT_TRUE(detector.gestureEnable_);
+    detector.gestureEnable_ = false;
+    ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers));
+    EXPECT_FALSE(detector.gestureEnable_);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_AddGestureFingers_04
+ * @tc.desc: Test AddGestureFingers
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_AddGestureFingers_04, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    int32_t fingers1 = 3;
+    ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers1));
+    EXPECT_TRUE(detector.gestureEnable_);
+    detector.gestureEnable_ = false;
+    int32_t fingers2 = 4;
+    ASSERT_NO_FATAL_FAILURE(detector.AddGestureFingers(fingers2));
+    EXPECT_TRUE(detector.gestureEnable_);
+}
+
 /**
  * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_01
  * @tc.desc: Test RemoveGestureFingers
@@ -1077,6 +1339,60 @@ HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers
     ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(fingers));
 }
 
+/**
+ * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_02
+ * @tc.desc: Test RemoveGestureFingers
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers_02, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    int32_t fingers = 1;
+    detector.AddGestureFingers(fingers);
+    ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(fingers));
+    EXPECT_FALSE(detector.fingers_.find(fingers) != detector.fingers_.cend());
+    EXPECT_FALSE(detector.gestureEnable_);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_03
+ * @tc.desc: Test RemoveGestureFingers
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers_03, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    int32_t finger1 = 3;
+    detector.AddGestureFingers(finger1);
+    int32_t finger2 = 4;
+    ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(finger2));
+    EXPECT_TRUE(detector.fingers_.find(finger1) != detector.fingers_.cend());
+    EXPECT_TRUE(detector.gestureEnable_);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_RemoveGestureFingers_04
+ * @tc.desc: Test RemoveGestureFingers
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_RemoveGestureFingers_04, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    int32_t finger1 = 3;
+    detector.AddGestureFingers(finger1);
+    int32_t finger2 = 4;
+    detector.AddGestureFingers(finger2);
+    ASSERT_NO_FATAL_FAILURE(detector.RemoveGestureFingers(finger2));
+    EXPECT_TRUE(detector.fingers_.find(finger1) != detector.fingers_.cend());
+    EXPECT_TRUE(detector.gestureEnable_);
+}
+
 /**
  * @tc.name: TouchGestureDetectorTest_IsMatchGesture_01
  * @tc.desc: Test IsMatchGesture
@@ -1894,5 +2210,89 @@ HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_CheckGestureTrend_00
     pointerEvent->SetPointerId(2);
     ASSERT_NO_FATAL_FAILURE(detector.CheckGestureTrend(pointerEvent));
 }
+
+/**
+ * @tc.name: TouchGestureDetectorTest_GetAngle_01
+ * @tc.desc: Test TouchGestureDetector::GetAngle
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_01, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    float startX = 0.0f;
+    float startY = 0.0f;
+    float endX = 0.0f;
+    float endY = 1.0f;
+    constexpr double expectedAngle = 90.0;
+    constexpr double precision = 0.001;
+
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    double actualAngle = detector.GetAngle(startX, startY, endX, endY);
+    EXPECT_NEAR(expectedAngle, actualAngle, precision);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_GetAngle_02
+ * @tc.desc: Test TouchGestureDetector::GetAngle
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_02, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    float startX = 0.0f;
+    float startY = 0.0f;
+    float endX = 1.0f;
+    float endY = 1.0f;
+    constexpr double expectedAngle = 45.0;
+    constexpr double precision = 0.001;
+
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    double actualAngle = detector.GetAngle(startX, startY, endX, endY);
+    EXPECT_NEAR(expectedAngle, actualAngle, precision);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_GetAngle_03
+ * @tc.desc: Test TouchGestureDetector::GetAngle
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_03, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    float startX = 0.0f;
+    float startY = 0.0f;
+    float endX = -1.0f;
+    float endY = 1.0f;
+    constexpr double expectedAngle = 135.0;
+    constexpr double precision = 0.001;
+
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    double actualAngle = detector.GetAngle(startX, startY, endX, endY);
+    EXPECT_NEAR(expectedAngle, actualAngle, precision);
+}
+
+/**
+ * @tc.name: TouchGestureDetectorTest_GetAngle_04
+ * @tc.desc: Test TouchGestureDetector::GetAngle
+ * @tc.type: FUNC
+ * @tc.require:
+ */
+HWTEST_F(TouchGestureDetectorTest, TouchGestureDetectorTest_GetAngle_04, TestSize.Level1)
+{
+    CALL_TEST_DEBUG;
+    float startX = 0.0f;
+    float startY = 0.0f;
+    float endX = -1.0f;
+    float endY = -1.0f;
+    constexpr double expectedAngle = -135.0;
+    constexpr double precision = 0.001;
+
+    TouchGestureDetector detector(TOUCH_GESTURE_TYPE_SWIPE, nullptr);
+    double actualAngle = detector.GetAngle(startX, startY, endX, endY);
+    EXPECT_NEAR(expectedAngle, actualAngle, precision);
+}
 } // namespace MMI
 } // namespace OHOS
\ No newline at end of file