1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <cstddef>
17 #include <cstdint>
18 #include <unistd.h>
19 
20 #include "gtest/gtest.h"
21 
22 #define private public
23 #define protected public
24 #include "test/mock/base/mock_task_executor.h"
25 #include "test/mock/core/pipeline/mock_pipeline_context.h"
26 
27 #include "core/components_ng/event/state_style_manager.h"
28 #include "core/components_ng/pattern/list/list_pattern.h"
29 #include "core/components_ng/pattern/navrouter/navdestination_pattern.h"
30 #include "core/components_ng/pattern/pattern.h"
31 #include "core/components_ng/pattern/swiper/swiper_pattern.h"
32 #include "core/event/ace_events.h"
33 
34 using namespace testing;
35 using namespace testing::ext;
36 
37 namespace OHOS::Ace::NG {
38 class StateStyleManagerTestNg : public testing::Test {
39 public:
40     static void SetUpTestSuite();
41     static void TearDownTestSuite();
42     void SetUp() override;
43     void TearDown() override;
44 };
45 
SetUpTestSuite()46 void StateStyleManagerTestNg::SetUpTestSuite()
47 {
48     GTEST_LOG_(INFO) << "StateStyleManagerTestNg SetUpTestCase";
49 }
50 
TearDownTestSuite()51 void StateStyleManagerTestNg::TearDownTestSuite()
52 {
53     GTEST_LOG_(INFO) << "StateStyleManagerTestNg TearDownTestCase";
54 }
55 
SetUp()56 void StateStyleManagerTestNg::SetUp()
57 {
58     MockPipelineContext::SetUp();
59 }
60 
TearDown()61 void StateStyleManagerTestNg::TearDown()
62 {
63     MockPipelineContext::TearDown();
64 }
65 
66 /**
67  * @tc.name: StateStyleTest001
68  * @tc.desc: Create StateStyleManager and execute pressed listener.
69  * @tc.type: FUNC
70  */
71 HWTEST_F(StateStyleManagerTestNg, StateStyleTest001, TestSize.Level1)
72 {
73     /**
74      * @tc.steps: step1. Create state style manger.
75      * @tc.expected: State style pressed listener is valid.
76      */
77     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
78     EXPECT_NE(frameNode, nullptr);
79     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
80     EXPECT_NE(stateStyleMgr, nullptr);
81     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
82     auto callback = stateStyleMgr->GetPressedListener();
83     EXPECT_NE(callback, nullptr);
84 
85     /**
86      * @tc.steps: step2. Create touch down event and execute it.
87      * @tc.expected: Should change to pressed state.
88      */
89 
90     TouchEventInfo touchEventInfo = TouchEventInfo("touch");
91     TouchLocationInfo touchLocationInfo = TouchLocationInfo(1);
92     touchLocationInfo.SetLocalLocation(Offset(100.0, 100.0));
93     touchLocationInfo.SetTouchType(TouchType::DOWN);
94     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
95     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
96 
97     (*callback)(touchEventInfo);
98     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
99 
100     /**
101      * @tc.steps: step3. Create touch up event and execute it.
102      * @tc.expected: Should cancel pressed state.
103      */
104 
105     touchLocationInfo.SetTouchType(TouchType::UP);
106     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
107     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
108 
109     (*callback)(touchEventInfo);
110     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
111 }
112 
113 /**
114  * @tc.name: StateStyleTest002
115  * @tc.desc: Create StateStyleManager and execute pressed listener when multi fingers.
116  * @tc.type: FUNC
117  */
118 HWTEST_F(StateStyleManagerTestNg, StateStyleTest002, TestSize.Level1)
119 {
120     /**
121      * @tc.steps: step1. Create state style manger.
122      * @tc.expected: State style pressed listener is valid.
123      */
124     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
125     EXPECT_NE(frameNode, nullptr);
126     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
127     EXPECT_NE(stateStyleMgr, nullptr);
128     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
129     auto callback = stateStyleMgr->GetPressedListener();
130     EXPECT_NE(callback, nullptr);
131 
132     /**
133      * @tc.steps: step2. One finger touch down.
134      * @tc.expected: Should change to pressed state.
135      */
136 
137     TouchEventInfo touchEventInfo = TouchEventInfo("touch");
138     TouchLocationInfo touchLocationInfo1 = TouchLocationInfo(1);
139     touchLocationInfo1.SetLocalLocation(Offset(100.0, 100.0));
140     touchLocationInfo1.SetTouchType(TouchType::DOWN);
141     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo1));
142     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo1));
143 
144     (*callback)(touchEventInfo);
145     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
146 
147     /**
148      * @tc.steps: step3. One more finger touch down.
149      * @tc.expected: Should hold on pressed state.
150      */
151 
152     TouchLocationInfo touchLocationInfo2 = TouchLocationInfo(2);
153     touchLocationInfo2.SetLocalLocation(Offset(100.0, 100.0));
154     touchLocationInfo2.SetTouchType(TouchType::DOWN);
155     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo2));
156     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo2));
157 
158     (*callback)(touchEventInfo);
159     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
160 
161     /**
162      * @tc.steps: step4. One finger touch up.
163      * @tc.expected: Should hold on pressed state.
164      */
165 
166     touchLocationInfo1.SetTouchType(TouchType::UP);
167     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo1));
168     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo1));
169 
170     (*callback)(touchEventInfo);
171     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
172 
173     /**
174      * @tc.steps: step5. One more finger touch up.
175      * @tc.expected: Should cancel pressed state.
176      */
177 
178     touchLocationInfo2.SetTouchType(TouchType::UP);
179     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo2));
180     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo2));
181 
182     (*callback)(touchEventInfo);
183     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
184 }
185 
186 /**
187  * @tc.name: StateStyleTest003
188  * @tc.desc: Create StateStyleManager and execute its functions.
189  * @tc.type: FUNC
190  */
191 HWTEST_F(StateStyleManagerTestNg, StateStyleTest003, TestSize.Level1)
192 {
193     /**
194      * @tc.steps: step1. Create state style manger.
195      * @tc.expected: Should have no scrolling parent.
196      */
197     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
198     EXPECT_NE(frameNode, nullptr);
199     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
200     EXPECT_NE(stateStyleMgr, nullptr);
201     stateStyleMgr->HandleScrollingParent();
202     bool hasScrollingParent = stateStyleMgr->GetHasScrollingParent();
203     EXPECT_EQ(false, hasScrollingParent);
204 
205     /**
206      * @tc.steps: step2. Set parent to current frame node.
207      * @tc.expected:  Should have scrolling parent.
208      */
209 
210     auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
211     EXPECT_NE(parent, nullptr);
212     frameNode->SetParent(parent);
213     stateStyleMgr->HandleScrollingParent();
214     hasScrollingParent = stateStyleMgr->GetHasScrollingParent();
215     EXPECT_EQ(true, hasScrollingParent);
216 }
217 
218 /**
219  * @tc.name: StateStyleTest004
220  * @tc.desc: Create StateStyleManager and execute its functions.
221  * @tc.type: FUNC
222  */
223 HWTEST_F(StateStyleManagerTestNg, StateStyleTest004, TestSize.Level1)
224 {
225     /**
226      * @tc.steps: step1. Create state style manger.
227      * @tc.expected: State style pressed listener is valid.
228      */
229     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
230     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
231     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
232     auto callback = stateStyleMgr->GetPressedListener();
233     EXPECT_NE(callback, nullptr);
234     auto callback2 = stateStyleMgr->GetPressedListener();
235     EXPECT_EQ(callback, callback2);
236 
237     /**
238      * @tc.steps: step2. Create condition that touches.empty()  changeTouches.empty()
239      * @tc.expected: State style pressed listener is valid.
240      */
241     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
242     TouchEventInfo touchEventInfo = TouchEventInfo("touch");
243     (*callback)(touchEventInfo);
244     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
245 
246     /**
247      * @tc.steps: step3. Create condition that touches.empty()=false  changeTouches.empty true
248      * @tc.expected: State style pressed listener is valid.
249      */
250     TouchLocationInfo touchLocationInfo = TouchLocationInfo(1);
251     touchLocationInfo.SetLocalLocation(Offset(100.0, 100.0));
252     touchLocationInfo.SetTouchType(TouchType::CANCEL);
253     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
254     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
255     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
256     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
257     (*callback)(touchEventInfo);
258     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
259 
260     /**
261      * @tc.steps: step3. Create condition that touches.empty false  changeTouches.empty false
262      * @tc.expected: State style pressed listener is valid.
263      */
264     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
265     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
266     (*callback)(touchEventInfo);
267     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
268 }
269 
270 /**
271  * @tc.name: StateStyleTest005
272  * @tc.desc: Create StateStyleManager and execute its functions.
273  * @tc.type: FUNC
274  */
275 HWTEST_F(StateStyleManagerTestNg, StateStyleTest005, TestSize.Level1)
276 {
277     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
278     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
279     auto callback = stateStyleMgr->GetPressedListener();
280     EXPECT_NE(callback, nullptr);
281     auto callback2 = stateStyleMgr->GetPressedListener();
282     EXPECT_EQ(callback, callback2);
283 
284     TouchEventInfo touchEventInfo = TouchEventInfo("touch");
285     TouchLocationInfo touchLocationInfo = TouchLocationInfo(1);
286     touchLocationInfo.SetLocalLocation(Offset(-100.0, -100.0));
287     touchLocationInfo.SetTouchType(TouchType::MOVE);
288     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
289     touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
290     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
291     stateStyleMgr->ResetPressedPendingState();
292     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
293     (*callback)(touchEventInfo);
294     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
295 
296     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, false);
297     stateStyleMgr->ResetPressedPendingState();
298     (*callback)(touchEventInfo);
299     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
300 }
301 
302 /**
303  * @tc.name: StateStyleTest006
304  * @tc.desc: Test HandleTouchDown function.
305  * @tc.type: FUNC
306  */
307 HWTEST_F(StateStyleManagerTestNg, StateStyleTest006, TestSize.Level1)
308 {
309     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
310     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
311     stateStyleMgr->SetSupportedStates(UI_STATE_NORMAL);
312     stateStyleMgr->HandleTouchDown();
313     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
314 
315     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
316     stateStyleMgr->HandleTouchDown();
317     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
318 
319     auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
320     EXPECT_NE(parent, nullptr);
321     frameNode->SetParent(parent);
322     stateStyleMgr->PendingCancelPressedState();
323     EXPECT_EQ(true, stateStyleMgr->IsPressedCancelStatePending());
324     stateStyleMgr->HandleTouchDown();
325     EXPECT_EQ(false, stateStyleMgr->IsPressedCancelStatePending());
326     EXPECT_EQ(true, stateStyleMgr->IsPressedStatePending());
327 
328     stateStyleMgr->ResetPressedCancelPendingState();
329     stateStyleMgr->HandleTouchDown();
330     EXPECT_EQ(false, stateStyleMgr->IsPressedCancelStatePending());
331     EXPECT_EQ(true, stateStyleMgr->IsPressedStatePending());
332 }
333 
334 /**
335  * @tc.name: StateStyleTest007
336  * @tc.desc: Test HandleTouchUp function.
337  * @tc.type: FUNC
338  */
339 HWTEST_F(StateStyleManagerTestNg, StateStyleTest007, TestSize.Level1)
340 {
341     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
342     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
343     auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
344     EXPECT_NE(parent, nullptr);
345     frameNode->SetParent(parent);
346 
347     stateStyleMgr->PendingPressedState();
348     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
349     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
350     stateStyleMgr->HandleTouchUp();
351     EXPECT_EQ(false, stateStyleMgr->IsPressedStatePending());
352     EXPECT_EQ(true, stateStyleMgr->IsPressedCancelStatePending());
353     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
354 
355     stateStyleMgr->ResetPressedPendingState();
356     stateStyleMgr->ResetPressedCancelPendingState();
357     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
358     stateStyleMgr->HandleTouchUp();
359     EXPECT_EQ(false, stateStyleMgr->IsPressedStatePending());
360     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
361 
362     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
363     stateStyleMgr->PendingCancelPressedState();
364     stateStyleMgr->HandleTouchUp();
365     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
366 }
367 
368 /**
369  * @tc.name: StateStyleTest008
370  * @tc.desc: Test PostPressStyleTask function.
371  * @tc.type: FUNC
372  */
373 HWTEST_F(StateStyleManagerTestNg, StateStyleTest008, TestSize.Level1)
374 {
375     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
376     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
377     stateStyleMgr->PendingPressedState();
378     EXPECT_EQ(true, stateStyleMgr->IsPressedStatePending());
379     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
380     auto context = PipelineContext::GetCurrentContext();
381     ASSERT_NE(context, nullptr);
382     context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
383     auto taskExecutor = context->GetTaskExecutor();
384     ASSERT_NE(taskExecutor, nullptr);
385     stateStyleMgr->PostPressStyleTask(1);
386     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
387 
388     stateStyleMgr->ResetPressedPendingState();
389     stateStyleMgr->ResetPressedCancelPendingState();
390     EXPECT_EQ(false, stateStyleMgr->IsPressedStatePending());
391     stateStyleMgr->PostPressStyleTask(1);
392     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
393 }
394 
395 /**
396  * @tc.name: StateStyleTest009
397  * @tc.desc: Test PostPressCancelStyleTask function.
398  * @tc.type: FUNC
399  */
400 HWTEST_F(StateStyleManagerTestNg, StateStyleTest009, TestSize.Level1)
401 {
402     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
403     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
404     auto context = PipelineContext::GetCurrentContext();
405     ASSERT_NE(context, nullptr);
406     context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
407     auto taskExecutor = context->GetTaskExecutor();
408     ASSERT_NE(taskExecutor, nullptr);
409 
410     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
411     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
412 
413     stateStyleMgr->PendingPressedState();
414     stateStyleMgr->PendingCancelPressedState();
415     stateStyleMgr->PostPressCancelStyleTask(1);
416     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
417 
418     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
419     stateStyleMgr->ResetPressedPendingState();
420     stateStyleMgr->PendingCancelPressedState();
421     stateStyleMgr->PostPressCancelStyleTask(1);
422     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
423 
424     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
425     stateStyleMgr->PendingPressedState();
426     stateStyleMgr->ResetPressedCancelPendingState();
427     stateStyleMgr->PostPressCancelStyleTask(1);
428     EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
429 
430     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
431     stateStyleMgr->ResetPressedPendingState();
432     stateStyleMgr->ResetPressedCancelPendingState();
433     stateStyleMgr->PostPressCancelStyleTask(1);
434     EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
435 }
436 
437 /**
438  * @tc.name: StateStyleTest010
439  * @tc.desc: Test HandleTouchUp function.
440  * @tc.type: FUNC
441  */
442 HWTEST_F(StateStyleManagerTestNg, StateStyleTest010, TestSize.Level1)
443 {
444     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
445     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
446     auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
447     frameNode->SetParent(parent);
448 
449     stateStyleMgr->PendingPressedState();
450     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
451     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
452     stateStyleMgr->hasScrollingParent_ = true;
453     stateStyleMgr->HandleTouchUp();
454     EXPECT_NE(parent, nullptr);
455 }
456 
457 /**
458  * @tc.name: StateStyleTest011
459  * @tc.desc: Test CleanScrollingParentListener function.
460  * @tc.type: FUNC
461  */
462 HWTEST_F(StateStyleManagerTestNg, StateStyleTest011, TestSize.Level1)
463 {
464     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
465     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
466     auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
467     frameNode->SetParent(parent);
468 
469     stateStyleMgr->PendingPressedState();
470     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
471     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
472     stateStyleMgr->CleanScrollingParentListener();
473     EXPECT_NE(parent, nullptr);
474 }
475 
476 /**
477  * @tc.name: StateStyleTest012
478  * @tc.desc: Test CleanScrollingParentListener function.
479  * @tc.type: FUNC
480  */
481 HWTEST_F(StateStyleManagerTestNg, StateStyleTest012, TestSize.Level1)
482 {
483     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
484     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
485 
486     stateStyleMgr->PendingPressedState();
487     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
488     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
489     stateStyleMgr->CleanScrollingParentListener();
490     EXPECT_NE(frameNode, nullptr);
491 }
492 
493 /**
494  * @tc.name: StateStyleTest013
495  * @tc.desc: Test CleanScrollingParentListener function.
496  * @tc.type: FUNC
497  */
498 HWTEST_F(StateStyleManagerTestNg, StateStyleTest013, TestSize.Level1)
499 {
500     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
501     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
502     auto pagePattern = AceType::MakeRefPtr<Pattern>();
503     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
504     frameNode->SetParent(pageNode);
505 
506     stateStyleMgr->PendingPressedState();
507     stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
508     stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
509     stateStyleMgr->CleanScrollingParentListener();
510     EXPECT_NE(pageNode, nullptr);
511 }
512 
513 /**
514  * @tc.name: StateStyleTest014
515  * @tc.desc: Test Transform function.
516  * @tc.type: FUNC
517  */
518 HWTEST_F(StateStyleManagerTestNg, StateStyleTest014, TestSize.Level1)
519 {
520     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
521     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
522     PointF current = { 1.1f, 1.0f };
523     RefPtr<FrameNode> node;
524     stateStyleMgr->Transform(current, node);
525     EXPECT_NE(frameNode, nullptr);
526 }
527 
528 /**
529  * @tc.name: StateStyleTest015
530  * @tc.desc: test HandleScrollingParent
531  * @tc.type: FUNC
532  */
533 HWTEST_F(StateStyleManagerTestNg, StateStyleTest015, TestSize.Level1)
534 {
535     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
536     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
537     bool hasScrollingParent = true;
538     auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
539     frameNode->SetParent(parent);
540     auto swiperPattern = AceType::MakeRefPtr<SwiperPattern>();
541     parent->pattern_ = swiperPattern;
542     stateStyleMgr->HandleScrollingParent();
543     auto scrollingListener = swiperPattern->scrollingListener_;
544     for (auto listener : scrollingListener) {
545         listener->NotifyScrollingEvent();
546     }
547     CancelableCallback<void()> cancelableTask;
__anond1d495750102null548     cancelableTask.Reset([] { ; });
549     stateStyleMgr->pressStyleTask_ = cancelableTask;
550     for (auto listener : scrollingListener) {
551         listener->NotifyScrollingEvent();
552     }
553     EXPECT_EQ(true, hasScrollingParent);
554 }
555 
556 /**
557  * @tc.name: StateStyleTest016
558  * @tc.desc: test FireStateFunc
559  * @tc.type: FUNC
560  */
561 HWTEST_F(StateStyleManagerTestNg, StateStyleTest016, TestSize.Level1)
562 {
563     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
564     RefPtr<CustomNode> customNode =
565         CustomNode::CreateCustomNode(ElementRegister::GetInstance()->MakeUniqueId(), "test");
566     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
567     bool hasScrollingParent = true;
568     auto swiperPattern = AceType::MakeRefPtr<SwiperPattern>();
569     customNode->AddChild(frameNode);
570     stateStyleMgr->FireStateFunc(hasScrollingParent);
571     EXPECT_EQ(true, hasScrollingParent);
572 }
573 
574 /**
575  * @tc.name: StateStyleTest017
576  * @tc.desc: test FireStateFunc
577  * @tc.type: FUNC
578  */
579 HWTEST_F(StateStyleManagerTestNg, StateStyleTest017, TestSize.Level1)
580 {
581     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
582     auto contentNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anond1d495750202() 583         V2::NAVDESTINATION_VIEW_ETS_TAG, 22, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
584     RefPtr<CustomNode> customNode =
585         CustomNode::CreateCustomNode(ElementRegister::GetInstance()->MakeUniqueId(), "test");
586     auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
587     bool hasScrollingParent = true;
588     auto popupBasePattern = AceType::MakeRefPtr<PopupBasePattern>();
589     contentNode->pattern_ = popupBasePattern;
590     customNode->SetParent(contentNode);
591     frameNode->SetParent(contentNode);
592     stateStyleMgr->FireStateFunc(hasScrollingParent);
593     EXPECT_EQ(true, hasScrollingParent);
594 }
595 } // namespace OHOS::Ace::NG
596