From f67085dd2eec1cb7a7246b4a1e260ee0711f975d Mon Sep 17 00:00:00 2001 From: qingjy Date: Mon, 14 Jul 2025 20:13:36 +0800 Subject: [PATCH 1/3] Tdd add Signed-off-by: qingjy --- test/mock/base/mock_ressched_report.cpp | 2 + test/unittest/core/event/BUILD.gn | 1 + .../core/event/event_dump_test_ng.cpp | 289 +++- .../core/event/event_manager_test_ng.cpp | 6 + .../core/event/event_manager_test_ng.h | 1 + .../core/event/event_manager_test_ng_new.cpp | 69 +- .../core/event/event_manager_test_ng_two.cpp | 1179 +++++++++++++++++ 7 files changed, 1538 insertions(+), 9 deletions(-) diff --git a/test/mock/base/mock_ressched_report.cpp b/test/mock/base/mock_ressched_report.cpp index 64f24856315..6838a5aa4ff 100644 --- a/test/mock/base/mock_ressched_report.cpp +++ b/test/mock/base/mock_ressched_report.cpp @@ -46,6 +46,8 @@ void ResSchedReport::ResSchedDataReport( void ResSchedReport::OnTouchEvent(const TouchEvent& touchEvent, const ReportConfig& config) {} +void ResSchedReport::OnKeyEvent(const KeyEvent& event) {} + void ResSchedReport::HandlePageTransition(const std::string& fromPage, const std::string& toPage, const std::string& mode) {} diff --git a/test/unittest/core/event/BUILD.gn b/test/unittest/core/event/BUILD.gn index f84ebd67d55..b61891f59d2 100644 --- a/test/unittest/core/event/BUILD.gn +++ b/test/unittest/core/event/BUILD.gn @@ -17,6 +17,7 @@ ace_unittest("event_manager_test_ng") { type = "new" module_output = "events" sources = [ + "$ace_root/frameworks/core/event/resample_algo.cpp", "$ace_root/test/mock/core/common/mock_watch_dog.cpp", "$ace_root/test/mock/core/common/mock_window.cpp", "event_dump_test_ng.cpp", diff --git a/test/unittest/core/event/event_dump_test_ng.cpp b/test/unittest/core/event/event_dump_test_ng.cpp index acb3ccdb610..0faa4c0ad7b 100644 --- a/test/unittest/core/event/event_dump_test_ng.cpp +++ b/test/unittest/core/event/event_dump_test_ng.cpp @@ -15,6 +15,7 @@ #include "gtest/gtest.h" #include "core/common/event_dump.h" +#include "test/unittest/core/event/event_manager_test_ng.h" using namespace testing; using namespace testing::ext; @@ -24,8 +25,9 @@ namespace { constexpr size_t MAX_EVENT_TREE_RECORD_CNT = 5; constexpr int32_t MAX_EVENT_TREE_TOUCH_DOWN_CNT = 10; constexpr int32_t MAX_EVENT_TREE_TOUCH_POINT_CNT = 20; +constexpr int32_t MAX_EVENT_TREE_AXIS_UPDATE_CNT = 20; +constexpr int32_t MAX_EVENT_TREE_AXIS_CNT = 20; constexpr int32_t PARENT_NODEID = 0; -constexpr int32_t NODEID = 1; constexpr int32_t DEFAULT_HITTEST_MODE = 0; constexpr int32_t DEFAULT_DEPTH = 1; constexpr int64_t DEFAULT_TIME_STAMP = 65536; @@ -46,9 +48,12 @@ public: std::shared_ptr CreateFrameNodeSnapshotWithInitValue(); std::shared_ptr CreateTouchPointSnapshot(const TouchEvent& event); + std::shared_ptr CreateAxisSnapshot(const AxisEvent& event); std::shared_ptr CreateEventTreeRecord(); void FillTouchDownEventToEventTree(std::shared_ptr eventTreeRecord, const TouchEvent& event, int32_t eventTreeRecordCount = 0, int32_t touchDownCount = 0, int32_t touchPointCount = 0); + void FillAxisUpdateEventToEventTree(std::shared_ptr eventTreeRecord, const AxisEvent& event, + int32_t eventTreeRecordCount = 0, int32_t axisUpdateCount = 0, int32_t AxisCount = 0); }; void EventDumpTestNg::SetUp() @@ -83,6 +88,11 @@ std::shared_ptr EventDumpTestNg::CreateTouchPointSnapshot(co return std::make_shared(event); } +std::shared_ptr EventDumpTestNg::CreateAxisSnapshot(const AxisEvent& event) +{ + return std::make_shared(event); +} + std::shared_ptr EventDumpTestNg::CreateEventTreeRecord() { return std::make_shared(); @@ -106,6 +116,25 @@ void EventDumpTestNg::FillTouchDownEventToEventTree(std::shared_ptr eventTreeRecord, + const AxisEvent& event, const int32_t eventTreeRecordCount, int32_t axisUpdateCount, int32_t AxisCount) +{ + if (!eventTreeRecord || event.action != Ace::AxisAction::BEGIN) { + return; + } + eventTreeRecord->eventTreeList.clear(); + for (int32_t i = 0; i < eventTreeRecordCount; ++i) { + eventTreeRecord->eventTreeList.emplace_back(EventTree()); + } + if (!eventTreeRecord->eventTreeList.empty()) { + for (int32_t i = 0; i < AxisCount; ++i) { + eventTreeRecord->eventTreeList.back().axis.emplace_back(AxisSnapshot(event)); + } + eventTreeRecord->eventTreeList.back().axisUpdateCount = axisUpdateCount; + } +} + + /** * @tc.name: EventDumpTestNg001 * @tc.desc: FrameNodeSnapshot dump function test. @@ -151,6 +180,10 @@ HWTEST_F(EventDumpTestNg, EventDumpTestNg002, TestSize.Level1) EXPECT_TRUE(dumpList.empty()); touchPointSnapshot->Dump(dumpList, DEFAULT_DEPTH); EXPECT_FALSE(dumpList.empty()); + + std::unique_ptr dumpJson = JsonUtil::Create(true); + touchPointSnapshot->Dump(dumpJson); + EXPECT_TRUE(dumpJson->Contains("isInjected")); } /** @@ -296,6 +329,11 @@ HWTEST_F(EventDumpTestNg, EventDumpTestNg007, TestSize.Level1) std::string state = "current"; std::string disposal = "mainThread"; + eventTreeRecord->AddGestureProcedure(finger + 1, procedure, "", state, disposal, DEFAULT_TIME_STAMP); + ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); + auto iter0 = eventTreeRecord->eventTreeList.back().gestureMap.find(finger + 1); + EXPECT_TRUE(iter0 == eventTreeRecord->eventTreeList.back().gestureMap.end()); + eventTreeRecord->AddGestureProcedure(finger, procedure, "", state, disposal, DEFAULT_TIME_STAMP); ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); auto iter = eventTreeRecord->eventTreeList.back().gestureMap.find(finger); @@ -341,7 +379,7 @@ HWTEST_F(EventDumpTestNg, EventDumpTestNg008, TestSize.Level2) } /** - * @tc.name: EventDumpTestNg007 + * @tc.name: EventDumpTestNg009 * @tc.desc: EventTreeRecord AddGestureProcedure function test. * @tc.type: FUNC */ @@ -367,6 +405,11 @@ HWTEST_F(EventDumpTestNg, EventDumpTestNg009, TestSize.Level1) std::string state = "current"; std::string disposal = "mainThread"; + eventTreeRecord->AddGestureProcedure(finger + 1, event, "", state, disposal, DEFAULT_TIME_STAMP); + ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); + auto iter0 = eventTreeRecord->eventTreeList.back().gestureMap.find(finger + 1); + EXPECT_TRUE(iter0 == eventTreeRecord->eventTreeList.back().gestureMap.end()); + eventTreeRecord->AddGestureProcedure(finger, event, "", state, disposal, DEFAULT_TIME_STAMP); ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); auto iter = eventTreeRecord->eventTreeList.back().gestureMap.find(finger); @@ -409,6 +452,13 @@ HWTEST_F(EventDumpTestNg, EventDumpTestNg010, TestSize.Level1) EXPECT_TRUE(dumpList.empty()); eventTreeRecord->Dump(dumpList, DEFAULT_DEPTH); EXPECT_FALSE(dumpList.empty()); + + std::unique_ptr dumpJson = JsonUtil::Create(true); + int32_t depth = 0; + int32_t startNumber = -1; + std::string header = "event tree_0"; + eventTreeRecord->Dump(dumpJson, depth, startNumber); + EXPECT_FALSE(dumpJson->Contains(header)); } /** @@ -589,5 +639,240 @@ HWTEST_F(EventDumpTestNg, EventDumpTestNg016, TestSize.Level1) int32_t startNumber = 1; eventTreeRecord->Dump(dumpList, DEFAULT_DEPTH, startNumber); EXPECT_FALSE(dumpList.empty()); + + std::unique_ptr dumpJson = JsonUtil::Create(true); + int32_t depth = 0; + std::string header = "event tree_0"; + eventTreeRecord->Dump(dumpJson, depth, startNumber); + EXPECT_TRUE(dumpJson->Contains(header)); +} + +/** + * @tc.name: EventDumpTestNg017 + * @tc.desc: AxisSnapshot dump function test. + * @tc.type: FUNC + */ +HWTEST_F(EventDumpTestNg, EventDumpTestNg017, TestSize.Level1) +{ + AxisEvent event; + const std::vector axisActionArray = {Ace::AxisAction::BEGIN, Ace::AxisAction::UPDATE, + Ace::AxisAction::END, Ace::AxisAction::CANCEL}; + std::unique_ptr dumpJson = JsonUtil::Create(true); + std::list> dumpList; + EXPECT_TRUE(dumpList.empty()); + + for (int32_t i = 0; i < axisActionArray.size(); ++i) { + event.action = axisActionArray[i]; + auto axisSnapshot = CreateAxisSnapshot(event); + ASSERT_NE(axisSnapshot, nullptr); + axisSnapshot->Dump(dumpList, DEFAULT_DEPTH + i); + axisSnapshot->Dump(dumpJson); + } + EXPECT_FALSE(dumpList.empty()); + EXPECT_TRUE(dumpJson->Contains("isInjected")); +} + +/** + * @tc.name: EventDumpTestNg018 + * @tc.desc: TouchPointSnapshot dump function test. + * @tc.type: FUNC + */ +HWTEST_F(EventDumpTestNg, EventDumpTestNg018, TestSize.Level1) +{ + /** + * @tc.steps: step1. create TouchPointSnapshot instance and init value. + */ + MockPipelineContext::SetUp(); + auto pipeline = NG::PipelineContext::GetCurrentContext(); + ASSERT_NE(pipeline, nullptr); + auto eventManager = pipeline->GetEventManager(); + ASSERT_NE(eventManager, nullptr); + int32_t fingerId = 1; + eventManager->downFingerIds_[fingerId] = 1; + TouchEvent event; + auto touchPointSnapshot = CreateTouchPointSnapshot(event); + ASSERT_NE(touchPointSnapshot, nullptr); + EXPECT_FALSE(touchPointSnapshot->downFingerIds.empty()); + + /** + * @tc.steps: step2. Invoke dump function. + * @tc.expected: dump list exist data, size is not empty. + */ + std::list> dumpList; + EXPECT_TRUE(dumpList.empty()); + touchPointSnapshot->Dump(dumpList, DEFAULT_DEPTH); + EXPECT_FALSE(dumpList.empty()); + + std::unique_ptr dumpJson = JsonUtil::Create(true); + touchPointSnapshot->Dump(dumpJson); + EXPECT_TRUE(dumpJson->Contains("downFingerIds")); + + MockPipelineContext::TearDown(); +} + +/** + * @tc.name: EventDumpTestNg019 + * @tc.desc: EventTreeRecord AddAxis function test. + * @tc.type: FUNC + */ +HWTEST_F(EventDumpTestNg, EventDumpTestNg019, TestSize.Level1) +{ + /** + * @tc.steps: step1. create EventTreeRecord instance. + */ + auto eventTreeRecord = CreateEventTreeRecord(); + ASSERT_NE(eventTreeRecord, nullptr); + + /** + * @tc.steps: step2. mock Axis event BEGIN to END. + */ + const std::vector axisActionArray = {Ace::AxisAction::BEGIN, Ace::AxisAction::END, + Ace::AxisAction::BEGIN, Ace::AxisAction::CANCEL}; + AxisEvent event; + int32_t eventTreeRecordCount = 1; + int32_t axisUpdateCount = 8; + for (int32_t i = 0; i < eventTreeRecordCount * axisUpdateCount; ++i) { + int32_t index = i % axisActionArray.size(); + event.action = axisActionArray[index]; + event.id = axisActionArray.size() > 0 ? i / axisActionArray.size() : i; + eventTreeRecord->AddAxis(event); + } + ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); + EXPECT_EQ(eventTreeRecord->eventTreeList.back().axisUpdateCount, (eventTreeRecordCount * axisUpdateCount) % 2); +} + +/** + * @tc.name: EventDumpTestNg020 + * @tc.desc: EventTreeRecord AddAxis function test. + * @tc.type: FUNC + */ +HWTEST_F(EventDumpTestNg, EventDumpTestNg020, TestSize.Level1) +{ + /** + * @tc.steps: step1. create EventTreeRecord instance. + */ + auto eventTreeRecord = CreateEventTreeRecord(); + ASSERT_NE(eventTreeRecord, nullptr); + AxisEvent event; + event.action = Ace::AxisAction::BEGIN; + event.id = 1; + + /** + * @tc.steps: step2. fill touch event vale to eventTree. + * @tc.expected: list is not empty. + */ + FillAxisUpdateEventToEventTree(eventTreeRecord, event, MAX_EVENT_TREE_RECORD_CNT + 1, + MAX_EVENT_TREE_AXIS_UPDATE_CNT, MAX_EVENT_TREE_AXIS_CNT + 1); + eventTreeRecord->AddAxis(event); + ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); + EXPECT_EQ(eventTreeRecord->eventTreeList.size(), MAX_EVENT_TREE_RECORD_CNT); +} + +/** + * @tc.name: EventDumpTestNg021 + * @tc.desc: EventTreeRecord AddAxis function test. + * @tc.type: FUNC + */ +HWTEST_F(EventDumpTestNg, EventDumpTestNg021, TestSize.Level1) +{ + /** + * @tc.steps: step1. create EventTreeRecord instance. + */ + auto eventTreeRecord = CreateEventTreeRecord(); + ASSERT_NE(eventTreeRecord, nullptr); + + /** + * @tc.steps: step2. mock Axis event END. + */ + AxisEvent event; + event.action = Ace::AxisAction::END; + eventTreeRecord->AddAxis(event); + EXPECT_TRUE(eventTreeRecord->eventTreeList.empty()); +} + +/** + * @tc.name: EventDumpTestNg022 + * @tc.desc: EventTreeRecord AddTouchPoint function test. + * @tc.type: FUNC + */ +HWTEST_F(EventDumpTestNg, EventDumpTestNg022, TestSize.Level1) +{ + /** + * @tc.steps: step1. create EventTreeRecord instance. + */ + auto eventTreeRecord = CreateEventTreeRecord(); + ASSERT_NE(eventTreeRecord, nullptr); + + /** + * @tc.steps: step2. mock touch event UP. + */ + TouchEvent event; + event.type = Ace::TouchType::UP; + eventTreeRecord->AddTouchPoint(event); + EXPECT_TRUE(eventTreeRecord->eventTreeList.empty()); +} + +/** + * @tc.name: EventDumpTestNg023 + * @tc.desc: EventTreeRecord AddGestureProcedure function test. + * @tc.type: FUNC + */ +HWTEST_F(EventDumpTestNg, EventDumpTestNg023, TestSize.Level1) +{ + /** + * @tc.steps: step1. create EventTreeRecord instance and fill touch event vale to eventTree. + */ + auto eventTreeRecord = CreateEventTreeRecord(); + ASSERT_NE(eventTreeRecord, nullptr); + AxisEvent event; + event.action = Ace::AxisAction::BEGIN; + event.id = 1; + eventTreeRecord->AddAxis(event); + AxisEvent event2; + event2.action = Ace::AxisAction::UPDATE; + event2.id = 2; + eventTreeRecord->AddAxis(event2); + AxisEvent event3; + event3.action = Ace::AxisAction::UPDATE; + event3.id = 3; + eventTreeRecord->AddAxis(event3); + + /** + * @tc.steps: step2. Invoke AddGestureProcedure function. + */ + auto gestureSnapshot = AceType::MakeRefPtr(); + int32_t finger = 0; + eventTreeRecord->AddGestureSnapshot(finger, std::move(gestureSnapshot)); + + std::string state = "current"; + std::string disposal = "mainThread"; + std::string state2 = "current2"; + std::string disposal2 = "mainThread2"; + eventTreeRecord->AddGestureProcedure(finger + 1, event, "", state, disposal, DEFAULT_TIME_STAMP); + ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); + auto iter = eventTreeRecord->eventTreeList.back().gestureMap.find(finger + 1); + EXPECT_TRUE(iter == eventTreeRecord->eventTreeList.back().gestureMap.end()); + + eventTreeRecord->AddGestureProcedure(finger, event, "", state, disposal, DEFAULT_TIME_STAMP); + eventTreeRecord->AddGestureProcedure(finger, event2, "", state, disposal, DEFAULT_TIME_STAMP); + eventTreeRecord->AddGestureProcedure(finger, event3, "", state2, disposal2, DEFAULT_TIME_STAMP); + + ASSERT_FALSE(eventTreeRecord->eventTreeList.empty()); + iter = eventTreeRecord->eventTreeList.back().gestureMap.find(finger); + ASSERT_TRUE(iter != eventTreeRecord->eventTreeList.back().gestureMap.end()); + ASSERT_TRUE(iter->second != nullptr); + EXPECT_FALSE(iter->second->stateHistory.empty()); + + std::list> dumpList; + EXPECT_TRUE(dumpList.empty()); + eventTreeRecord->Dump(dumpList, DEFAULT_DEPTH); + EXPECT_FALSE(dumpList.empty()); + + std::unique_ptr dumpJson = JsonUtil::Create(true); + int32_t depth = 0; + int32_t startNumber = -1; + std::string header = "event tree_0"; + eventTreeRecord->Dump(dumpJson, depth, startNumber); + EXPECT_FALSE(dumpJson->Contains(header)); } } // namespace OHOS::Ace::NG diff --git a/test/unittest/core/event/event_manager_test_ng.cpp b/test/unittest/core/event/event_manager_test_ng.cpp index d1cab9ac767..dc54eb9a9f3 100644 --- a/test/unittest/core/event/event_manager_test_ng.cpp +++ b/test/unittest/core/event/event_manager_test_ng.cpp @@ -448,6 +448,7 @@ HWTEST_F(EventManagerTestNg, EventManagerTest014, TestSize.Level1) event.action = AxisAction::BEGIN; Container::SetCurrentUsePartialUpdate(true); AceForwardCompatibility::isNewPipeline_ = true; + eventManager->TouchTest(event, frameNode, touchRestrict); eventManager->DispatchTouchEvent(event); auto container = Container::Current(); container->useNewPipeline_ = true; @@ -876,6 +877,11 @@ HWTEST_F(EventManagerTestNg, EventManagerTest023, TestSize.Level1) event.type = TouchType::UP; ret = eventManager->DispatchTouchEvent(event); EXPECT_TRUE(ret); + + event.id = 1; + eventManager->downFingerIds_[1] = 1; + ret = eventManager->DispatchTouchEvent(event); + EXPECT_FALSE(ret); } /** diff --git a/test/unittest/core/event/event_manager_test_ng.h b/test/unittest/core/event/event_manager_test_ng.h index 13ab2e2559f..d9c30e207a8 100644 --- a/test/unittest/core/event/event_manager_test_ng.h +++ b/test/unittest/core/event/event_manager_test_ng.h @@ -50,6 +50,7 @@ #include "core/components_ng/pattern/stage/page_pattern.h" #include "core/components_v2/inspector/inspector_constants.h" #include "core/event/ace_events.h" +#include "core/event/resample_algo.h" #include "core/event/axis_event.h" #include "core/event/key_event.h" #include "core/event/mouse_event.h" diff --git a/test/unittest/core/event/event_manager_test_ng_new.cpp b/test/unittest/core/event/event_manager_test_ng_new.cpp index 96af66d7030..4a886ced519 100644 --- a/test/unittest/core/event/event_manager_test_ng_new.cpp +++ b/test/unittest/core/event/event_manager_test_ng_new.cpp @@ -465,6 +465,10 @@ HWTEST_F(EventManagerTestNg, EventManagerTest043, TestSize.Level1) event.pullType = TouchType::PULL_MOVE; ret = eventManager->DispatchTouchEvent(event); EXPECT_FALSE(ret); + + event.type = TouchType::CANCEL; + ret = eventManager->DispatchTouchEvent(event); + EXPECT_FALSE(ret); } /** @@ -628,6 +632,11 @@ HWTEST_F(EventManagerTestNg, EventManagerTest048, TestSize.Level1) bool isMousePressAtSelectedNode = false; eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, 1); EXPECT_FALSE(isMousePressAtSelectedNode); + + EXPECT_EQ(touchTestIds.size(), 2); + auto num = std::stoi(touchTestIds.back()); + eventManager->GetTouchTestIds(event, touchTestIds, isMousePressAtSelectedNode, num); + EXPECT_FALSE(isMousePressAtSelectedNode); } /** @@ -757,8 +766,12 @@ HWTEST_F(EventManagerTestNg, EventManagerTest053, TestSize.Level1) eventManager->LogPrintMouseTest(); auto mouseEventTarget = AceType::MakeRefPtr(MOUSE, NODEID); - std::list> MouseTestResult = {mouseEventTarget}; + std::list> MouseTestResult = {}; eventManager->currMouseTestResultsMap_[0] = MouseTestResult; + eventManager->LogPrintMouseTest(); + MouseTestResult = {mouseEventTarget}; + eventManager->currMouseTestResultsMap_[0] = MouseTestResult; + eventManager->LogPrintMouseTest(); auto hoverEventTarget = AceType::MakeRefPtr(MOUSE, NODEID); std::list> HoverTestResult = {hoverEventTarget}; @@ -942,7 +955,12 @@ HWTEST_F(EventManagerTestNg, EventManagerTest060, TestSize.Level1) ASSERT_NE(eventManager, nullptr); int eventId = 1; bool logImmediately = true; + + SystemProperties::debugEnabled_ = false; + eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately); + EXPECT_TRUE(eventManager->lastReceivedEvent_.eventId == -1); + SystemProperties::debugEnabled_ = true; eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately); EXPECT_TRUE(eventManager->lastReceivedEvent_.eventId == -1); @@ -955,8 +973,16 @@ HWTEST_F(EventManagerTestNg, EventManagerTest060, TestSize.Level1) auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000; eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp; eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately); - EXPECT_TRUE(eventManager->lastReceivedEvent_.lastLogTimeStamp > currentTime); - + EXPECT_FALSE(eventManager->lastReceivedEvent_.lastLogTimeStamp > currentTime); + + eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp - 1; + eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately); + EXPECT_FALSE(eventManager->lastReceivedEvent_.lastLogTimeStamp == currentTime); + + SystemProperties::debugEnabled_ = false; + eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately); + EXPECT_FALSE(eventManager->lastReceivedEvent_.lastLogTimeStamp == currentTime); + eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000; eventManager->CheckAndLogLastReceivedEventInfo(eventId, logImmediately); EXPECT_TRUE(eventManager->lastReceivedEvent_.lastLogTimeStamp == lastLogTimeStamp + 20000); @@ -989,7 +1015,11 @@ HWTEST_F(EventManagerTestNg, EventManagerTest061, TestSize.Level1) auto lastLogTimeStamp = currentTime - 1000 * 1000000 - 1000; eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp; eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately); - EXPECT_TRUE(eventManager->lastConsumedEvent_.lastLogTimeStamp > currentTime); + EXPECT_FALSE(eventManager->lastConsumedEvent_.lastLogTimeStamp > currentTime); + + eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp - 1; + eventManager->CheckAndLogLastConsumedEventInfo(eventId, logImmediately); + EXPECT_FALSE(eventManager->lastConsumedEvent_.lastLogTimeStamp == currentTime); eventManager->lastReceivedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000; eventManager->lastConsumedEvent_.lastLogTimeStamp = lastLogTimeStamp + 20000; @@ -1305,14 +1335,29 @@ HWTEST_F(EventManagerTestNg, EventManagerTest070, TestSize.Level1) auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern); MouseEvent event; + TouchRestrict touchRestrict; + event.action = MouseAction::PULL_MOVE; + eventManager->MouseTest(event, pageNode, touchRestrict); + EXPECT_FALSE(touchRestrict.touchEvent.isMouseTouchTest); + + event.action = MouseAction::MOVE; + event.button = MouseButton::NONE_BUTTON; + eventManager->MouseTest(event, pageNode, touchRestrict); + EXPECT_FALSE(touchRestrict.touchEvent.isMouseTouchTest); + + event.action = MouseAction::PRESS; + event.button = MouseButton::LEFT_BUTTON; + eventManager->MouseTest(event, pageNode, touchRestrict); + EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest); + event.action = MouseAction::MOVE; event.button = MouseButton::RIGHT_BUTTON; - TouchRestrict touchRestrict; eventManager->MouseTest(event, pageNode, touchRestrict); event.action = MouseAction::WINDOW_ENTER; eventManager->MouseTest(event, pageNode, touchRestrict); - EXPECT_FALSE(touchRestrict.touchEvent.isMouseTouchTest); + EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest); + event.button = MouseButton::LEFT_BUTTON; eventManager->MouseTest(event, pageNode, touchRestrict); EXPECT_TRUE(touchRestrict.touchEvent.isMouseTouchTest); @@ -1615,6 +1660,16 @@ HWTEST_F(EventManagerTestNg, EventManagerAccessibilityHoverTest001, TestSize.Lev eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict); EXPECT_TRUE(eventManager->lastAccessibilityHoverResults_.empty()); EXPECT_TRUE(eventManager->curAccessibilityHoverResults_.empty()); + + /** + * @tc.steps: step4. Call MouseTest with MouseAction::HOVER + * @tc.expected: lastHoverTestResults_ is empty and currHoverTestResults_ is empty + */ + event.type = TouchType::HOVER_CANCEL; + eventManager->curAccessibilityHoverResults_.push_back(hoverEventTarget); + eventManager->AccessibilityHoverTest(event, frameNode, touchRestrict); + EXPECT_FALSE(eventManager->lastAccessibilityHoverResults_.empty()); + EXPECT_TRUE(eventManager->curAccessibilityHoverResults_.empty()); } /** @@ -2107,6 +2162,6 @@ HWTEST_F(EventManagerTestNg, DispatchTouchEventTest001, TestSize.Level1) event.type = TouchType::UP; eventManager->touchTestResults_.clear(); eventManager->DispatchTouchEvent(event, true); - EXPECT_NE(ret, !eventManager->touchTestResults_[event.id].empty()); + EXPECT_EQ(ret, !eventManager->touchTestResults_[event.id].empty()); } } // namespace OHOS::Ace::NG \ No newline at end of file diff --git a/test/unittest/core/event/event_manager_test_ng_two.cpp b/test/unittest/core/event/event_manager_test_ng_two.cpp index b9645f53ba3..698c09c961f 100644 --- a/test/unittest/core/event/event_manager_test_ng_two.cpp +++ b/test/unittest/core/event/event_manager_test_ng_two.cpp @@ -322,4 +322,1183 @@ HWTEST_F(EventManagerTestNg, AddTouchDelegate001, TestSize.Level1) EXPECT_FALSE(eventManager->touchDelegatesMap_.empty()); EXPECT_EQ(eventManager->touchDelegatesMap_[TOUCH_ID].size(), 1); } + +/** + * @tc.name: ExecuteTouchTestDoneCallbackTest009 + * @tc.desc: Test ExecuteTouchTestDoneCallbackTest function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, ExecuteTouchTestDoneCallbackTest009, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + TouchEvent touchEvent; + touchEvent.deviceId = 1; + touchEvent.force = 1.0f; + touchEvent.tiltX = 1.0f; + touchEvent.tiltY = 1.0f; + touchEvent.rollAngle = 1.0f; + touchEvent.pointers.push_back(TouchPoint()); + + ResponseLinkResult responseLinkRecognizers; + auto panHorizontal1 = AceType::MakeRefPtr( + DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); + + auto frameNode = FrameNode::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG, 0, nullptr); + ASSERT_NE(frameNode, nullptr); + auto eventHub = frameNode->GetOrCreateGestureEventHub(); + ASSERT_NE(eventHub, nullptr); + eventManager->onTouchTestDoneFrameNodeList_.emplace_back(WeakPtr(frameNode)); + eventManager->ExecuteTouchTestDoneCallback(touchEvent, responseLinkRecognizers); + EXPECT_FALSE(eventManager->onTouchTestDoneFrameNodeList_.empty()); +} + +/** + * @tc.name: EventManagerTestAxisEvent001 + * @tc.desc: Test TouchTest with FrameNode AxisEvent + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerTestAxisEvent001, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create EventManager. + * @tc.expected: eventManager is not null. + */ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + /** + * @tc.steps: step2. Create FrameNode and Call TouchTest + * @tc.expected: touchTestResults_ has the touchPoint.id of instance + */ + const int nodeId = 10002; + auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr); + TouchRestrict touchRestrict; + EXPECT_TRUE(eventManager->axisTouchTestResults_.empty()); + + std::vector actionVec = { AxisAction::NONE, AxisAction::BEGIN, AxisAction::UPDATE, AxisAction::END, + AxisAction::CANCEL }; + for (auto i = 0; i < actionVec.size(); ++i) { + AxisEvent axisEvent; + axisEvent.sourceType = SourceType::TOUCH; + axisEvent.action = actionVec[i]; + eventManager->TouchTest(axisEvent, frameNode, touchRestrict); + } + EXPECT_FALSE(eventManager->axisTouchTestResults_.empty()); +} + +/** + * @tc.name: EventManagerHandleGlobal001 + * @tc.desc: Test HandleGlobalEventNG + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerHandleGlobal001, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create EventManager. + * @tc.expected: eventManager is not null. + */ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + /** + * @tc.steps: step2. Do not Call TouchTest to add touchTestResults_[touchPoint.id] + * @tc.expected: touchTestResults_ has the touchPoint.id of instance + */ + TouchEvent touchPoint; + touchPoint.type = TouchType::DOWN; + touchPoint.sourceType = SourceType::MOUSE; + + const int nodeId = 10003; + auto frameNode = FrameNode::GetOrCreateFrameNode(V2::LOCATION_BUTTON_ETS_TAG, nodeId, nullptr); + + /** + * @tc.steps: step3. Create FrameNode and Call TouchTest to add touchTestResults_[touchPoint.id] + * @tc.expected: selectOverlayManager->touchTestResults_ is empty for do not have specific event + */ + EXPECT_TRUE(eventManager->touchTestResults_.empty()); + auto selectOverlayManager = AceType::MakeRefPtr(frameNode); + NG::OffsetF rootOffset; + eventManager->HandleGlobalEventNG(touchPoint, selectOverlayManager, rootOffset); + EXPECT_TRUE(selectOverlayManager->touchTestResults_.empty()); +} + +/** + * @tc.name: EventManagerHandleOut001 + * @tc.desc: Test HandleOutOfRectCallback + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerHandleOut001, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create EventManager. + * @tc.expected: eventManager is not null. + */ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + /** + * @tc.steps: step2. Create rectCallbackList + * @tc.expected: touchTestResults_ has the touchPoint.id of instance + */ + Point point(10, 20); + point.SetSourceType(SourceType::TOUCH); + + auto rectGetCallback1 = [](std::vector& rectList) -> void { rectList.push_back(Rect()); }; + auto rectGetCallback2 = [](std::vector& rectList) -> void { rectList.push_back(Rect(0, 0, 100, 100)); }; + + auto touchCallback = []() -> void {}; + auto mouseCallback = []() -> void {}; + std::vector rectCallbackList { RectCallback(rectGetCallback1, touchCallback, mouseCallback), + RectCallback(rectGetCallback2, touchCallback, mouseCallback), + RectCallback(nullptr, touchCallback, mouseCallback), RectCallback(rectGetCallback2, touchCallback, nullptr) }; + + /** + * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH + * @tc.expected: rectCallbackList.size() is 1 + */ + eventManager->HandleOutOfRectCallback(point, rectCallbackList); + EXPECT_EQ(rectCallbackList.size(), 3); + + /** + * @tc.steps: step4. Call HandleOutOfRectCallback with SourceType::MOUSE + * @tc.expected: rectCallbackList.size() is 0 + */ + point.SetSourceType(SourceType::MOUSE); + eventManager->HandleOutOfRectCallback(point, rectCallbackList); + EXPECT_FALSE(rectCallbackList.empty()); +} + +/** + * @tc.name: EventManagerFlushEnd001 + * @tc.desc: Test FlushTouchEventsEnd + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerFlushEnd001, TestSize.Level1) +{ + /** + * @tc.steps: step1. Create EventManager. + * @tc.expected: eventManager is not null. + */ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + auto resultId = ElementRegister::GetInstance()->MakeUniqueId(); + TouchTestResult touchTestResults; + + touchTestResults.push_back(AceType::MakeRefPtr()); + eventManager->touchTestResults_.emplace(resultId, touchTestResults); + + TouchEvent event {}; + event.id = 1; + std::list touchEvents { event }; + eventManager->FlushTouchEventsEnd(touchEvents); + EXPECT_EQ(eventManager->touchTestResults_.find(event.id), eventManager->touchTestResults_.end()); + + TouchEvent event2 {}; + event2.id = resultId; + event2.history.push_back(event); + std::list touchEvents2 { event2 }; + eventManager->FlushTouchEventsEnd(touchEvents2); + EXPECT_NE(eventManager->touchTestResults_.find(event2.id), eventManager->touchTestResults_.end()); +} + +/** + * @tc.name: EventManagerClearPenStylus001 + * @tc.desc: Test ClearTouchTestTargetForPenStylus func + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerClearPenStylus001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + auto resultId = ElementRegister::GetInstance()->MakeUniqueId(); + TouchTestResult touchTestResults; + auto panRecognizer = AceType::MakeRefPtr( + DEFAULT_PAN_FINGER, PanDirection { PanDirection::NONE }, DEFAULT_PAN_DISTANCE.ConvertToPx()); + touchTestResults.push_back(panRecognizer); + eventManager->touchTestResults_.emplace(resultId, touchTestResults); + TouchEvent event; + event.id = resultId; + RefPtr scope = AceType::MakeRefPtr(resultId); + ASSERT_NE(scope, nullptr); + ASSERT_NE(eventManager->refereeNG_, nullptr); + scope->AddMember(panRecognizer); + eventManager->refereeNG_->gestureScopes_.insert(std::make_pair(resultId, scope)); + eventManager->referee_->gestureScopes_.insert(std::make_pair(resultId, scope)); + eventManager->downFingerIds_[1] = 1; + eventManager->ClearTouchTestTargetForPenStylus(event); + EXPECT_EQ(event.id, 1); +} + +/** + * @tc.name: EventManagerClearHover001 + * @tc.desc: Test CleanHoverStatusForDragBegin. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerClearHover001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast(PlatformVersion::VERSION_TWELVE)); + + MouseEvent event; + TouchTestResult touchTestResults; + auto eventTarget = AceType::MakeRefPtr(); + touchTestResults.push_back(eventTarget); + eventManager->mouseTestResults_.emplace(event.id, touchTestResults); + eventManager->CleanHoverStatusForDragBegin(); + EXPECT_TRUE(eventManager->mouseTestResults_.empty()); +} + +/** + * @tc.name: EventManagerClearHover002 + * @tc.desc: Test CleanHoverStatusForDragBegin. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerClearHover002, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + AceApplicationInfo::GetInstance().SetApiTargetVersion(static_cast(PlatformVersion::VERSION_ELEVEN)); + + MouseEvent event; + TouchTestResult touchTestResults; + auto eventTarget = AceType::MakeRefPtr(); + touchTestResults.push_back(eventTarget); + eventManager->mouseTestResults_.emplace(event.id, touchTestResults); + eventManager->CleanHoverStatusForDragBegin(); + EXPECT_FALSE(eventManager->mouseTestResults_.empty()); +} + +/** + * @tc.name: EventManagerUpdateHover001 + * @tc.desc: Test UpdateAccessibilityHoverNode. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerUpdateHover001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + int32_t doneId = 0; + TouchEvent event; + TouchTestResult touchTestResults; + auto panRecognizer = AceType::MakeRefPtr( + DEFAULT_PAN_FINGER, PanDirection { PanDirection::NONE }, DEFAULT_PAN_DISTANCE.ConvertToPx()); + touchTestResults.push_back(panRecognizer); + eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); + EXPECT_EQ(doneId, 0); + + touchTestResults.clear(); + const int nodeId = 10008; + auto hoverEventTarget = AceType::MakeRefPtr(V2::LOCATION_BUTTON_ETS_TAG, nodeId); + touchTestResults.push_back(hoverEventTarget); + eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); + EXPECT_EQ(doneId, 0); + + touchTestResults.clear(); + hoverEventTarget->SetAccessibilityHoverCallback(nullptr); + touchTestResults.push_back(hoverEventTarget); + eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); + EXPECT_EQ(doneId, 0); + + touchTestResults.clear(); + auto OnAccessibilityHoverFunc = [&doneId](bool, AccessibilityHoverInfo& info) { ++doneId; }; + hoverEventTarget->SetAccessibilityHoverCallback(OnAccessibilityHoverFunc); + touchTestResults.push_back(hoverEventTarget); + eventManager->UpdateAccessibilityHoverNode(event, touchTestResults); + EXPECT_EQ(doneId, 0); +} + +/** + * @tc.name: EventManagerDispatchHover001 + * @tc.desc: Test HandleMouseHoverAnimation + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, EventManagerDispatchHover001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + MouseEvent event; + + eventManager->currHoverNode_ = nullptr; + eventManager->lastHoverNode_ = nullptr; + + event.action = MouseAction::WINDOW_ENTER; + eventManager->DispatchMouseHoverAnimationNG(event, true); + EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); + + event.action = MouseAction::WINDOW_LEAVE; + eventManager->DispatchMouseHoverAnimationNG(event, true); + EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); + + eventManager->currHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr); + eventManager->lastHoverNode_ = FrameNode::GetOrCreateFrameNode(CTRL, 0, nullptr); + + event.action = MouseAction::WINDOW_ENTER; + eventManager->DispatchMouseHoverAnimationNG(event, true); + EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); + + event.action = MouseAction::WINDOW_LEAVE; + eventManager->DispatchMouseHoverAnimationNG(event, true); + EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); +} + +/** + * @tc.name: CheckDifferentTargetDisplay001 + * @tc.desc: Test CheckDifferentTargetDisplay function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, CheckDifferentTargetDisplay001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(2); + + // all empty, CheckDifferentTargetDisplay == true + bool ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_TRUE(ret); + + // his empty, cur not empty + current.push_back(touchEvent1); + ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_TRUE(ret); + current.push_back(touchEvent1); + ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_TRUE(ret); + current.push_back(touchEvent2); + ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_FALSE(ret); + + // his not empty, cur empty + current.clear(); + history.push_back(touchEvent1); + ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_TRUE(ret); + history.push_back(touchEvent1); + ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_TRUE(ret); + history.push_back(touchEvent2); + ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_FALSE(ret); + + // his not empty, cur not empty + current.push_back(touchEvent1); + ret = eventManager->CheckDifferentTargetDisplay(history, current); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: OnNonPointerEvent001 + * @tc.desc: Test OnNonPointerEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, OnNonPointerEvent001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + NonPointerEvent event; + event.eventType = UIInputEventType::KEY; + auto ret = eventManager->OnNonPointerEvent(event); + EXPECT_FALSE(ret); + + event.eventType = UIInputEventType::FOCUS_AXIS; + ret = eventManager->OnNonPointerEvent(event); + EXPECT_FALSE(ret); + + event.eventType = UIInputEventType::CROWN; + ret = eventManager->OnNonPointerEvent(event); + EXPECT_FALSE(ret); + + event.eventType = UIInputEventType::TOUCH; + ret = eventManager->OnNonPointerEvent(event); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: CheckMousePendingRecognizersState001 + * @tc.desc: Test CheckMousePendingRecognizersState function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, CheckMousePendingRecognizersState001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + auto panHorizontal = AceType::MakeRefPtr( + DEFAULT_PAN_FINGER, PanDirection { PanDirection::HORIZONTAL }, DEFAULT_PAN_DISTANCE.ConvertToPx()); + panHorizontal->refereeState_ = RefereeState::SUCCEED; + + TouchEvent touchEvent; + touchEvent.sourceType = SourceType::MOUSE; + + eventManager->AddToMousePendingRecognizers(panHorizontal); + eventManager->CheckMousePendingRecognizersState(touchEvent); + EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); + + eventManager->CheckMousePendingRecognizersState(touchEvent); + EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); + + panHorizontal->refereeState_ = RefereeState::PENDING; + eventManager->AddToMousePendingRecognizers(panHorizontal); + eventManager->CheckMousePendingRecognizersState(touchEvent); + EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); + + panHorizontal->refereeState_ = RefereeState::PENDING_BLOCKED; + eventManager->AddToMousePendingRecognizers(panHorizontal); + eventManager->CheckMousePendingRecognizersState(touchEvent); + EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); + + touchEvent.sourceType = SourceType::TOUCH; + eventManager->AddToMousePendingRecognizers(panHorizontal); + eventManager->CheckMousePendingRecognizersState(touchEvent); + EXPECT_TRUE(eventManager->mousePendingRecognizers_.empty()); +} + +/** + * @tc.name: DumpEventWithCount001 + * @tc.desc: Test DumpEventWithCount function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, DumpEventWithCount001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + NG::EventTreeType type = EventTreeType::TOUCH; + bool hasJson = false; + std::string param0 = "dump"; + std::string param1 = "-n"; + std::string param2 = "0"; + std::string param3 = "any"; + std::string param4 = "-d"; + std::string param5 = "3"; + std::string param6 = "6"; + + std::vector params0 = { param0 }; + eventManager->DumpEventWithCount(params0, type, hasJson); + std::vector params1 = { param0, param1 }; + eventManager->DumpEventWithCount(params1, type, hasJson); + std::vector params2 = { param0, param1, param2 }; + eventManager->DumpEventWithCount(params2, type, hasJson); + std::vector params3 = { param0, param1, param2, param3 }; + eventManager->DumpEventWithCount(params3, type, hasJson); + std::vector params4 = { param0, param4, param2, param3 }; + eventManager->DumpEventWithCount(params3, type, hasJson); + std::vector params5 = { param0, param1, param6, param3 }; + eventManager->DumpEventWithCount(params5, type, hasJson); + std::vector params6 = { param0, param1, param5, param3 }; + eventManager->DumpEventWithCount(params6, type, hasJson); + EXPECT_FALSE(hasJson); +} + +/** + * @tc.name: TouchDelegate002 + * @tc.desc: Test TouchDelegate + */ +HWTEST_F(EventManagerTestNg, TouchDelegate002, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + int32_t touchId = -1; + auto delegater1 = AceType::MakeRefPtr(); + auto delegater2 = AceType::MakeRefPtr(); + + auto handler = eventManager->AddTouchDelegate(touchId, delegater1); + handler = eventManager->UpdateTouchDelegate(touchId, delegater2); + eventManager->touchDelegatesMap_.clear(); + eventManager->UnregisterTouchDelegate(handler); + EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); + + handler = eventManager->AddTouchDelegate(touchId, delegater1); + EXPECT_EQ(eventManager->touchDelegatesMap_[touchId].size(), 1); + eventManager->UnregisterTouchDelegate(touchId - 1); + eventManager->UnregisterTouchDelegate(touchId); + EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); + + TouchEvent touchEvent; + touchEvent.id = touchId; + eventManager->DelegateTouchEvent(touchEvent); +} + +/** + * @tc.name: TouchDelegate003 + * @tc.desc: Test TouchDelegate + */ +HWTEST_F(EventManagerTestNg, TouchDelegate003, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + int32_t touchId = 1; + auto delegater1 = AceType::MakeRefPtr(); + auto delegater2 = AceType::MakeRefPtr(); + + auto handler = eventManager->AddTouchDelegate(touchId, delegater1); + handler = eventManager->UpdateTouchDelegate(touchId, delegater2); + eventManager->touchDelegatesMap_.clear(); + eventManager->UnregisterTouchDelegate(handler); + EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); + + handler = eventManager->AddTouchDelegate(touchId, delegater1); + EXPECT_EQ(eventManager->touchDelegatesMap_[touchId].size(), 1); + eventManager->UnregisterTouchDelegate(touchId - 1); + eventManager->UnregisterTouchDelegate(touchId); + EXPECT_TRUE(eventManager->touchDelegatesMap_.empty()); + + TouchEvent touchEvent; + touchEvent.id = touchId; + eventManager->DelegateTouchEvent(touchEvent); +} + +/** + * @tc.name: TryResampleTouchEvent001 + * @tc.desc: Test TryResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, TryResampleTouchEvent001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(1); + + uint64_t resampleTime1 = 0.5 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + touchEvent1.time = ts1; + uint64_t resampleTime2 = 3 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds2(resampleTime2); + TimeStamp ts2(nanoseconds2); + touchEvent2.time = ts2; + current.push_back(touchEvent1); + current.push_back(touchEvent2); + TouchEvent resample; + uint64_t resampleTime = 4 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); + EXPECT_TRUE(ret); + + SystemProperties::debugEnabled_ = false; + ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: TryResampleTouchEvent002 + * @tc.desc: Test TryResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, TryResampleTouchEvent002, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent resample; + uint64_t resampleTime = 4 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); + EXPECT_FALSE(ret); + + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(2); + current.push_back(touchEvent1); + current.push_back(touchEvent2); + ret = eventManager->TryResampleTouchEvent(history, current, resampleTime, resample); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: GetResampleTouchEvent001 + * @tc.desc: Test GetResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleTouchEvent001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(1); + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + touchEvent1.time = ts1; + touchEvent2.time = ts1; + touchEvent2.x = 0.0f; + touchEvent2.y = 0.0f; + history.push_back(touchEvent1); + current.push_back(touchEvent2); + TouchEvent newEvent; + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + EXPECT_FALSE(ret); + + SystemProperties::debugEnabled_ = false; + ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: GetResampleTouchEvent002 + * @tc.desc: Test GetResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleTouchEvent002, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(1); + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + touchEvent1.time = ts1; + touchEvent2.time = ts1; + touchEvent2.x = 1.0f; + touchEvent2.y = 0.0f; + history.push_back(touchEvent1); + current.push_back(touchEvent2); + TouchEvent newEvent; + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: GetResampleTouchEvent003 + * @tc.desc: Test GetResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleTouchEvent003, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(1); + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + touchEvent1.time = ts1; + touchEvent2.time = ts1; + touchEvent2.x = 0.0f; + touchEvent2.y = 1.0f; + history.push_back(touchEvent1); + current.push_back(touchEvent2); + TouchEvent newEvent; + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: GetResampleTouchEvent004 + * @tc.desc: Test GetResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleTouchEvent004, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(1); + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + touchEvent1.time = ts1; + touchEvent2.time = ts1; + touchEvent2.x = 1.0f; + touchEvent2.y = 1.0f; + history.push_back(touchEvent1); + current.push_back(touchEvent2); + TouchEvent newEvent; + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + EXPECT_TRUE(ret); +} + +/** + * @tc.name: GetResampleTouchEvent005 + * @tc.desc: Test GetResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleTouchEvent005, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(2); + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + touchEvent1.time = ts1; + touchEvent2.time = ts1; + current.push_back(touchEvent1); + current.push_back(touchEvent2); + TouchEvent newEvent; + uint64_t resampleTime = 3 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: GetResampleTouchEvent006 + * @tc.desc: Test GetResampleTouchEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleTouchEvent006, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(2); + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + touchEvent1.time = ts1; + touchEvent2.time = ts1; + current.push_back(touchEvent1); + current.push_back(touchEvent2); + TouchEvent newEvent; + uint64_t resampleTime = 1 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + EXPECT_FALSE(ret); +} + +/** + * @tc.name: GetResampleMouseEvent001 + * @tc.desc: Test GetResampleMouseEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleMouseEvent001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + MouseEvent mouseEvent1; + mouseEvent1.targetDisplayId = 1; + MouseEvent mouseEvent2; + mouseEvent2.targetDisplayId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + mouseEvent1.time = ts1; + mouseEvent2.time = ts1; + mouseEvent2.x = 0.0f; + mouseEvent2.y = 0.0f; + history.push_back(mouseEvent1); + current.push_back(mouseEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, 0.0f); + + SystemProperties::debugEnabled_ = false; + mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, 0.0f); +} + +/** + * @tc.name: GetResampleMouseEvent002 + * @tc.desc: Test GetResampleMouseEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleMouseEvent002, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + MouseEvent mouseEvent1; + mouseEvent1.targetDisplayId = 1; + MouseEvent mouseEvent2; + mouseEvent2.targetDisplayId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + mouseEvent1.time = ts1; + mouseEvent2.time = ts1; + mouseEvent2.x = 1.0f; + mouseEvent2.y = 0.0f; + history.push_back(mouseEvent1); + current.push_back(mouseEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_NE(mouseEvent.x, 0.0f); +} + +/** + * @tc.name: GetResampleMouseEvent003 + * @tc.desc: Test GetResampleMouseEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleMouseEvent003, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + MouseEvent mouseEvent1; + mouseEvent1.targetDisplayId = 1; + MouseEvent mouseEvent2; + mouseEvent2.targetDisplayId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + mouseEvent1.time = ts1; + mouseEvent2.time = ts1; + mouseEvent2.x = 0.0f; + mouseEvent2.y = 1.0f; + history.push_back(mouseEvent1); + current.push_back(mouseEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, 0.0f); +} + +/** + * @tc.name: GetResampleMouseEvent004 + * @tc.desc: Test GetResampleMouseEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleMouseEvent004, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + std::vector history; + std::vector current; + MouseEvent mouseEvent1; + mouseEvent1.targetDisplayId = 1; + MouseEvent mouseEvent2; + mouseEvent2.targetDisplayId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + mouseEvent1.time = ts1; + mouseEvent2.time = ts1; + mouseEvent2.x = 1.0f; + mouseEvent2.y = 1.0f; + history.push_back(mouseEvent1); + current.push_back(mouseEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, 1.0f); +} + +/** + * @tc.name: GetResampleMouseEvent005 + * @tc.desc: Test GetResampleMouseEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleMouseEvent005, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + MouseEvent mouseEvent1; + mouseEvent1.targetDisplayId = 1; + MouseEvent mouseEvent2; + mouseEvent2.targetDisplayId = 2; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + mouseEvent1.time = ts1; + mouseEvent2.time = ts1; + current.push_back(mouseEvent1); + current.push_back(mouseEvent2); + uint64_t resampleTime = 3 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, 0.0f); +} + +/** + * @tc.name: GetResampleMouseEvent006 + * @tc.desc: Test GetResampleMouseEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResampleMouseEvent006, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + MouseEvent mouseEvent1; + mouseEvent1.targetDisplayId = 1; + MouseEvent mouseEvent2; + mouseEvent2.targetDisplayId = 2; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + mouseEvent1.time = ts1; + mouseEvent2.time = ts1; + current.push_back(mouseEvent1); + current.push_back(mouseEvent2); + uint64_t resampleTime = 1 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, 0.0f); +} + +/** + * + * @tc.name: GetResamplePointerEvent001 + * @tc.desc: Test GetResamplePointerEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent001, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + DragPointerEvent dragPointerEvent1; + dragPointerEvent1.targetWindowId = 1; + DragPointerEvent dragPointerEvent2; + dragPointerEvent2.targetWindowId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + dragPointerEvent1.time = ts1; + dragPointerEvent2.time = ts1; + dragPointerEvent2.x = 0.0f; + dragPointerEvent2.y = 0.0f; + history.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, 0.0f); + + SystemProperties::debugEnabled_ = false; + dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, 0.0f); +} + +/** + * @tc.name: GetResamplePointerEvent002 + * @tc.desc: Test GetResamplePointerEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent002, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + DragPointerEvent dragPointerEvent1; + dragPointerEvent1.targetWindowId = 1; + DragPointerEvent dragPointerEvent2; + dragPointerEvent2.targetWindowId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + dragPointerEvent1.time = ts1; + dragPointerEvent2.time = ts1; + dragPointerEvent2.x = 1.0f; + dragPointerEvent2.y = 0.0f; + history.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_NE(dragPointerEvent.x, 0.0f); +} + +/** + * @tc.name: GetResamplePointerEvent003 + * @tc.desc: Test GetResamplePointerEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent003, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + DragPointerEvent dragPointerEvent1; + dragPointerEvent1.targetWindowId = 1; + DragPointerEvent dragPointerEvent2; + dragPointerEvent2.targetWindowId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + dragPointerEvent1.time = ts1; + dragPointerEvent2.time = ts1; + dragPointerEvent2.x = 0.0f; + dragPointerEvent2.y = 1.0f; + history.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, 0.0f); +} + +/** + * @tc.name: GetResamplePointerEvent004 + * @tc.desc: Test GetResamplePointerEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent004, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + std::vector history; + std::vector current; + DragPointerEvent dragPointerEvent1; + dragPointerEvent1.targetWindowId = 1; + DragPointerEvent dragPointerEvent2; + dragPointerEvent2.targetWindowId = 1; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + dragPointerEvent1.time = ts1; + dragPointerEvent2.time = ts1; + dragPointerEvent2.x = 1.0f; + dragPointerEvent2.y = 1.0f; + history.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent2); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + + auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, 1.0f); +} + +/** + * @tc.name: GetResamplePointerEvent005 + * @tc.desc: Test GetResamplePointerEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent005, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + std::vector history; + std::vector current; + DragPointerEvent dragPointerEvent1; + dragPointerEvent1.targetWindowId = 1; + DragPointerEvent dragPointerEvent2; + dragPointerEvent2.targetWindowId = 2; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + dragPointerEvent1.time = ts1; + dragPointerEvent2.time = ts1; + current.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent2); + uint64_t resampleTime = 3 * 1000 * 1000; + + auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, 0.0f); +} + +/** + * @tc.name: GetResamplePointerEvent006 + * @tc.desc: Test GetResamplePointerEvent function. + * @tc.type: FUNC + */ +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent006, TestSize.Level1) +{ + auto eventManager = AceType::MakeRefPtr(); + ASSERT_NE(eventManager, nullptr); + + std::vector history; + std::vector current; + DragPointerEvent dragPointerEvent1; + dragPointerEvent1.targetWindowId = 1; + DragPointerEvent dragPointerEvent2; + dragPointerEvent2.targetWindowId = 2; + + uint64_t resampleTime1 = 2 * 1000 * 1000; + std::chrono::nanoseconds nanoseconds1(resampleTime1); + TimeStamp ts1(nanoseconds1); + dragPointerEvent1.time = ts1; + dragPointerEvent2.time = ts1; + current.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent2); + uint64_t resampleTime = 1 * 1000 * 1000; + + SystemProperties::debugEnabled_ = true; + auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, 0.0f); +} } // namespace OHOS::Ace::NG \ No newline at end of file -- Gitee From 07bbc08baa4da73d1602c3eb9c86eedc6e009c3b Mon Sep 17 00:00:00 2001 From: qingjy Date: Mon, 14 Jul 2025 20:47:29 +0800 Subject: [PATCH 2/3] delete template CheckDifferentTargetDisplay Signed-off-by: qingjy --- .../core/event/event_manager_test_ng_two.cpp | 50 ------------------- 1 file changed, 50 deletions(-) diff --git a/test/unittest/core/event/event_manager_test_ng_two.cpp b/test/unittest/core/event/event_manager_test_ng_two.cpp index 698c09c961f..354281897ef 100644 --- a/test/unittest/core/event/event_manager_test_ng_two.cpp +++ b/test/unittest/core/event/event_manager_test_ng_two.cpp @@ -644,56 +644,6 @@ HWTEST_F(EventManagerTestNg, EventManagerDispatchHover001, TestSize.Level1) EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); } -/** - * @tc.name: CheckDifferentTargetDisplay001 - * @tc.desc: Test CheckDifferentTargetDisplay function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, CheckDifferentTargetDisplay001, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - - std::vector history; - std::vector current; - TouchEvent touchEvent1; - touchEvent1.SetTargetDisplayId(1); - TouchEvent touchEvent2; - touchEvent2.SetTargetDisplayId(2); - - // all empty, CheckDifferentTargetDisplay == true - bool ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_TRUE(ret); - - // his empty, cur not empty - current.push_back(touchEvent1); - ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_TRUE(ret); - current.push_back(touchEvent1); - ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_TRUE(ret); - current.push_back(touchEvent2); - ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_FALSE(ret); - - // his not empty, cur empty - current.clear(); - history.push_back(touchEvent1); - ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_TRUE(ret); - history.push_back(touchEvent1); - ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_TRUE(ret); - history.push_back(touchEvent2); - ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_FALSE(ret); - - // his not empty, cur not empty - current.push_back(touchEvent1); - ret = eventManager->CheckDifferentTargetDisplay(history, current); - EXPECT_FALSE(ret); -} - /** * @tc.name: OnNonPointerEvent001 * @tc.desc: Test OnNonPointerEvent function. -- Gitee From e2afd4e3c2ab88c930724c4e685bb951316f6fd8 Mon Sep 17 00:00:00 2001 From: qingjy Date: Mon, 14 Jul 2025 23:03:17 +0800 Subject: [PATCH 3/3] delete dumplicate Signed-off-by: qingjy --- .../core/event/event_manager_test_ng_two.cpp | 511 +++++------------- 1 file changed, 131 insertions(+), 380 deletions(-) diff --git a/test/unittest/core/event/event_manager_test_ng_two.cpp b/test/unittest/core/event/event_manager_test_ng_two.cpp index 354281897ef..340c7ea86cb 100644 --- a/test/unittest/core/event/event_manager_test_ng_two.cpp +++ b/test/unittest/core/event/event_manager_test_ng_two.cpp @@ -449,9 +449,12 @@ HWTEST_F(EventManagerTestNg, EventManagerHandleOut001, TestSize.Level1) auto touchCallback = []() -> void {}; auto mouseCallback = []() -> void {}; - std::vector rectCallbackList { RectCallback(rectGetCallback1, touchCallback, mouseCallback), + std::vector rectCallbackList { + RectCallback(rectGetCallback1, touchCallback, mouseCallback), RectCallback(rectGetCallback2, touchCallback, mouseCallback), - RectCallback(nullptr, touchCallback, mouseCallback), RectCallback(rectGetCallback2, touchCallback, nullptr) }; + RectCallback(nullptr, touchCallback, mouseCallback), + RectCallback(rectGetCallback2, touchCallback, nullptr) + }; /** * @tc.steps: step3. Call HandleOutOfRectCallback with SourceType::TOUCH @@ -644,34 +647,6 @@ HWTEST_F(EventManagerTestNg, EventManagerDispatchHover001, TestSize.Level1) EXPECT_EQ(eventManager->currHoverNode_.Upgrade(), nullptr); } -/** - * @tc.name: OnNonPointerEvent001 - * @tc.desc: Test OnNonPointerEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, OnNonPointerEvent001, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - - NonPointerEvent event; - event.eventType = UIInputEventType::KEY; - auto ret = eventManager->OnNonPointerEvent(event); - EXPECT_FALSE(ret); - - event.eventType = UIInputEventType::FOCUS_AXIS; - ret = eventManager->OnNonPointerEvent(event); - EXPECT_FALSE(ret); - - event.eventType = UIInputEventType::CROWN; - ret = eventManager->OnNonPointerEvent(event); - EXPECT_FALSE(ret); - - event.eventType = UIInputEventType::TOUCH; - ret = eventManager->OnNonPointerEvent(event); - EXPECT_FALSE(ret); -} - /** * @tc.name: CheckMousePendingRecognizersState001 * @tc.desc: Test CheckMousePendingRecognizersState function. @@ -873,142 +848,6 @@ HWTEST_F(EventManagerTestNg, TryResampleTouchEvent002, TestSize.Level1) EXPECT_FALSE(ret); } -/** - * @tc.name: GetResampleTouchEvent001 - * @tc.desc: Test GetResampleTouchEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleTouchEvent001, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - TouchEvent touchEvent1; - touchEvent1.SetTargetDisplayId(1); - TouchEvent touchEvent2; - touchEvent2.SetTargetDisplayId(1); - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - touchEvent1.time = ts1; - touchEvent2.time = ts1; - touchEvent2.x = 0.0f; - touchEvent2.y = 0.0f; - history.push_back(touchEvent1); - current.push_back(touchEvent2); - TouchEvent newEvent; - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - SystemProperties::debugEnabled_ = true; - bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); - EXPECT_FALSE(ret); - - SystemProperties::debugEnabled_ = false; - ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); - EXPECT_FALSE(ret); -} - -/** - * @tc.name: GetResampleTouchEvent002 - * @tc.desc: Test GetResampleTouchEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleTouchEvent002, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - TouchEvent touchEvent1; - touchEvent1.SetTargetDisplayId(1); - TouchEvent touchEvent2; - touchEvent2.SetTargetDisplayId(1); - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - touchEvent1.time = ts1; - touchEvent2.time = ts1; - touchEvent2.x = 1.0f; - touchEvent2.y = 0.0f; - history.push_back(touchEvent1); - current.push_back(touchEvent2); - TouchEvent newEvent; - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - SystemProperties::debugEnabled_ = true; - bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); - EXPECT_FALSE(ret); -} - -/** - * @tc.name: GetResampleTouchEvent003 - * @tc.desc: Test GetResampleTouchEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleTouchEvent003, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - TouchEvent touchEvent1; - touchEvent1.SetTargetDisplayId(1); - TouchEvent touchEvent2; - touchEvent2.SetTargetDisplayId(1); - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - touchEvent1.time = ts1; - touchEvent2.time = ts1; - touchEvent2.x = 0.0f; - touchEvent2.y = 1.0f; - history.push_back(touchEvent1); - current.push_back(touchEvent2); - TouchEvent newEvent; - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - SystemProperties::debugEnabled_ = true; - bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); - EXPECT_FALSE(ret); -} - -/** - * @tc.name: GetResampleTouchEvent004 - * @tc.desc: Test GetResampleTouchEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleTouchEvent004, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - TouchEvent touchEvent1; - touchEvent1.SetTargetDisplayId(1); - TouchEvent touchEvent2; - touchEvent2.SetTargetDisplayId(1); - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - touchEvent1.time = ts1; - touchEvent2.time = ts1; - touchEvent2.x = 1.0f; - touchEvent2.y = 1.0f; - history.push_back(touchEvent1); - current.push_back(touchEvent2); - TouchEvent newEvent; - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - SystemProperties::debugEnabled_ = true; - bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); - EXPECT_TRUE(ret); -} - /** * @tc.name: GetResampleTouchEvent005 * @tc.desc: Test GetResampleTouchEvent function. @@ -1018,6 +857,7 @@ HWTEST_F(EventManagerTestNg, GetResampleTouchEvent005, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); + std::vector history; std::vector current; TouchEvent touchEvent1; @@ -1049,6 +889,7 @@ HWTEST_F(EventManagerTestNg, GetResampleTouchEvent006, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); + std::vector history; std::vector current; TouchEvent touchEvent1; @@ -1071,136 +912,6 @@ HWTEST_F(EventManagerTestNg, GetResampleTouchEvent006, TestSize.Level1) EXPECT_FALSE(ret); } -/** - * @tc.name: GetResampleMouseEvent001 - * @tc.desc: Test GetResampleMouseEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleMouseEvent001, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - MouseEvent mouseEvent1; - mouseEvent1.targetDisplayId = 1; - MouseEvent mouseEvent2; - mouseEvent2.targetDisplayId = 1; - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - mouseEvent1.time = ts1; - mouseEvent2.time = ts1; - mouseEvent2.x = 0.0f; - mouseEvent2.y = 0.0f; - history.push_back(mouseEvent1); - current.push_back(mouseEvent2); - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - SystemProperties::debugEnabled_ = true; - auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); - EXPECT_EQ(mouseEvent.x, 0.0f); - - SystemProperties::debugEnabled_ = false; - mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); - EXPECT_EQ(mouseEvent.x, 0.0f); -} - -/** - * @tc.name: GetResampleMouseEvent002 - * @tc.desc: Test GetResampleMouseEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleMouseEvent002, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - MouseEvent mouseEvent1; - mouseEvent1.targetDisplayId = 1; - MouseEvent mouseEvent2; - mouseEvent2.targetDisplayId = 1; - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - mouseEvent1.time = ts1; - mouseEvent2.time = ts1; - mouseEvent2.x = 1.0f; - mouseEvent2.y = 0.0f; - history.push_back(mouseEvent1); - current.push_back(mouseEvent2); - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); - EXPECT_NE(mouseEvent.x, 0.0f); -} - -/** - * @tc.name: GetResampleMouseEvent003 - * @tc.desc: Test GetResampleMouseEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleMouseEvent003, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - MouseEvent mouseEvent1; - mouseEvent1.targetDisplayId = 1; - MouseEvent mouseEvent2; - mouseEvent2.targetDisplayId = 1; - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - mouseEvent1.time = ts1; - mouseEvent2.time = ts1; - mouseEvent2.x = 0.0f; - mouseEvent2.y = 1.0f; - history.push_back(mouseEvent1); - current.push_back(mouseEvent2); - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); - EXPECT_EQ(mouseEvent.x, 0.0f); -} - -/** - * @tc.name: GetResampleMouseEvent004 - * @tc.desc: Test GetResampleMouseEvent function. - * @tc.type: FUNC - */ -HWTEST_F(EventManagerTestNg, GetResampleMouseEvent004, TestSize.Level1) -{ - auto eventManager = AceType::MakeRefPtr(); - ASSERT_NE(eventManager, nullptr); - - std::vector history; - std::vector current; - MouseEvent mouseEvent1; - mouseEvent1.targetDisplayId = 1; - MouseEvent mouseEvent2; - mouseEvent2.targetDisplayId = 1; - - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - mouseEvent1.time = ts1; - mouseEvent2.time = ts1; - mouseEvent2.x = 1.0f; - mouseEvent2.y = 1.0f; - history.push_back(mouseEvent1); - current.push_back(mouseEvent2); - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); - EXPECT_EQ(mouseEvent.x, 1.0f); -} - /** * @tc.name: GetResampleMouseEvent005 * @tc.desc: Test GetResampleMouseEvent function. @@ -1210,6 +921,7 @@ HWTEST_F(EventManagerTestNg, GetResampleMouseEvent005, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); + std::vector history; std::vector current; MouseEvent mouseEvent1; @@ -1240,6 +952,7 @@ HWTEST_F(EventManagerTestNg, GetResampleMouseEvent006, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); + std::vector history; std::vector current; MouseEvent mouseEvent1; @@ -1261,194 +974,232 @@ HWTEST_F(EventManagerTestNg, GetResampleMouseEvent006, TestSize.Level1) EXPECT_EQ(mouseEvent.x, 0.0f); } + + /** - * - * @tc.name: GetResamplePointerEvent001 + * @tc.name: GetResamplePointerEvent005 * @tc.desc: Test GetResamplePointerEvent function. * @tc.type: FUNC */ -HWTEST_F(EventManagerTestNg, GetResamplePointerEvent001, TestSize.Level1) +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent005, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); + std::vector history; std::vector current; DragPointerEvent dragPointerEvent1; dragPointerEvent1.targetWindowId = 1; DragPointerEvent dragPointerEvent2; - dragPointerEvent2.targetWindowId = 1; + dragPointerEvent2.targetWindowId = 2; uint64_t resampleTime1 = 2 * 1000 * 1000; std::chrono::nanoseconds nanoseconds1(resampleTime1); TimeStamp ts1(nanoseconds1); dragPointerEvent1.time = ts1; dragPointerEvent2.time = ts1; - dragPointerEvent2.x = 0.0f; - dragPointerEvent2.y = 0.0f; - history.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent1); current.push_back(dragPointerEvent2); - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + uint64_t resampleTime = 3 * 1000 * 1000; SystemProperties::debugEnabled_ = true; auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); EXPECT_EQ(dragPointerEvent.x, 0.0f); - - SystemProperties::debugEnabled_ = false; - dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); - EXPECT_EQ(dragPointerEvent.x, 0.0f); } /** - * @tc.name: GetResamplePointerEvent002 + * @tc.name: GetResamplePointerEvent006 * @tc.desc: Test GetResamplePointerEvent function. * @tc.type: FUNC */ -HWTEST_F(EventManagerTestNg, GetResamplePointerEvent002, TestSize.Level1) +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent006, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); + std::vector history; std::vector current; DragPointerEvent dragPointerEvent1; dragPointerEvent1.targetWindowId = 1; DragPointerEvent dragPointerEvent2; - dragPointerEvent2.targetWindowId = 1; + dragPointerEvent2.targetWindowId = 2; uint64_t resampleTime1 = 2 * 1000 * 1000; std::chrono::nanoseconds nanoseconds1(resampleTime1); TimeStamp ts1(nanoseconds1); dragPointerEvent1.time = ts1; dragPointerEvent2.time = ts1; - dragPointerEvent2.x = 1.0f; - dragPointerEvent2.y = 0.0f; - history.push_back(dragPointerEvent1); + current.push_back(dragPointerEvent1); current.push_back(dragPointerEvent2); - uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; + uint64_t resampleTime = 1 * 1000 * 1000; + SystemProperties::debugEnabled_ = true; auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); - EXPECT_NE(dragPointerEvent.x, 0.0f); + EXPECT_EQ(dragPointerEvent.x, 0.0f); } /** - * @tc.name: GetResamplePointerEvent003 - * @tc.desc: Test GetResamplePointerEvent function. + * @tc.name: GetResampleTouchEvent0012 + * @tc.desc: Test GetResampleTouchEvent function. * @tc.type: FUNC */ -HWTEST_F(EventManagerTestNg, GetResamplePointerEvent003, TestSize.Level1) +HWTEST_F(EventManagerTestNg, GetResampleTouchEvent0012, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - DragPointerEvent dragPointerEvent1; - dragPointerEvent1.targetWindowId = 1; - DragPointerEvent dragPointerEvent2; - dragPointerEvent2.targetWindowId = 1; + std::vector history; + std::vector current; + TouchEvent touchEvent1; + touchEvent1.SetTargetDisplayId(1); + TouchEvent touchEvent2; + touchEvent2.SetTargetDisplayId(1); uint64_t resampleTime1 = 2 * 1000 * 1000; std::chrono::nanoseconds nanoseconds1(resampleTime1); TimeStamp ts1(nanoseconds1); - dragPointerEvent1.time = ts1; - dragPointerEvent2.time = ts1; - dragPointerEvent2.x = 0.0f; - dragPointerEvent2.y = 1.0f; - history.push_back(dragPointerEvent1); - current.push_back(dragPointerEvent2); + touchEvent1.time = ts1; + touchEvent2.time = ts1; + history.push_back(touchEvent1); + + TouchEvent newEvent; uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - - auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); - EXPECT_EQ(dragPointerEvent.x, 0.0f); + std::vector> xyVec = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}}; + for (auto xy : xyVec) { + current.clear(); + touchEvent2.x = xy.first; + touchEvent2.y = xy.second; + current.push_back(touchEvent2); + + SystemProperties::debugEnabled_ = true; + bool ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + if (xy.first == 1.0f && xy.second == 1.0f) { + EXPECT_TRUE(ret); + } else { + EXPECT_FALSE(ret); + } + + SystemProperties::debugEnabled_ = false; + ret = eventManager->GetResampleTouchEvent(history, current, resampleTime, newEvent); + if (xy.first == 1.0f && xy.second == 1.0f) { + EXPECT_TRUE(ret); + } else { + EXPECT_FALSE(ret); + } + } } /** - * @tc.name: GetResamplePointerEvent004 - * @tc.desc: Test GetResamplePointerEvent function. + * @tc.name: GetResampleMouseEvent0012 + * @tc.desc: Test GetResampleMouseEvent function. * @tc.type: FUNC */ -HWTEST_F(EventManagerTestNg, GetResamplePointerEvent004, TestSize.Level1) +HWTEST_F(EventManagerTestNg, GetResampleMouseEvent0012, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); - - std::vector history; - std::vector current; - DragPointerEvent dragPointerEvent1; - dragPointerEvent1.targetWindowId = 1; - DragPointerEvent dragPointerEvent2; - dragPointerEvent2.targetWindowId = 1; + std::vector history; + std::vector current; + MouseEvent mouseEvent1; + mouseEvent1.targetDisplayId = 1; + MouseEvent mouseEvent2; + mouseEvent2.targetDisplayId = 1; uint64_t resampleTime1 = 2 * 1000 * 1000; std::chrono::nanoseconds nanoseconds1(resampleTime1); TimeStamp ts1(nanoseconds1); - dragPointerEvent1.time = ts1; - dragPointerEvent2.time = ts1; - dragPointerEvent2.x = 1.0f; - dragPointerEvent2.y = 1.0f; - history.push_back(dragPointerEvent1); - current.push_back(dragPointerEvent2); + mouseEvent1.time = ts1; + mouseEvent2.time = ts1; + history.push_back(mouseEvent1); uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); - EXPECT_EQ(dragPointerEvent.x, 1.0f); + std::vector> xyVec = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}}; + for (auto xy : xyVec) { + current.clear(); + mouseEvent2.x = xy.first; + mouseEvent2.y = xy.second; + current.push_back(mouseEvent2); + + SystemProperties::debugEnabled_ = true; + auto mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, xy.first); + + SystemProperties::debugEnabled_ = false; + mouseEvent = eventManager->GetResampleMouseEvent(history, current, resampleTime); + EXPECT_EQ(mouseEvent.x, xy.first); + } } /** - * @tc.name: GetResamplePointerEvent005 + * + * @tc.name: GetResamplePointerEvent0012 * @tc.desc: Test GetResamplePointerEvent function. * @tc.type: FUNC */ -HWTEST_F(EventManagerTestNg, GetResamplePointerEvent005, TestSize.Level1) +HWTEST_F(EventManagerTestNg, GetResamplePointerEvent0012, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); + std::vector history; std::vector current; DragPointerEvent dragPointerEvent1; dragPointerEvent1.targetWindowId = 1; DragPointerEvent dragPointerEvent2; - dragPointerEvent2.targetWindowId = 2; + dragPointerEvent2.targetWindowId = 1; uint64_t resampleTime1 = 2 * 1000 * 1000; std::chrono::nanoseconds nanoseconds1(resampleTime1); TimeStamp ts1(nanoseconds1); dragPointerEvent1.time = ts1; dragPointerEvent2.time = ts1; - current.push_back(dragPointerEvent1); - current.push_back(dragPointerEvent2); - uint64_t resampleTime = 3 * 1000 * 1000; + history.push_back(dragPointerEvent1); + uint64_t resampleTime = 3 * 1000 * 1000 + 20 * 1000 * 1000; - auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); - EXPECT_EQ(dragPointerEvent.x, 0.0f); + std::vector> xyVec = {{0.0f, 0.0f}, {1.0f, 0.0f}, {0.0f, 1.0f}, {1.0f, 1.0f}}; + for (auto xy : xyVec) { + current.clear(); + dragPointerEvent2.x = xy.first; + dragPointerEvent2.y = xy.second; + current.push_back(dragPointerEvent2); + + SystemProperties::debugEnabled_ = true; + auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, xy.first); + + SystemProperties::debugEnabled_ = false; + dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); + EXPECT_EQ(dragPointerEvent.x, xy.first); + } } /** - * @tc.name: GetResamplePointerEvent006 - * @tc.desc: Test GetResamplePointerEvent function. + * @tc.name: OnNonPointerEvent001 + * @tc.desc: Test OnNonPointerEvent function. * @tc.type: FUNC */ -HWTEST_F(EventManagerTestNg, GetResamplePointerEvent006, TestSize.Level1) +HWTEST_F(EventManagerTestNg, OnNonPointerEvent001, TestSize.Level1) { auto eventManager = AceType::MakeRefPtr(); ASSERT_NE(eventManager, nullptr); - std::vector history; - std::vector current; - DragPointerEvent dragPointerEvent1; - dragPointerEvent1.targetWindowId = 1; - DragPointerEvent dragPointerEvent2; - dragPointerEvent2.targetWindowId = 2; + NonPointerEvent event; + event.eventType = UIInputEventType::KEY; + auto ret = eventManager->OnNonPointerEvent(event); + EXPECT_FALSE(ret); - uint64_t resampleTime1 = 2 * 1000 * 1000; - std::chrono::nanoseconds nanoseconds1(resampleTime1); - TimeStamp ts1(nanoseconds1); - dragPointerEvent1.time = ts1; - dragPointerEvent2.time = ts1; - current.push_back(dragPointerEvent1); - current.push_back(dragPointerEvent2); - uint64_t resampleTime = 1 * 1000 * 1000; + NonPointerEvent event2; + event2.eventType = UIInputEventType::FOCUS_AXIS; + ret = eventManager->OnNonPointerEvent(event2); + EXPECT_FALSE(ret); - SystemProperties::debugEnabled_ = true; - auto dragPointerEvent = eventManager->GetResamplePointerEvent(history, current, resampleTime); - EXPECT_EQ(dragPointerEvent.x, 0.0f); + NonPointerEvent event3; + event3.eventType = UIInputEventType::CROWN; + ret = eventManager->OnNonPointerEvent(event3); + EXPECT_FALSE(ret); + + NonPointerEvent event4; + event4.eventType = UIInputEventType::TOUCH; + ret = eventManager->OnNonPointerEvent(event4); + EXPECT_FALSE(ret); } } // namespace OHOS::Ace::NG \ No newline at end of file -- Gitee