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 #include "test/mock/core/render/mock_render_context.h"
27
28 #include "core/components_ng/event/state_style_manager.h"
29 #include "core/components_ng/pattern/list/list_pattern.h"
30 #include "core/components_ng/pattern/navrouter/navdestination_pattern.h"
31 #include "core/components_ng/pattern/pattern.h"
32 #include "core/components_ng/pattern/swiper/swiper_pattern.h"
33 #include "core/event/ace_events.h"
34
35 using namespace testing;
36 using namespace testing::ext;
37
38 namespace OHOS::Ace::NG {
39 class StateStyleManagerTestNg : public testing::Test {
40 public:
41 static void SetUpTestSuite();
42 static void TearDownTestSuite();
43 void SetUp() override;
44 void TearDown() override;
45 };
46
SetUpTestSuite()47 void StateStyleManagerTestNg::SetUpTestSuite()
48 {
49 GTEST_LOG_(INFO) << "StateStyleManagerTestNg SetUpTestCase";
50 }
51
TearDownTestSuite()52 void StateStyleManagerTestNg::TearDownTestSuite()
53 {
54 GTEST_LOG_(INFO) << "StateStyleManagerTestNg TearDownTestCase";
55 }
56
SetUp()57 void StateStyleManagerTestNg::SetUp()
58 {
59 MockPipelineContext::SetUp();
60 }
61
TearDown()62 void StateStyleManagerTestNg::TearDown()
63 {
64 MockPipelineContext::TearDown();
65 }
66
67 /**
68 * @tc.name: StateStyleTest001
69 * @tc.desc: Create StateStyleManager and execute pressed listener.
70 * @tc.type: FUNC
71 */
72 HWTEST_F(StateStyleManagerTestNg, StateStyleTest001, TestSize.Level1)
73 {
74 /**
75 * @tc.steps: step1. Create state style manger.
76 * @tc.expected: State style pressed listener is valid.
77 */
78 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
79 EXPECT_NE(frameNode, nullptr);
80 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
81 EXPECT_NE(stateStyleMgr, nullptr);
82 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
83 auto callback = stateStyleMgr->GetPressedListener();
84 EXPECT_NE(callback, nullptr);
85
86 /**
87 * @tc.steps: step2. Create touch down event and execute it.
88 * @tc.expected: Should change to pressed state.
89 */
90
91 TouchEventInfo touchEventInfo = TouchEventInfo("touch");
92 TouchLocationInfo touchLocationInfo = TouchLocationInfo(1);
93 touchLocationInfo.SetLocalLocation(Offset(100.0, 100.0));
94 touchLocationInfo.SetTouchType(TouchType::DOWN);
95 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
96 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
97
98 (*callback)(touchEventInfo);
99 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
100
101 /**
102 * @tc.steps: step3. Create touch up event and execute it.
103 * @tc.expected: Should cancel pressed state.
104 */
105
106 touchLocationInfo.SetTouchType(TouchType::UP);
107 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
108 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
109
110 (*callback)(touchEventInfo);
111 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
112 }
113
114 /**
115 * @tc.name: StateStyleTest002
116 * @tc.desc: Create StateStyleManager and execute pressed listener when multi fingers.
117 * @tc.type: FUNC
118 */
119 HWTEST_F(StateStyleManagerTestNg, StateStyleTest002, TestSize.Level1)
120 {
121 /**
122 * @tc.steps: step1. Create state style manger.
123 * @tc.expected: State style pressed listener is valid.
124 */
125 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
126 EXPECT_NE(frameNode, nullptr);
127 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
128 EXPECT_NE(stateStyleMgr, nullptr);
129 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
130 auto callback = stateStyleMgr->GetPressedListener();
131 EXPECT_NE(callback, nullptr);
132
133 /**
134 * @tc.steps: step2. One finger touch down.
135 * @tc.expected: Should change to pressed state.
136 */
137
138 TouchEventInfo touchEventInfo = TouchEventInfo("touch");
139 TouchLocationInfo touchLocationInfo1 = TouchLocationInfo(1);
140 touchLocationInfo1.SetLocalLocation(Offset(100.0, 100.0));
141 touchLocationInfo1.SetTouchType(TouchType::DOWN);
142 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo1));
143 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo1));
144
145 (*callback)(touchEventInfo);
146 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
147
148 /**
149 * @tc.steps: step3. One more finger touch down.
150 * @tc.expected: Should hold on pressed state.
151 */
152
153 TouchLocationInfo touchLocationInfo2 = TouchLocationInfo(2);
154 touchLocationInfo2.SetLocalLocation(Offset(100.0, 100.0));
155 touchLocationInfo2.SetTouchType(TouchType::DOWN);
156 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo2));
157 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo2));
158
159 (*callback)(touchEventInfo);
160 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
161
162 /**
163 * @tc.steps: step4. One finger touch up.
164 * @tc.expected: Should hold on pressed state.
165 */
166
167 touchLocationInfo1.SetTouchType(TouchType::UP);
168 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo1));
169 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo1));
170
171 (*callback)(touchEventInfo);
172 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
173
174 /**
175 * @tc.steps: step5. One more finger touch up.
176 * @tc.expected: Should cancel pressed state.
177 */
178
179 touchLocationInfo2.SetTouchType(TouchType::UP);
180 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo2));
181 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo2));
182
183 (*callback)(touchEventInfo);
184 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
185 }
186
187 /**
188 * @tc.name: StateStyleTest003
189 * @tc.desc: Create StateStyleManager and execute its functions.
190 * @tc.type: FUNC
191 */
192 HWTEST_F(StateStyleManagerTestNg, StateStyleTest003, TestSize.Level1)
193 {
194 /**
195 * @tc.steps: step1. Create state style manger.
196 * @tc.expected: Should have no scrolling parent.
197 */
198 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
199 EXPECT_NE(frameNode, nullptr);
200 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
201 EXPECT_NE(stateStyleMgr, nullptr);
202 stateStyleMgr->HandleScrollingParent();
203 bool hasScrollingParent = stateStyleMgr->GetHasScrollingParent();
204 EXPECT_EQ(false, hasScrollingParent);
205
206 /**
207 * @tc.steps: step2. Set parent to current frame node.
208 * @tc.expected: Should have scrolling parent.
209 */
210
211 auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
212 EXPECT_NE(parent, nullptr);
213 frameNode->SetParent(parent);
214 stateStyleMgr->HandleScrollingParent();
215 hasScrollingParent = stateStyleMgr->GetHasScrollingParent();
216 EXPECT_EQ(true, hasScrollingParent);
217 EXPECT_EQ(false, stateStyleMgr->isFastScrolling_);
218
219 /**
220 * @tc.steps: step3. Set list parent to current frame node and ShouldPreventChildPressedState is true.
221 * @tc.expected: Should have scrolling parent and isFastScrolling_ is true.
222 */
223
224 auto listPattern = parent->GetPattern<ListPattern>();
225 listPattern->isHitTestBlock_ = true;
226 stateStyleMgr->HandleScrollingParent();
227 hasScrollingParent = stateStyleMgr->GetHasScrollingParent();
228 EXPECT_EQ(true, hasScrollingParent);
229 EXPECT_EQ(true, stateStyleMgr->isFastScrolling_);
230 }
231
232 /**
233 * @tc.name: StateStyleTest004
234 * @tc.desc: Create StateStyleManager and execute its functions.
235 * @tc.type: FUNC
236 */
237 HWTEST_F(StateStyleManagerTestNg, StateStyleTest004, TestSize.Level1)
238 {
239 /**
240 * @tc.steps: step1. Create state style manger.
241 * @tc.expected: State style pressed listener is valid.
242 */
243 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
244 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
245 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
246 auto callback = stateStyleMgr->GetPressedListener();
247 EXPECT_NE(callback, nullptr);
248 auto callback2 = stateStyleMgr->GetPressedListener();
249 EXPECT_EQ(callback, callback2);
250
251 /**
252 * @tc.steps: step2. Create condition that touches.empty() changeTouches.empty()
253 * @tc.expected: State style pressed listener is valid.
254 */
255 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
256 TouchEventInfo touchEventInfo = TouchEventInfo("touch");
257 (*callback)(touchEventInfo);
258 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
259
260 /**
261 * @tc.steps: step3. Create condition that touches.empty()=false changeTouches.empty true
262 * @tc.expected: State style pressed listener is valid.
263 */
264 TouchLocationInfo touchLocationInfo = TouchLocationInfo(1);
265 touchLocationInfo.SetLocalLocation(Offset(100.0, 100.0));
266 touchLocationInfo.SetTouchType(TouchType::CANCEL);
267 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
268 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
269 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
270 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
271 (*callback)(touchEventInfo);
272 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
273
274 /**
275 * @tc.steps: step3. Create condition that touches.empty false changeTouches.empty false
276 * @tc.expected: State style pressed listener is valid.
277 */
278 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
279 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
280 (*callback)(touchEventInfo);
281 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
282 }
283
284 /**
285 * @tc.name: StateStyleTest005
286 * @tc.desc: Create StateStyleManager and execute its functions.
287 * @tc.type: FUNC
288 */
289 HWTEST_F(StateStyleManagerTestNg, StateStyleTest005, TestSize.Level1)
290 {
291 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
292 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
293 auto callback = stateStyleMgr->GetPressedListener();
294 EXPECT_NE(callback, nullptr);
295 auto callback2 = stateStyleMgr->GetPressedListener();
296 EXPECT_EQ(callback, callback2);
297
298 TouchEventInfo touchEventInfo = TouchEventInfo("touch");
299 TouchLocationInfo touchLocationInfo = TouchLocationInfo(1);
300 touchLocationInfo.SetLocalLocation(Offset(-100.0, -100.0));
301 touchLocationInfo.SetTouchType(TouchType::MOVE);
302 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
303 touchEventInfo.AddChangedTouchLocationInfo(std::move(touchLocationInfo));
304 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
305 stateStyleMgr->ResetPressedPendingState();
306 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
307 (*callback)(touchEventInfo);
308 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
309
310 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, false);
311 stateStyleMgr->ResetPressedPendingState();
312 (*callback)(touchEventInfo);
313 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
314 }
315
316 /**
317 * @tc.name: StateStyleTest006
318 * @tc.desc: Test HandleTouchDown function.
319 * @tc.type: FUNC
320 */
321 HWTEST_F(StateStyleManagerTestNg, StateStyleTest006, TestSize.Level1)
322 {
323 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
324 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
325 stateStyleMgr->SetSupportedStates(UI_STATE_NORMAL);
326 stateStyleMgr->HandleTouchDown();
327 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
328
329 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
330 stateStyleMgr->HandleTouchDown();
331 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
332
333 auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
334 EXPECT_NE(parent, nullptr);
335 frameNode->SetParent(parent);
336 stateStyleMgr->PendingCancelPressedState();
337 EXPECT_EQ(true, stateStyleMgr->IsPressedCancelStatePending());
338 stateStyleMgr->HandleTouchDown();
339 EXPECT_EQ(false, stateStyleMgr->IsPressedCancelStatePending());
340 EXPECT_EQ(true, stateStyleMgr->IsPressedStatePending());
341
342 stateStyleMgr->ResetPressedCancelPendingState();
343 stateStyleMgr->HandleTouchDown();
344 EXPECT_EQ(false, stateStyleMgr->IsPressedCancelStatePending());
345 EXPECT_EQ(true, stateStyleMgr->IsPressedStatePending());
346 }
347
348 /**
349 * @tc.name: StateStyleTest007
350 * @tc.desc: Test HandleTouchUp function.
351 * @tc.type: FUNC
352 */
353 HWTEST_F(StateStyleManagerTestNg, StateStyleTest007, TestSize.Level1)
354 {
355 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
356 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
357 auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
358 EXPECT_NE(parent, nullptr);
359 frameNode->SetParent(parent);
360
361 stateStyleMgr->PendingPressedState();
362 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
363 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
364 stateStyleMgr->HandleTouchUp();
365 EXPECT_EQ(false, stateStyleMgr->IsPressedStatePending());
366 EXPECT_EQ(true, stateStyleMgr->IsPressedCancelStatePending());
367 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
368
369 stateStyleMgr->ResetPressedPendingState();
370 stateStyleMgr->ResetPressedCancelPendingState();
371 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
372 stateStyleMgr->HandleTouchUp();
373 EXPECT_EQ(false, stateStyleMgr->IsPressedStatePending());
374 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
375
376 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
377 stateStyleMgr->PendingCancelPressedState();
378 stateStyleMgr->HandleTouchUp();
379 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
380 }
381
382 /**
383 * @tc.name: StateStyleTest008
384 * @tc.desc: Test PostPressStyleTask function.
385 * @tc.type: FUNC
386 */
387 HWTEST_F(StateStyleManagerTestNg, StateStyleTest008, TestSize.Level1)
388 {
389 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
390 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
391 stateStyleMgr->PendingPressedState();
392 EXPECT_EQ(true, stateStyleMgr->IsPressedStatePending());
393 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
394 auto context = PipelineContext::GetCurrentContext();
395 ASSERT_NE(context, nullptr);
396 context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
397 auto taskExecutor = context->GetTaskExecutor();
398 ASSERT_NE(taskExecutor, nullptr);
399 stateStyleMgr->PostPressStyleTask(1);
400 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
401
402 stateStyleMgr->ResetPressedPendingState();
403 stateStyleMgr->ResetPressedCancelPendingState();
404 EXPECT_EQ(false, stateStyleMgr->IsPressedStatePending());
405 stateStyleMgr->PostPressStyleTask(1);
406 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
407 }
408
409 /**
410 * @tc.name: StateStyleTest009
411 * @tc.desc: Test PostPressCancelStyleTask function.
412 * @tc.type: FUNC
413 */
414 HWTEST_F(StateStyleManagerTestNg, StateStyleTest009, TestSize.Level1)
415 {
416 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
417 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
418 auto context = PipelineContext::GetCurrentContext();
419 ASSERT_NE(context, nullptr);
420 context->taskExecutor_ = AceType::MakeRefPtr<MockTaskExecutor>();
421 auto taskExecutor = context->GetTaskExecutor();
422 ASSERT_NE(taskExecutor, nullptr);
423
424 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
425 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
426
427 stateStyleMgr->PendingPressedState();
428 stateStyleMgr->PendingCancelPressedState();
429 stateStyleMgr->PostPressCancelStyleTask(1);
430 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
431
432 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
433 stateStyleMgr->ResetPressedPendingState();
434 stateStyleMgr->PendingCancelPressedState();
435 stateStyleMgr->PostPressCancelStyleTask(1);
436 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
437
438 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
439 stateStyleMgr->PendingPressedState();
440 stateStyleMgr->ResetPressedCancelPendingState();
441 stateStyleMgr->PostPressCancelStyleTask(1);
442 EXPECT_EQ(true, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
443
444 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
445 stateStyleMgr->ResetPressedPendingState();
446 stateStyleMgr->ResetPressedCancelPendingState();
447 stateStyleMgr->PostPressCancelStyleTask(1);
448 EXPECT_EQ(false, stateStyleMgr->IsCurrentStateOn(UI_STATE_PRESSED));
449 }
450
451 /**
452 * @tc.name: StateStyleTest010
453 * @tc.desc: Test HandleTouchUp function.
454 * @tc.type: FUNC
455 */
456 HWTEST_F(StateStyleManagerTestNg, StateStyleTest010, TestSize.Level1)
457 {
458 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
459 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
460 auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
461 frameNode->SetParent(parent);
462
463 stateStyleMgr->PendingPressedState();
464 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
465 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
466 stateStyleMgr->hasScrollingParent_ = true;
467 stateStyleMgr->HandleTouchUp();
468 EXPECT_NE(parent, nullptr);
469 }
470
471 /**
472 * @tc.name: StateStyleTest011
473 * @tc.desc: Test CleanScrollingParentListener function.
474 * @tc.type: FUNC
475 */
476 HWTEST_F(StateStyleManagerTestNg, StateStyleTest011, TestSize.Level1)
477 {
478 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
479 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
480 auto parent = AceType::MakeRefPtr<FrameNode>(V2::LIST_ETS_TAG, -1, AceType::MakeRefPtr<ListPattern>());
481 frameNode->SetParent(parent);
482
483 stateStyleMgr->PendingPressedState();
484 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
485 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
486 stateStyleMgr->CleanScrollingParentListener();
487 EXPECT_NE(parent, nullptr);
488 }
489
490 /**
491 * @tc.name: StateStyleTest012
492 * @tc.desc: Test CleanScrollingParentListener function.
493 * @tc.type: FUNC
494 */
495 HWTEST_F(StateStyleManagerTestNg, StateStyleTest012, TestSize.Level1)
496 {
497 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
498 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
499
500 stateStyleMgr->PendingPressedState();
501 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
502 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
503 stateStyleMgr->CleanScrollingParentListener();
504 EXPECT_NE(frameNode, nullptr);
505 }
506
507 /**
508 * @tc.name: StateStyleTest013
509 * @tc.desc: Test CleanScrollingParentListener function.
510 * @tc.type: FUNC
511 */
512 HWTEST_F(StateStyleManagerTestNg, StateStyleTest013, TestSize.Level1)
513 {
514 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
515 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
516 auto pagePattern = AceType::MakeRefPtr<Pattern>();
517 auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
518 frameNode->SetParent(pageNode);
519
520 stateStyleMgr->PendingPressedState();
521 stateStyleMgr->SetSupportedStates(UI_STATE_PRESSED);
522 stateStyleMgr->SetCurrentUIState(UI_STATE_PRESSED, true);
523 stateStyleMgr->CleanScrollingParentListener();
524 EXPECT_NE(pageNode, nullptr);
525 }
526
527 /**
528 * @tc.name: StateStyleTest014
529 * @tc.desc: Test Transform function.
530 * @tc.type: FUNC
531 */
532 HWTEST_F(StateStyleManagerTestNg, StateStyleTest014, TestSize.Level1)
533 {
534 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
535 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
536 PointF current = { 1.1f, 1.0f };
537 RefPtr<FrameNode> node;
538 stateStyleMgr->Transform(current, node);
539 EXPECT_NE(frameNode, nullptr);
540 }
541
542 /**
543 * @tc.name: StateStyleTest016
544 * @tc.desc: test FireStateFunc
545 * @tc.type: FUNC
546 */
547 HWTEST_F(StateStyleManagerTestNg, StateStyleTest016, TestSize.Level1)
548 {
549 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
550 RefPtr<CustomNode> customNode =
551 CustomNode::CreateCustomNode(ElementRegister::GetInstance()->MakeUniqueId(), "test");
552 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
553 bool hasScrollingParent = true;
554 auto swiperPattern = AceType::MakeRefPtr<SwiperPattern>();
555 customNode->AddChild(frameNode);
556 stateStyleMgr->FireStateFunc(UI_STATE_PRESSED, stateStyleMgr->currentState_, hasScrollingParent);
557 EXPECT_EQ(true, hasScrollingParent);
558 }
559
560 /**
561 * @tc.name: StateStyleTest017
562 * @tc.desc: test FireStateFunc
563 * @tc.type: FUNC
564 */
565 HWTEST_F(StateStyleManagerTestNg, StateStyleTest017, TestSize.Level1)
566 {
567 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
568 auto contentNode = NavDestinationGroupNode::GetOrCreateGroupNode(
__anon64cc0b5f0102() 569 V2::NAVDESTINATION_VIEW_ETS_TAG, 22, []() { return AceType::MakeRefPtr<NavDestinationPattern>(); });
570 RefPtr<CustomNode> customNode =
571 CustomNode::CreateCustomNode(ElementRegister::GetInstance()->MakeUniqueId(), "test");
572 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
573 bool hasScrollingParent = true;
574 auto popupBasePattern = AceType::MakeRefPtr<PopupBasePattern>();
575 contentNode->pattern_ = popupBasePattern;
576 customNode->SetParent(contentNode);
577 frameNode->SetParent(contentNode);
578 stateStyleMgr->FireStateFunc(UI_STATE_PRESSED, stateStyleMgr->currentState_, hasScrollingParent);
579 EXPECT_EQ(true, hasScrollingParent);
580 }
581
582 /**
583 * @tc.name: StateStyleTest018
584 * @tc.desc: test AddSupportedUIStateWithCallback
585 * @tc.type: FUNC
586 */
587 HWTEST_F(StateStyleManagerTestNg, StateStyleTest018, TestSize.Level1)
588 {
589 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
590 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
__anon64cc0b5f0202(UIState state) 591 std::function<void(UIState)> callback = [](UIState state) {};
592 stateStyleMgr->AddSupportedUIStateWithCallback(UI_STATE_NORMAL, callback, true);
593 EXPECT_TRUE(stateStyleMgr->HasStateStyle(UI_STATE_NORMAL));
594
595 stateStyleMgr->AddSupportedUIStateWithCallback(UI_STATE_NORMAL | UI_STATE_PRESSED, callback, true);
596 EXPECT_TRUE(stateStyleMgr->HasStateStyle(UI_STATE_PRESSED));
597
598 stateStyleMgr->AddSupportedUIStateWithCallback(UI_STATE_NORMAL | UI_STATE_PRESSED, callback, false);
599 bool flag = (stateStyleMgr->userStateStyleSubscribers_.first & UI_STATE_PRESSED) == UI_STATE_PRESSED;
600 EXPECT_TRUE(flag);
601 }
602
603 /**
604 * @tc.name: StateStyleTest019
605 * @tc.desc: test RemoveSupportedUIState
606 * @tc.type: FUNC
607 */
608 HWTEST_F(StateStyleManagerTestNg, StateStyleTest019, TestSize.Level1)
609 {
610 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
611 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
612 stateStyleMgr->RemoveSupportedUIState(UI_STATE_NORMAL, true);
613 EXPECT_TRUE(stateStyleMgr->HasStateStyle(UI_STATE_NORMAL));
614 EXPECT_FALSE(stateStyleMgr->HasStateStyle(UI_STATE_PRESSED));
615
__anon64cc0b5f0302(UIState state) 616 std::function<void(UIState)> callback = [](UIState state) {};
617 stateStyleMgr->AddSupportedUIStateWithCallback(UI_STATE_PRESSED, callback, true);
618 stateStyleMgr->AddSupportedUIStateWithCallback(UI_STATE_PRESSED, callback, false);
619 EXPECT_TRUE(stateStyleMgr->HasStateStyle(UI_STATE_PRESSED));
620
621 stateStyleMgr->RemoveSupportedUIState(UI_STATE_PRESSED, true);
622 EXPECT_TRUE(stateStyleMgr->HasStateStyle(UI_STATE_PRESSED));
623
624 stateStyleMgr->RemoveSupportedUIState(UI_STATE_PRESSED, false);
625 EXPECT_FALSE(stateStyleMgr->HasStateStyle(UI_STATE_PRESSED));
626 }
627
628 /**
629 * @tc.name: StateStyleTest020
630 * @tc.desc: test HandleStateChangeInternal
631 * @tc.type: FUNC
632 */
633 HWTEST_F(StateStyleManagerTestNg, StateStyleTest020, TestSize.Level1)
634 {
635 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
636 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
637
__anon64cc0b5f0402(UIState state) 638 std::function<void(UIState)> callback = [](UIState state) {};
639 stateStyleMgr->AddSupportedUIStateWithCallback(UI_STATE_NORMAL | UI_STATE_PRESSED, callback, true);
640 EXPECT_TRUE(stateStyleMgr->HasStateStyle(UI_STATE_NORMAL | UI_STATE_PRESSED));
641 stateStyleMgr->HandleStateChangeInternal(UI_STATE_PRESSED, stateStyleMgr->currentState_, true);
642 EXPECT_TRUE(stateStyleMgr->innerStateStyleSubscribers_.second);
643
644 stateStyleMgr->AddSupportedUIStateWithCallback(UI_STATE_NORMAL | UI_STATE_PRESSED, callback, false);
645 EXPECT_TRUE(stateStyleMgr->HasStateStyle(UI_STATE_NORMAL | UI_STATE_PRESSED));
646 stateStyleMgr->HandleStateChangeInternal(UI_STATE_PRESSED, stateStyleMgr->currentState_, false);
647 EXPECT_TRUE(stateStyleMgr->userStateStyleSubscribers_.second);
648 }
649
650 /**
651 * @tc.name: StateStyleTest021
652 * @tc.desc: test IsOutOfPressedRegion
653 * @tc.type: FUNC
654 */
655 HWTEST_F(StateStyleManagerTestNg, StateStyleTest021, TestSize.Level1)
656 {
657 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
658 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
659
660 int32_t sourceType = 1;
661 Offset location = {1, 1};
662 bool ret = stateStyleMgr->IsOutOfPressedRegion(sourceType, location);
663 EXPECT_TRUE(ret);
664
665 auto renderContext = AceType::MakeRefPtr<MockRenderContext>();
666 renderContext->rect_ = RectF(0, 0, 10, 10);
667 renderContext->paintRect_ = RectF(0, 0, 10, 10);
668 stateStyleMgr->GetFrameNode()->renderContext_ = renderContext;
669 ret = stateStyleMgr->IsOutOfPressedRegion(sourceType, location);
670 EXPECT_FALSE(ret);
671
672 auto testFrameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, 0, AceType::MakeRefPtr<Pattern>());
673 testFrameNode->renderContext_ = renderContext;
674 stateStyleMgr->GetFrameNode()->SetParent(testFrameNode);
675 ret = stateStyleMgr->IsOutOfPressedRegion(sourceType, location);
676 EXPECT_FALSE(ret);
677 }
678
679 /**
680 * @tc.name: StateStyleTest022
681 * @tc.desc: test IsOutOfPressedRegion
682 * @tc.type: FUNC
683 */
684 HWTEST_F(StateStyleManagerTestNg, StateStyleTest022, TestSize.Level1)
685 {
686 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
687 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
688
689 int32_t sourceType = 1;
690 Offset location = { 1, 1 };
691 bool ret = stateStyleMgr->IsOutOfPressedRegion(sourceType, location);
692 EXPECT_TRUE(ret);
693
694 auto renderContext = AceType::MakeRefPtr<MockRenderContext>();
695 renderContext->rect_ = RectF(0, 0, 10, 10);
696 renderContext->paintRect_ = RectF(0, 0, 10, 10);
697 stateStyleMgr->GetFrameNode()->renderContext_ = renderContext;
698
699 auto testFrameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, 0, AceType::MakeRefPtr<Pattern>());
700 testFrameNode->renderContext_ = nullptr;
701 stateStyleMgr->GetFrameNode()->SetParent(testFrameNode);
702 ret = stateStyleMgr->IsOutOfPressedRegion(sourceType, location);
703 EXPECT_FALSE(ret);
704 }
705
706 /**
707 * @tc.name: StateStyleTest023
708 * @tc.desc: test Transform
709 * @tc.type: FUNC
710 */
711 HWTEST_F(StateStyleManagerTestNg, StateStyleTest023, TestSize.Level1)
712 {
713 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
714 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
715 PointF localPointF = { 0, 0 };
716 RefPtr<FrameNode> node = AceType::MakeRefPtr<FrameNode>("test1", 1, AceType::MakeRefPtr<Pattern>());
717 WeakPtr<FrameNode> weakNode = AceType::WeakClaim(AceType::RawPtr(node));
718 stateStyleMgr->Transform(localPointF, weakNode);
719 EXPECT_EQ(localPointF.GetX(), 0);
720 EXPECT_EQ(localPointF.GetY(), 0);
721 }
722
723 /**
724 * @tc.name: StateStyleTest024
725 * @tc.desc: test IsExcludeInner
726 * @tc.type: FUNC
727 */
728 HWTEST_F(StateStyleManagerTestNg, StateStyleTest024, TestSize.Level1)
729 {
730 /**
731 * @tc.steps: step1. Create state style manger.
732 * @tc.expected: stateStyleMgr is not null.
733 */
734 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
735 ASSERT_NE(frameNode, nullptr);
736 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
737 ASSERT_NE(stateStyleMgr, nullptr);
738
739 /**
740 * @tc.steps: step2. Call AddSupportedUIStateWithCallback.
741 * @tc.expected: userSubscribersExcludeConfigs_ value is correct, IsExcludeInner's return value meets expectations.
742 */
__anon64cc0b5f0502(UIState state) 743 std::function<void(UIState)> callback = [](UIState state) {};
744 UIState uiState = UI_STATE_NORMAL | UI_STATE_PRESSED | UI_STATE_FOCUSED;
745 stateStyleMgr->AddSupportedUIStateWithCallback(uiState, callback, false, true);
746 EXPECT_EQ(uiState, stateStyleMgr->userSubscribersExcludeConfigs_);
747 EXPECT_TRUE(stateStyleMgr->IsExcludeInner(UI_STATE_FOCUSED));
748
749 /**
750 * @tc.steps: step3. Call RemoveSupportedUIState.
751 * @tc.expected: userSubscribersExcludeConfigs_ value is correct, IsExcludeInner's return value meets expectations.
752 */
753 stateStyleMgr->RemoveSupportedUIState(UI_STATE_PRESSED, false);
754 EXPECT_EQ(UI_STATE_FOCUSED, stateStyleMgr->userSubscribersExcludeConfigs_);
755 EXPECT_FALSE(stateStyleMgr->IsExcludeInner(UI_STATE_PRESSED));
756 stateStyleMgr->RemoveSupportedUIState(UI_STATE_FOCUSED, false);
757 EXPECT_EQ(EXCLUDE_INNER_FLAG_NONE, stateStyleMgr->userSubscribersExcludeConfigs_);
758 EXPECT_FALSE(stateStyleMgr->IsExcludeInner(UI_STATE_FOCUSED));
759 }
760
761 /**
762 * @tc.name: StateStyleTest025
763 * @tc.desc: test AddSupportedUIStateWithCallback
764 * @tc.type: FUNC
765 */
766 HWTEST_F(StateStyleManagerTestNg, StateStyleTest025, TestSize.Level1)
767 {
768 /**
769 * @tc.steps: step1. Create state style manger.
770 * @tc.expected: stateStyleMgr is not null.
771 */
772 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::BUTTON_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
773 ASSERT_NE(frameNode, nullptr);
774 auto stateStyleMgr = AceType::MakeRefPtr<StateStyleManager>(frameNode);
775 ASSERT_NE(stateStyleMgr, nullptr);
776 UIState callbackUIState = UI_STATE_NORMAL;
__anon64cc0b5f0602(UIState state) 777 std::function<void(UIState)> callback = [ & ](UIState state) {
778 callbackUIState = state;
779 };
780 EXPECT_EQ(callbackUIState, UI_STATE_NORMAL);
781
782 /**
783 * @tc.steps: step2. Call AddSupportedUIStateWithCallback.
784 * @tc.expected: callbackUIState value is correct.
785 */
786 UIState uiState = UI_STATE_SELECTED;
787 stateStyleMgr->AddSupportedUIStateWithCallback(uiState, callback, false);
788 EXPECT_EQ(stateStyleMgr->supportedStates_, UI_STATE_SELECTED);
789 stateStyleMgr->SetCurrentUIState(UI_STATE_SELECTED, true);
790 EXPECT_EQ(callbackUIState, UI_STATE_SELECTED);
791 stateStyleMgr->SetCurrentUIState(UI_STATE_SELECTED, false);
792 EXPECT_EQ(callbackUIState, UI_STATE_NORMAL);
793
794 /**
795 * @tc.steps: step3. Call RemoveSupportedUIState.
796 * @tc.expected: callbackUIState value is correct.
797 */
798 stateStyleMgr->RemoveSupportedUIState(UI_STATE_SELECTED, false);
799 EXPECT_EQ(UI_STATE_NORMAL, stateStyleMgr->supportedStates_);
800 }
801 } // namespace OHOS::Ace::NG
802