1 /*
2 * Copyright (c) 2022-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 "gtest/gtest.h"
17
18 #define private public
19 #define protected public
20 #include "test/mock/core/pipeline/mock_pipeline_context.h"
21
22 #include "base/geometry/ng/offset_t.h"
23 #include "base/memory/ace_type.h"
24 #include "base/memory/referenced.h"
25 #include "core/components_ng/base/frame_node.h"
26 #include "core/components_ng/event/event_hub.h"
27 #include "core/components_ng/pattern/pattern.h"
28 #include "core/components_v2/inspector/inspector_constants.h"
29
30 using namespace testing;
31 using namespace testing::ext;
32
33 namespace OHOS::Ace::NG {
34 namespace {
35 constexpr bool EVENT_HUB_ENABLE = false;
36 const std::string DRAG_STARR_EVENT_TYPE = "drag start";
37 const std::string DRAG_ENTER_EVENT_TYPE = "drag enter";
38 const std::string DRAG_LEAVE_EVENT_TYPE = "drag leave";
39 const std::string DRAG_MOVE_EVENT_TYPE = "drag move";
40 const std::string DRAG_DROP_EVENT_TYPE = "drag drop";
41 const std::string DRAG_END_EVENT_TYPE = "drag end";
42
43 const float OLD_X_VALUE = 10.9f;
44 const float OLD_Y_VALUE = 11.0f;
45 const float OLD_WIDTH = 400.0f;
46 const float OLD_HEIGHT = 400.0f;
47 const RectF OLD_RECT = RectF(OLD_X_VALUE, OLD_Y_VALUE, OLD_WIDTH, OLD_HEIGHT);
48 const OffsetF OLD_ORIGIN = OffsetF(OLD_WIDTH, OLD_HEIGHT);
49
50 const float NEW_X_VALUE = 15.9f;
51 const float NEW_Y_VALUE = 15.0f;
52 const float NEW_WIDTH = 500.0f;
53 const float NEW_HEIGHT = 500.0f;
54 const RectF NEW_RECT = RectF(NEW_X_VALUE, NEW_Y_VALUE, NEW_WIDTH, NEW_HEIGHT);
55 const OffsetF NEW_ORIGIN = OffsetF(NEW_WIDTH, NEW_HEIGHT);
56
57 const RectF RECT_DELTA = RectF(1.0f, 1.0f, 1.0f, 1.0f);
58 const OffsetF OFFSET_DELTA = OffsetF(1.0f, 1.0f);
59 const OffsetF ORIGIN_DELTA = OffsetF(1.0f, 1.0f);
60
61 const std::string STRINGCTER_A = "A";
62 const std::string STRINGCTER_Q = "Q";
63 const std::string STRINGCTER_E = "E";
64 constexpr int32_t NUM_CTRL_VALUE = 1;
65 constexpr int32_t NUM_SHIFT_VALUE = 2;
66 constexpr int32_t NUM_ALT_VALUE = 4;
67 constexpr uint32_t MIN_INTERVAL = 100; // 100ms
68
69 const std::string RESULT_SUCCESS_ONE = "sucess1";
70 const std::string RESULT_SUCCESS_TWO = "sucess2";
71
72 int32_t flag = 0;
73 } // namespace
74
75 class EventHubTestNg : public testing::Test {
76 public:
77 static void SetUpTestSuite();
78 static void TearDownTestSuite();
79 void SetUp() override;
80 void TearDown() override;
81 };
82
SetUpTestSuite()83 void EventHubTestNg::SetUpTestSuite()
84 {
85 GTEST_LOG_(INFO) << "EventHubTestNg SetUpTestCase";
86 }
87
TearDownTestSuite()88 void EventHubTestNg::TearDownTestSuite()
89 {
90 GTEST_LOG_(INFO) << "EventHubTestNg TearDownTestCase";
91 }
92
SetUp()93 void EventHubTestNg::SetUp()
94 {
95 MockPipelineContext::SetUp();
96 }
97
TearDown()98 void EventHubTestNg::TearDown()
99 {
100 MockPipelineContext::TearDown();
101 }
102
103 /**
104 * @tc.name: EventHubCreateTest001
105 * @tc.desc: Create EventHub.
106 * @tc.type: FUNC
107 */
108 HWTEST_F(EventHubTestNg, EventHubCreateTest001, TestSize.Level1)
109 {
110 /**
111 * @tc.steps: step1. Create EventHub.
112 * @tc.expected: eventHub is not null.
113 */
114 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
115 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
116 eventHub->MarkModifyDone();
117 EXPECT_NE(eventHub, nullptr);
118
119 /**
120 * @tc.steps: step2. Get EventHub's properties.
121 * @tc.expected: These properties are null when GetOrCreateEventHub functions have not been invoked.
122 */
123 EXPECT_EQ(eventHub->GetGestureEventHub(), nullptr);
124 EXPECT_EQ(eventHub->GetInputEventHub(), nullptr);
125 EXPECT_EQ(eventHub->GetFocusHub(), nullptr);
126 EXPECT_NE(eventHub->GetFrameNode(), nullptr);
127 EXPECT_EQ(eventHub->GetOnDragStart(), nullptr);
128
129 /**
130 * @tc.steps: step3. Test EventHub's default properties.
131 */
132 EXPECT_TRUE(!eventHub->HasOnAreaChanged());
133 EXPECT_TRUE(!eventHub->HasOnDragStart());
134 EXPECT_TRUE(!eventHub->HasOnDrop());
135 EXPECT_TRUE(eventHub->IsEnabled());
136 }
137
138 /**
139 * @tc.name: EventHubPropertyTest002
140 * @tc.desc: Create EventHub and invoke GetOrCreateEventHub functions.
141 * @tc.type: FUNC
142 */
143 HWTEST_F(EventHubTestNg, EventHubPropertyTest002, TestSize.Level1)
144 {
145 /**
146 * @tc.steps: step1. Create EventHub.
147 * @tc.expected: eventHub is not null.
148 */
149 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
150 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
151 EXPECT_NE(eventHub, nullptr);
152
153 /**
154 * @tc.steps: step2. Invoke GetOrCreateEventHub functions.
155 * @tc.expected: These eventHub properties are not null.
156 */
157 eventHub->GetOrCreateGestureEventHub();
158 eventHub->GetOrCreateInputEventHub();
159 eventHub->GetOrCreateFocusHub();
160 EXPECT_NE(eventHub->GetGestureEventHub(), nullptr);
161 EXPECT_NE(eventHub->GetInputEventHub(), nullptr);
162 EXPECT_NE(eventHub->GetFocusHub(), nullptr);
163
164 EXPECT_TRUE(eventHub->GetFrameNode() != nullptr && eventHub->GetFrameNode()->GetTag() == V2::TEXT_ETS_TAG);
165 eventHub->OnContextAttached();
166 eventHub->SetEnabled(EVENT_HUB_ENABLE);
167 EXPECT_TRUE(!eventHub->IsEnabled());
168 }
169
170 /**
171 * @tc.name: EventHubPropertyTest003
172 * @tc.desc: Create EventHub and set/fire onAreaChanged, onAppear and onDisappear function.
173 * @tc.type: FUNC
174 */
175 HWTEST_F(EventHubTestNg, EventHubPropertyTest003, TestSize.Level1)
176 {
177 /**
178 * @tc.steps: step1. Create EventHub.
179 * @tc.expected: eventHub is not null.
180 */
181 auto eventHub = AceType::MakeRefPtr<EventHub>();
182 EXPECT_NE(eventHub, nullptr);
183
184 /**
185 * @tc.steps: step2. Set EventHub OnAreaChanged function and fire it.
186 * @tc.expected: onAreaChanged is invoked and the temp values are assigned with correct values.
187 */
188 RectF tempOldRect;
189 OffsetF tempOldOrigin;
190 RectF tempNewRect;
191 OffsetF tempNewOrigin;
192 auto onAreaChanged = [&tempOldRect, &tempOldOrigin, &tempNewRect, &tempNewOrigin](
__anon3541bcd40202( const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 193 const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {
194 tempOldRect = oldRect;
195 tempOldOrigin = oldOrigin;
196 tempNewRect = rect;
197 tempNewOrigin = origin;
198 };
199
200 eventHub->SetOnAreaChanged(onAreaChanged);
201 eventHub->FireOnAreaChanged(OLD_RECT, OLD_ORIGIN, NEW_RECT, NEW_ORIGIN);
202 EXPECT_TRUE(eventHub->HasOnAreaChanged());
203 EXPECT_EQ(tempOldRect, OLD_RECT);
204 EXPECT_EQ(tempOldOrigin, OLD_ORIGIN);
205 EXPECT_EQ(tempNewRect, NEW_RECT);
206 EXPECT_EQ(tempNewOrigin, NEW_ORIGIN);
207
208 /**
209 * @tc.steps: step3. Set/fire EventHub onAppear and onDisappear function.
210 * @tc.expected: isAppear is assigned with correct value.
211 */
__anon3541bcd40302() 212 eventHub->SetOnAppear([]() {});
213 eventHub->FireOnAppear();
__anon3541bcd40402() 214 eventHub->SetOnDisappear([]() {});
215 eventHub->FireOnDisappear();
216 }
217
218 /**
219 * @tc.name: EventHubDragEventsTest004
220 * @tc.desc: Create EventHub and set/fire drag related functions.
221 * @tc.type: FUNC
222 */
223 HWTEST_F(EventHubTestNg, EventHubDragEventsTest004, TestSize.Level1)
224 {
225 /**
226 * @tc.steps: step1. Create EventHub.
227 * @tc.expected: eventHub is not null.
228 */
229 auto eventHub = AceType::MakeRefPtr<EventHub>();
230 EXPECT_NE(eventHub, nullptr);
231
232 /**
233 * @tc.steps: step2. Set EventHub OnDragStart event and fire it.
234 * @tc.expected: OnDragStart is invoked and the temp values are assigned with correct values.
235 */
236 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
237 std::string dragEventType;
238 auto OnDragStartFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon3541bcd40502(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 239 const std::string& eventType) -> DragDropInfo {
240 dragEventType = eventType;
241 return {};
242 };
243 eventHub->SetOnDragStart(OnDragStartFunc);
244 EXPECT_TRUE(eventHub->HasOnDragStart());
245 EXPECT_NE(eventHub->GetOnDragStart(), nullptr);
246 eventHub->GetOnDragStart()(dragEvent, DRAG_STARR_EVENT_TYPE);
247 EXPECT_EQ(dragEventType, DRAG_STARR_EVENT_TYPE);
248
249 /**
250 * @tc.steps: step3. Set EventHub OnDragEnter event and fire it.
251 * @tc.expected: OnDragEnter is invoked and the temp values are assigned with correct values.
252 */
253 auto OnDragFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon3541bcd40602(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 254 const std::string& eventType) { dragEventType = eventType; };
255 auto onDragEnter = OnDragFunc;
256 eventHub->SetOnDragEnter(onDragEnter);
257 eventHub->FireOnDragEnter(dragEvent, DRAG_ENTER_EVENT_TYPE);
258 EXPECT_EQ(dragEventType, DRAG_ENTER_EVENT_TYPE);
259
260 /**
261 * @tc.steps: step4. Set EventHub OnDragLeave event and fire it.
262 * @tc.expected: OnDragLeave is invoked and the temp values are assigned with correct values.
263 */
264 auto onDragLeave = OnDragFunc;
265 eventHub->SetOnDragLeave(onDragLeave);
266 eventHub->FireOnDragLeave(dragEvent, DRAG_LEAVE_EVENT_TYPE);
267 EXPECT_EQ(dragEventType, DRAG_LEAVE_EVENT_TYPE);
268
269 /**
270 * @tc.steps: step5. Set EventHub OnDragMove event and fire it.
271 * @tc.expected: OnDragMove is invoked and the temp values are assigned with correct values.
272 */
273 auto onDragMove = OnDragFunc;
274 eventHub->SetOnDragMove(onDragMove);
275 eventHub->FireOnDragMove(dragEvent, DRAG_MOVE_EVENT_TYPE);
276 EXPECT_EQ(dragEventType, DRAG_MOVE_EVENT_TYPE);
277
278 /**
279 * @tc.steps: step6. Set EventHub OnDrop event and fire it.
280 * @tc.expected: OnDrop is invoked and the temp values are assigned with correct values.
281 */
282 auto onDragDrop = OnDragFunc;
283 eventHub->SetOnDrop(onDragDrop);
284 eventHub->FireOnDragMove(dragEvent, DRAG_DROP_EVENT_TYPE);
285 EXPECT_TRUE(eventHub->HasOnDrop());
286 EXPECT_EQ(dragEventType, DRAG_DROP_EVENT_TYPE);
287 }
288
289 /**
290 * @tc.name: EventHubCreateTest005
291 * @tc.desc: Create EventHub.
292 * @tc.type: FUNC
293 */
294 HWTEST_F(EventHubTestNg, EventHubDragEventsTest005, TestSize.Level1)
295 {
296 auto eventHub = AceType::MakeRefPtr<EventHub>();
297 ASSERT_NE(eventHub, nullptr);
298 std::vector<KeyboardShortcut> keyboardShortcut;
__anon3541bcd40702() 299 eventHub->SetKeyboardShortcut(STRINGCTER_A, NUM_CTRL_VALUE, []() {});
300 keyboardShortcut = eventHub->GetKeyboardShortcut();
301 for (auto iter = keyboardShortcut.begin(); iter != keyboardShortcut.end(); iter++) {
302 EXPECT_EQ(STRINGCTER_A, (*iter).value);
303 EXPECT_EQ(NUM_CTRL_VALUE, (*iter).keys);
304 }
305 keyboardShortcut.clear();
306
__anon3541bcd40802() 307 eventHub->SetKeyboardShortcut(STRINGCTER_Q, NUM_SHIFT_VALUE, []() {});
308 eventHub->GetKeyboardShortcut();
309 for (auto iter = keyboardShortcut.begin(); iter != keyboardShortcut.end(); iter++) {
310 EXPECT_EQ(STRINGCTER_Q, (*iter).value);
311 EXPECT_EQ(NUM_SHIFT_VALUE, (*iter).keys);
312 }
313 keyboardShortcut.clear();
314
__anon3541bcd40902() 315 eventHub->SetKeyboardShortcut(STRINGCTER_E, NUM_ALT_VALUE, []() {});
316 eventHub->GetKeyboardShortcut();
317 for (auto iter = keyboardShortcut.begin(); iter != keyboardShortcut.end(); iter++) {
318 EXPECT_EQ(STRINGCTER_E, (*iter).value);
319 EXPECT_EQ(NUM_CTRL_VALUE, (*iter).keys);
320 }
321 keyboardShortcut.clear();
322 }
323
324 /**
325 * @tc.name: EventHubDragEventsTest006
326 * @tc.desc: Create EventHub and set/fire drag related customer functions.
327 * @tc.type: FUNC
328 */
329 HWTEST_F(EventHubTestNg, EventHubDragEventsTest006, TestSize.Level1)
330 {
331 /**
332 * @tc.steps: step1. Create EventHub.
333 * @tc.expected: eventHub is not null.
334 */
335 auto eventHub = AceType::MakeRefPtr<EventHub>();
336 EXPECT_NE(eventHub, nullptr);
337
338 /**
339 * @tc.steps: step2. Set EventHub Customer OnDragEnter event and fire it.
340 * @tc.expected: OnDragEnter is invoked and the temp values are assigned with correct values.
341 */
342 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
343 std::string dragEventType;
344 auto OnDragFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon3541bcd40a02(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 345 const std::string& eventType) { dragEventType = eventType; };
346 auto onDragEnter = OnDragFunc;
347 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_ENTER, onDragEnter);
348 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_ENTER, dragEvent, DRAG_ENTER_EVENT_TYPE);
349 EXPECT_EQ(dragEventType, DRAG_ENTER_EVENT_TYPE);
350
351 /**
352 * @tc.steps: step3. Set EventHub Customer OnDragLeave event and fire it.
353 * @tc.expected: OnDragLeave is invoked and the temp values are assigned with correct values.
354 */
355 auto onDragLeave = OnDragFunc;
356 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_LEAVE, onDragLeave);
357 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_LEAVE, dragEvent, DRAG_LEAVE_EVENT_TYPE);
358 EXPECT_EQ(dragEventType, DRAG_LEAVE_EVENT_TYPE);
359
360 /**
361 * @tc.steps: step4. Set EventHub Customer OnDragMove event and fire it.
362 * @tc.expected: OnDragMove is invoked and the temp values are assigned with correct values.
363 */
364 auto onDragMove = OnDragFunc;
365 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_MOVE, onDragMove);
366 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_MOVE, dragEvent, DRAG_MOVE_EVENT_TYPE);
367 EXPECT_EQ(dragEventType, DRAG_MOVE_EVENT_TYPE);
368
369 /**
370 * @tc.steps: step6. Set EventHub Customer OnDrop event and fire it.
371 * @tc.expected: OnDrop is invoked and the temp values are assigned with correct values.
372 */
373 auto onDragDrop = OnDragFunc;
374 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_DROP, onDragDrop);
375 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_DROP, dragEvent, DRAG_DROP_EVENT_TYPE);
376 EXPECT_TRUE(eventHub->HasCustomerOnDrop());
377 EXPECT_EQ(dragEventType, DRAG_DROP_EVENT_TYPE);
378
379 /**
380 * @tc.steps: step7. Set EventHub Customer OnDragEnd event and fire it.
381 * @tc.expected: OnDragEnd is invoked and the temp values are assigned with correct values.
382 */
__anon3541bcd40b02(const RefPtr<OHOS::Ace::DragEvent>& ) 383 auto OnDragEnd = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */) {
384 dragEventType = DRAG_END_EVENT_TYPE;
385 };
386 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_END, OnDragEnd);
387 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_END, dragEvent);
388 EXPECT_EQ(dragEventType, DRAG_END_EVENT_TYPE);
389 }
390
391 /**
392 * @tc.name: EventHubDisableAreaChange001
393 * @tc.desc: Create EventHub and test disable areaChange function.
394 * @tc.type: FUNC
395 */
396 HWTEST_F(EventHubTestNg, EventHubDisableAreaChange001, TestSize.Level1)
397 {
398 /**
399 * @tc.steps: step1. Create EventHub.
400 * @tc.expected: eventHub is not null.
401 */
402 auto eventHub = AceType::MakeRefPtr<EventHub>();
403 EXPECT_NE(eventHub, nullptr);
404
405 /**
406 * @tc.steps: step2. Set EventHub OnAreaChanged function and fire it.
407 * @tc.expected: onAreaChanged is invoked and the temp values are assigned with correct values.
408 */
409 RectF tempOldRect;
410 OffsetF tempOldOrigin;
411 RectF tempNewRect;
412 OffsetF tempNewOrigin;
413 auto onAreaChanged = [&tempOldRect, &tempOldOrigin, &tempNewRect, &tempNewOrigin](
__anon3541bcd40c02( const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 414 const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {
415 tempOldRect = oldRect;
416 tempOldOrigin = oldOrigin;
417 tempNewRect = rect;
418 tempNewOrigin = origin;
419 };
420
421 eventHub->SetOnAreaChanged(onAreaChanged);
422 eventHub->FireOnAreaChanged(OLD_RECT, OLD_ORIGIN, NEW_RECT, NEW_ORIGIN);
423 EXPECT_TRUE(eventHub->HasOnAreaChanged());
424 EXPECT_EQ(tempOldRect, OLD_RECT);
425 EXPECT_EQ(tempOldOrigin, OLD_ORIGIN);
426 EXPECT_EQ(tempNewRect, NEW_RECT);
427 EXPECT_EQ(tempNewOrigin, NEW_ORIGIN);
428
429 /**
430 * @tc.steps: step3. Clear the callback.
431 * @tc.expected: onAreaChanged is empty.
432 */
433 eventHub->ClearUserOnAreaChanged();
434 eventHub->FireOnAreaChanged(
435 OLD_RECT + OFFSET_DELTA, OLD_ORIGIN + ORIGIN_DELTA, NEW_RECT + OFFSET_DELTA, NEW_ORIGIN + ORIGIN_DELTA);
436 EXPECT_FALSE(eventHub->HasOnAreaChanged());
437 EXPECT_EQ(tempOldRect, OLD_RECT);
438 EXPECT_EQ(tempOldOrigin, OLD_ORIGIN);
439 EXPECT_EQ(tempNewRect, NEW_RECT);
440 EXPECT_EQ(tempNewOrigin, NEW_ORIGIN);
441
442 /**
443 * @tc.steps: step3. Set/fire areaChange function.
444 * @tc.expected: areaChange is assigned with correct value.
445 */
446 eventHub->SetOnAreaChanged(onAreaChanged);
447 eventHub->FireOnAreaChanged(
448 OLD_RECT + OFFSET_DELTA, OLD_ORIGIN + ORIGIN_DELTA, NEW_RECT + OFFSET_DELTA, NEW_ORIGIN + ORIGIN_DELTA);
449 EXPECT_TRUE(eventHub->HasOnAreaChanged());
450 EXPECT_EQ(tempOldRect, OLD_RECT + OFFSET_DELTA);
451 EXPECT_EQ(tempOldOrigin, OLD_ORIGIN + ORIGIN_DELTA);
452 EXPECT_EQ(tempNewRect, NEW_RECT + OFFSET_DELTA);
453 EXPECT_EQ(tempNewOrigin, NEW_ORIGIN + ORIGIN_DELTA);
454 }
455
456 /**
457 * @tc.name: EventHubDisableAppear001
458 * @tc.desc: Create EventHub and test disable onAppear function.
459 * @tc.type: FUNC
460 */
461 HWTEST_F(EventHubTestNg, EventHubDisableAppear001, TestSize.Level1)
462 {
463 /**
464 * @tc.steps: step1. Create EventHub.
465 * @tc.expected: eventHub is not null.
466 */
467 auto eventHub = AceType::MakeRefPtr<EventHub>();
468 EXPECT_NE(eventHub, nullptr);
469
470 /**
471 * @tc.steps: step2. Set EventHub onAppear function and fire it.
472 * @tc.expected: onAppear is invoked and the temp values are assigned with correct values.
473 */
474 std::string result;
__anon3541bcd40d02() 475 auto onAppear = [&result]() { result = RESULT_SUCCESS_ONE; };
476
477 eventHub->SetOnAppear(onAppear);
478 EXPECT_NE(eventHub->onAppear_, nullptr);
479 eventHub->onAppear_();
480 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
481 /**
482 * @tc.steps: step3. Clear the callback.
483 * @tc.expected: onAppear is empty.
484 */
485 eventHub->ClearUserOnAppear();
486 EXPECT_EQ(eventHub->onAppear_, nullptr);
487
488 /**
489 * @tc.steps: step3. Set/fire EventHub onAppear function.
490 * @tc.expected: onAppear is assigned with correct value.
491 */
__anon3541bcd40e02() 492 auto onAppear2 = [&result]() { result = RESULT_SUCCESS_TWO; };
493
494 eventHub->SetOnAppear(onAppear2);
495 EXPECT_NE(eventHub->onAppear_, nullptr);
496 eventHub->onAppear_();
497 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
498 }
499
500 /**
501 * @tc.name: EventHubDisableDisAppear001
502 * @tc.desc: Create EventHub and test disable onDisAppear function.
503 * @tc.type: FUNC
504 */
505 HWTEST_F(EventHubTestNg, EventHubDisableDisAppear001, TestSize.Level1)
506 {
507 /**
508 * @tc.steps: step1. Create EventHub.
509 * @tc.expected: eventHub is not null.
510 */
511 auto eventHub = AceType::MakeRefPtr<EventHub>();
512 EXPECT_NE(eventHub, nullptr);
513
514 /**
515 * @tc.steps: step2. Set EventHub onDisAppear function and fire it.
516 * @tc.expected: onDisAppear is invoked and the temp values are assigned with correct values.
517 */
518 std::string result;
__anon3541bcd40f02() 519 auto onDisAppear = [&result]() { result = RESULT_SUCCESS_ONE; };
520
521 eventHub->SetOnDisappear(onDisAppear);
522 EXPECT_NE(eventHub->onDisappear_, nullptr);
523 eventHub->onDisappear_();
524 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
525 /**
526 * @tc.steps: step3. Clear the callback.
527 * @tc.expected: onDisAppear is empty.
528 */
529 eventHub->ClearUserOnDisAppear();
530 EXPECT_EQ(eventHub->onDisappear_, nullptr);
531
532 /**
533 * @tc.steps: step3. Set/fire EventHub onDisappear function.
534 * @tc.expected: disAppear is assigned with correct value.
535 */
__anon3541bcd41002() 536 auto onDisAppear2 = [&result]() { result = RESULT_SUCCESS_TWO; };
537
538 eventHub->SetOnDisappear(onDisAppear2);
539 EXPECT_NE(eventHub->onDisappear_, nullptr);
540 eventHub->onDisappear_();
541 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
542 }
543
544 /**
545 * @tc.name: SetCurrentUIState001
546 * @tc.desc: Create EventHub and test disable onDisAppear function.
547 * @tc.type: FUNC
548 */
549 HWTEST_F(EventHubTestNg, SetCurrentUIState002, TestSize.Level1)
550 {
551 /**
552 * @tc.steps: step1. Create EventHub.
553 * @tc.expected: eventHub is not null.
554 */
555 auto eventHub = AceType::MakeRefPtr<EventHub>();
556 EXPECT_NE(eventHub, nullptr);
557 bool temp = true;
558
559 /**
560 * @tc.steps: Use SetCurrentUIState to set the UIState state
561 * @tc.expected: Use 'GetCurrentUIState' to obtain the already set UIState
562 */
563 eventHub->AddSupportedState(UI_STATE_NORMAL);
564 eventHub->SetSupportedStates(UI_STATE_NORMAL);
565 eventHub->MarkModifyDone();
566
567 eventHub->SetCurrentUIState(UI_STATE_NORMAL, temp);
568 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_NORMAL);
569
570 eventHub->IsCurrentStateOn(UI_STATE_NORMAL);
571 eventHub->CreateGetEventTargetImpl();
572
573 eventHub->SetCurrentUIState(UI_STATE_PRESSED, temp);
574 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_PRESSED);
575
576 eventHub->SetCurrentUIState(UI_STATE_FOCUSED, temp);
577 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_NORMAL | UI_STATE_PRESSED | UI_STATE_FOCUSED);
578 eventHub->MarkModifyDone();
579
580 eventHub->SetCurrentUIState(UI_STATE_DISABLED, temp);
581 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_NORMAL | UI_STATE_PRESSED | UI_STATE_FOCUSED | UI_STATE_DISABLED);
582
583 eventHub->SetCurrentUIState(UI_STATE_SELECTED, temp);
584 EXPECT_EQ(eventHub->GetCurrentUIState(),
585 UI_STATE_SELECTED | UI_STATE_NORMAL | UI_STATE_PRESSED | UI_STATE_FOCUSED | UI_STATE_DISABLED);
586 }
587
588 /**
589 * @tc.name: EventHubTest001
590 * @tc.desc: Default branch in test FireCustomerOnDragFunc
591 * @tc.type: FUNC
592 */
593 HWTEST_F(EventHubTestNg, EventHubTest001, TestSize.Level1)
594 {
595 /**
596 * @tc.steps: step1. Create EventHub.
597 * @tc.expected: eventHub is not null.
598 */
599 auto eventHub = AceType::MakeRefPtr<EventHub>();
600 EXPECT_NE(eventHub, nullptr);
601
602 /**
603 * @tc.steps: step2. Create DragEvent.
604 * @tc.expected: DragEvent is not null.
605 */
606 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
607 EXPECT_NE(dragEvent, nullptr);
608
609 /**
610 * @tc.steps: step3. Calling DRAG in FirecustomerOnDragFunc_ CustomerOnDragEnd in END_ Empty branch.
611 * @tc.expected: retFlag is false.
612 */
613 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_END, dragEvent, DRAG_DROP_EVENT_TYPE);
614 auto retFlag = eventHub->HasCustomerOnDrop();
615 EXPECT_FALSE(retFlag);
616
617 /**
618 * @tc.steps: step4. Calling the default branch in FirecustomerOnDragFunc.
619 * @tc.expected: retFlag is false.
620 */
621 eventHub->FireCustomerOnDragFunc(DragFuncType(10), dragEvent, DRAG_DROP_EVENT_TYPE);
622 retFlag = eventHub->HasCustomerOnDrop();
623 EXPECT_FALSE(retFlag);
624 }
625
626 /**
627 * @tc.name: EventHubTest002
628 * @tc.desc: Default Branch in Test SetCustomerOnDragFunc(OnDragFunc)
629 * @tc.type: FUNC
630 */
631 HWTEST_F(EventHubTestNg, EventHubTest002, TestSize.Level1)
632 {
633 /**
634 * @tc.steps: step1. Create EventHub.
635 * @tc.expected: eventHub is not null.
636 */
637 auto eventHub = AceType::MakeRefPtr<EventHub>();
638 EXPECT_NE(eventHub, nullptr);
639
640 /**
641 * @tc.steps: step2. Create DragEvent.
642 * @tc.expected: DragEvent is not null.
643 */
644 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
645 EXPECT_NE(dragEvent, nullptr);
646
647 /**
648 * @tc.steps: step3. construct OnDragFunc.
649 */
650 std::string dragEventType;
651 auto onDragFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon3541bcd41102(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 652 const std::string& eventType) { dragEventType = eventType; };
653
654 /**
655 * @tc.steps: step4. Calling the default branch in SetCustomerOnDragFunc.
656 * @tc.expected: eventHub->customerOnDragEnd_ is false.
657 */
658 eventHub->SetCustomerOnDragFunc(DragFuncType(10), onDragFunc);
659 EXPECT_FALSE(eventHub->customerOnDragEnd_);
660 }
661
662 /**
663 * @tc.name: EventHubTest003
664 * @tc.desc: Default Branch in Test SetCustomerOnDragFunc(OnNewDragFunc)
665 * @tc.type: FUNC
666 */
667 HWTEST_F(EventHubTestNg, EventHubTest003, TestSize.Level1)
668 {
669 /**
670 * @tc.steps: step1. Create EventHub.
671 * @tc.expected: eventHub is not null.
672 */
673 auto eventHub = AceType::MakeRefPtr<EventHub>();
674 EXPECT_NE(eventHub, nullptr);
675
676 /**
677 * @tc.steps: step2. Create DragEvent.
678 * @tc.expected: DragEvent is not null.
679 */
680 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
681 EXPECT_NE(dragEvent, nullptr);
682
683 /**
684 * @tc.steps: step3. construct OnDragFunc.
685 */
686 std::string dragEventType;
687 auto onDragFunc = [&dragEventType](
__anon3541bcd41202( const RefPtr<OHOS::Ace::DragEvent>& ) 688 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */) { dragEventType = DRAG_END_EVENT_TYPE; };
689
690 /**
691 * @tc.steps: step4. Call SetCustomerOnDragFunc with OnDragFunc.
692 * @tc.expected: eventHub->customerOnDragEnter_ is false.
693 */
694 eventHub->SetCustomerOnDragFunc(DragFuncType(10), onDragFunc);
695 EXPECT_FALSE(eventHub->customerOnDragEnter_);
696 }
697
698 /**
699 * @tc.name: EventHubTest004
700 * @tc.desc: Test MarkModifyDone
701 * @tc.type: FUNC
702 */
703 HWTEST_F(EventHubTestNg, EventHubTest004, TestSize.Level1)
704 {
705 /**
706 * @tc.steps: step1. Create EventHub.
707 * @tc.expected: eventHub is not null.
708 */
709 auto eventHub = AceType::MakeRefPtr<EventHub>();
710 EXPECT_NE(eventHub, nullptr);
711
712 /**
713 * @tc.steps: step2. Update SupportedState in eventHub using UI_STATE_PRESSED.
714 */
715 eventHub->AddSupportedState(UI_STATE_PRESSED);
716 eventHub->SetSupportedStates(UI_STATE_PRESSED);
717
718 /**
719 * @tc.steps: step3. Call MarkModifyDone, stateStyleMgr_->HasStateStyle(UI_STATE_PRESSED) is a true branch.
720 * @tc.expected: retFlag is true.
721 */
722 eventHub->MarkModifyDone();
723 bool retFlag = eventHub->stateStyleMgr_->HasStateStyle(UI_STATE_PRESSED);
724 EXPECT_TRUE(retFlag);
725
726 /**
727 * @tc.steps: step4. Update SupportedState in eventHub using UI_STATE_DISABLED.
728 */
729 eventHub->AddSupportedState(UI_STATE_DISABLED);
730 eventHub->SetSupportedStates(UI_STATE_DISABLED);
731
732 /**
733 * @tc.steps: step5. Call MarkModifyDone, stateStyleMgr_->HasStateStyle(UI_STATE_DISABLED) is a true branch.
734 * @tc.expected: retFlag is true.
735 */
736 eventHub->MarkModifyDone();
737 retFlag = eventHub->stateStyleMgr_->HasStateStyle(UI_STATE_DISABLED);
738 EXPECT_TRUE(retFlag);
739
740 /**
741 * @tc.steps: step6. Update SupportedState in eventHub using UI_STATE_DISABLED.
742 */
743 eventHub->AddSupportedState(UI_STATE_DISABLED);
744 eventHub->SetSupportedStates(UI_STATE_DISABLED);
745 eventHub->SetEnabled(false);
746
747 /**
748 * @tc.steps: step7. Call MarkModifyDone, enabled_ is a false branch.
749 * @tc.expected: eventHub->IsEnabled() return value is false.
750 */
751 eventHub->MarkModifyDone();
752 EXPECT_FALSE(eventHub->IsEnabled());
753 }
754
755 /**
756 * @tc.name: EventHubTest005
757 * @tc.desc: stateStyleMgr_ in Test SetSupportedStates is a fake branch
758 * @tc.type: FUNC
759 */
760 HWTEST_F(EventHubTestNg, EventHubTest005, TestSize.Level1)
761 {
762 /**
763 * @tc.steps: step1. Create EventHub.
764 * @tc.expected: eventHub is not null.
765 */
766 auto eventHub = AceType::MakeRefPtr<EventHub>();
767 EXPECT_NE(eventHub, nullptr);
768
769 /**
770 * @tc.steps: step2. Call SetSupportedStates with UI_STATE_PRESSED.
771 * @tc.expected: eventHub->stateStyleMgr_ is true.
772 */
773 eventHub->stateStyleMgr_ = nullptr;
774 eventHub->SetSupportedStates(UI_STATE_PRESSED);
775 EXPECT_TRUE(eventHub->stateStyleMgr_);
776 }
777
778 /**
779 * @tc.name: EventHubFrameNodeTest001
780 * @tc.desc: test ClearJSFrameNodeOnDisappear
781 * @tc.type: FUNC
782 */
783 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest001, TestSize.Level1)
784 {
785 /**
786 * @tc.steps: step1. Create EventHub.
787 * @tc.expected: eventHub is not null.
788 */
789 auto eventHub = AceType::MakeRefPtr<EventHub>();
790 EXPECT_NE(eventHub, nullptr);
791
792 /**
793 * @tc.steps: step2. Call ClearJSFrameNodeOnDisappear with onJSFrameNodeDisappear_ is nullptr.
794 * @tc.expected: eventHub->onJSFrameNodeDisappear_ is nullptr.
795 */
796 eventHub->onJSFrameNodeDisappear_ = nullptr;
797 eventHub->ClearJSFrameNodeOnDisappear();
798 EXPECT_EQ(eventHub->onJSFrameNodeDisappear_, nullptr);
799
800 /**
801 * @tc.steps: step3. Call ClearJSFrameNodeOnDisappear with onJSFrameNodeDisappear_ is not nullptr.
802 * @tc.expected: flag is equal 1.
803 */
__anon3541bcd41302() 804 std::function<void()> flagFunc = []() { ++flag; };
805 eventHub->SetJSFrameNodeOnDisappear(std::move(flagFunc));
806 EXPECT_NE(eventHub->onJSFrameNodeDisappear_, nullptr);
807 eventHub->ClearJSFrameNodeOnDisappear();
808 EXPECT_EQ(eventHub->onJSFrameNodeDisappear_, nullptr);
809 }
810
811 /**
812 * @tc.name: EventHubFrameNodeTest002
813 * @tc.desc: test ClearJSFrameNodeOnAppear
814 * @tc.type: FUNC
815 */
816 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest002, TestSize.Level1)
817 {
818 /**
819 * @tc.steps: step1. Create EventHub.
820 * @tc.expected: eventHub is not null.
821 */
822 auto eventHub = AceType::MakeRefPtr<EventHub>();
823 EXPECT_NE(eventHub, nullptr);
824
825 /**
826 * @tc.steps: step2. Call ClearJSFrameNodeOnAppear with onJSFrameNodeAppear_ is nullptr.
827 * @tc.expected: eventHub->onJSFrameNodeAppear_ is nullptr.
828 */
829 eventHub->onJSFrameNodeAppear_ = nullptr;
830 eventHub->ClearJSFrameNodeOnAppear();
831 EXPECT_EQ(eventHub->onJSFrameNodeAppear_, nullptr);
832
833 /**
834 * @tc.steps: step3. Call ClearJSFrameNodeOnAppear with onJSFrameNodeDisappear_ is not nullptr.
835 * @tc.expected:onJSFrameNodeAppear_ is nullptr.
836 */
__anon3541bcd41402() 837 std::function<void()> flagFunc = []() { ++flag; };
838 eventHub->SetJSFrameNodeOnAppear(std::move(flagFunc));
839 EXPECT_NE(eventHub->onJSFrameNodeAppear_, nullptr);
840 eventHub->ClearJSFrameNodeOnAppear();
841 EXPECT_EQ(eventHub->onJSFrameNodeAppear_, nullptr);
842 }
843
844 /**
845 * @tc.name: EventHubFrameNodeTest003
846 * @tc.desc: test FireOnAppear
847 * @tc.type: FUNC
848 */
849 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest003, TestSize.Level1)
850 {
851 /**
852 * @tc.steps: step1. Create EventHub.
853 * @tc.expected: eventHub is not null.
854 */
855 auto eventHub = AceType::MakeRefPtr<EventHub>();
856 EXPECT_NE(eventHub, nullptr);
857
858 /**
859 * @tc.steps: step2. Call FireOnAppear with onAppear_ and onJSFrameNodeAppear_ are both nullptr.
860 * @tc.expected: flag is equal 0.
861 */
862 eventHub->onAppear_ = nullptr;
863 eventHub->onJSFrameNodeAppear_ = nullptr;
864 eventHub->FireOnAppear();
865 EXPECT_EQ(flag, 0);
866
867 /**
868 * @tc.steps: step3. Call FireOnAppear with onAppear_ is nullptr and onJSFrameNodeAppear_ are is not nullptr.
869 * @tc.expected: onJSFrameNodeAppear_ is not nullptr.
870 */
__anon3541bcd41502() 871 std::function<void()> flagFunc = []() { ++flag; };
872 eventHub->SetJSFrameNodeOnAppear(std::move(flagFunc));
873 eventHub->FireOnAppear();
874 EXPECT_NE(eventHub->onJSFrameNodeAppear_, nullptr);
875 }
876
877 /**
878 * @tc.name: EventHubFrameNodeTest004
879 * @tc.desc: test FireOnDisappear
880 * @tc.type: FUNC
881 */
882 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest004, TestSize.Level1)
883 {
884 /**
885 * @tc.steps: step1. Create EventHub.
886 * @tc.expected: eventHub is not null.
887 */
888 auto eventHub = AceType::MakeRefPtr<EventHub>();
889 EXPECT_NE(eventHub, nullptr);
890
891 /**
892 * @tc.steps: step2. Call FireOnDisappear with onAppear_ and onJSFrameNodeAppear_ are both nullptr.
893 * @tc.expected: flag is equal 0.
894 */
895 eventHub->onDisappear_ = nullptr;
896 eventHub->onJSFrameNodeDisappear_ = nullptr;
897 eventHub->FireOnDisappear();
898 EXPECT_EQ(flag, 0);
899
900 /**
901 * @tc.steps: step3. Call FireOnDisappear with onAppear_ is and onJSFrameNodeAppear_ are both not nullptr.
902 * @tc.expected: flag is equal 2.
903 */
__anon3541bcd41602() 904 std::function<void()> flagFunc = []() { flag++; };
905 eventHub->onDisappear_ = flagFunc;
906 eventHub->onJSFrameNodeDisappear_ = flagFunc;
907 eventHub->FireOnDisappear();
908 EXPECT_EQ(flag, 2);
909 }
910
911 /**
912 * @tc.name: EventHubFrameNodeTest005
913 * @tc.desc: test set event about visibleAreaChange
914 * @tc.type: FUNC
915 */
916 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest005, TestSize.Level1)
917 {
918 /**
919 * @tc.steps: step1. Create EventHub.
920 * @tc.expected: eventHub is not null.
921 */
922 auto eventHub = AceType::MakeRefPtr<EventHub>();
923 EXPECT_NE(eventHub, nullptr);
924
925 /**
926 * @tc.steps: step2. set throttledVisibleAreaRatios_, throttledVisibleAreaCallback_.
927 * @tc.expected: HasImmediatelyVisibleCallback is equal to false.
928 */
929 VisibleCallbackInfo callbackInfo;
__anon3541bcd41702(bool isVisible, double radio) 930 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
931 callbackInfo.callback = jsCallback;
932 callbackInfo.period = MIN_INTERVAL;
933 std::vector<double> ratios = { 0, 1.0 };
934 flag = 0;
935 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
936 EXPECT_EQ(flag, 0);
937 EXPECT_NE(eventHub->HasImmediatelyVisibleCallback(), true);
938 EXPECT_EQ(eventHub->GetThrottledVisibleAreaRatios(), ratios);
939 EXPECT_NE(eventHub->GetThrottledVisibleAreaCallback().callback, nullptr);
940
941 /**
942 * @tc.steps: step3. clear throttledVisibleAreaRatios_, throttledVisibleAreaCallback_.
943 * @tc.expected:throttledVisibleAreaRatios_ is empty, callback in throttledVisibleAreaCallback_ is nullptr.
944 */
945 eventHub->CleanVisibleAreaCallback(true, true);
946 EXPECT_EQ(eventHub->GetThrottledVisibleAreaRatios().empty(), true);
947 EXPECT_EQ(eventHub->GetThrottledVisibleAreaCallback().callback, nullptr);
948
949 /**
950 * @tc.steps: step4. set visibleAreaUserCallback_.
951 * @tc.expected: HasImmediatelyVisibleCallback is equal to true.
952 */
953 callbackInfo.period = 0;
954 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
955 EXPECT_EQ(flag, 0);
956 EXPECT_EQ(eventHub->HasImmediatelyVisibleCallback(), true);
957 }
958
959 /**
960 * @tc.name: EventHubTest006
961 * @tc.desc: OnAttachContext
962 * @tc.type: FUNC
963 */
964 HWTEST_F(EventHubTestNg, EventHubTest006, TestSize.Level1)
965 {
966 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
967 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
968 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
969 RectF tempOldRect;
970 OffsetF tempOldOrigin;
971 RectF tempNewRect;
972 OffsetF tempNewOrigin;
973 auto onAreaChanged = [&tempOldRect, &tempOldOrigin, &tempNewRect, &tempNewOrigin](
__anon3541bcd41802( const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 974 const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {
975 tempOldRect = oldRect;
976 tempOldOrigin = oldOrigin;
977 tempNewRect = rect;
978 tempNewOrigin = origin;
979 };
980
981 eventHub->SetOnAreaChanged(onAreaChanged);
982 eventHub->GetOrCreateGestureEventHub();
983 eventHub->GetOrCreateInputEventHub();
984 eventHub->GetOrCreateFocusHub();
985
986 VisibleCallbackInfo callbackInfo;
__anon3541bcd41902(bool isVisible, double radio) 987 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
988 callbackInfo.callback = jsCallback;
989 callbackInfo.period = MIN_INTERVAL;
990 callbackInfo.period = 0;
991 std::vector<double> ratios = { 0, 1.0 };
992 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
993
994 auto context = MockPipelineContext::GetCurrent();
995 eventHub->OnAttachContext(AceType::RawPtr(context));
996 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
997 }
998
999 /**
1000 * @tc.name: EventHubTest007
1001 * @tc.desc: OnAttachContext
1002 * @tc.type: FUNC
1003 */
1004 HWTEST_F(EventHubTestNg, EventHubTest007, TestSize.Level1)
1005 {
1006 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1007 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
1008
1009 eventHub->GetOrCreateGestureEventHub();
1010 eventHub->GetOrCreateInputEventHub();
1011 eventHub->GetOrCreateFocusHub();
1012 bool flags = false;
1013 OnAreaChangedFunc onAreaChanged = [&flags](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect,
__anon3541bcd41a02(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1014 const OffsetF& origin) { flags = !flags; };
1015 eventHub->AddInnerOnAreaChangedCallback(1, std::move(onAreaChanged));
1016 VisibleCallbackInfo callbackInfo;
__anon3541bcd41b02(bool isVisible, double radio) 1017 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
1018 callbackInfo.callback = jsCallback;
1019 callbackInfo.period = MIN_INTERVAL;
1020 std::vector<double> ratios = { 0, 1.0 };
1021 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, false);
1022
1023 eventHub->OnAttachContext(nullptr);
1024 auto context = MockPipelineContext::GetCurrent();
1025 eventHub->OnAttachContext(AceType::RawPtr(context));
1026 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1027 }
1028
1029 /**
1030 * @tc.name: EventHubTest008
1031 * @tc.desc: OnDetachContext
1032 * @tc.type: FUNC
1033 */
1034 HWTEST_F(EventHubTestNg, EventHubTest008, TestSize.Level1)
1035 {
1036 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1037 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
1038 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
1039 RectF tempOldRect;
1040 OffsetF tempOldOrigin;
1041 RectF tempNewRect;
1042 OffsetF tempNewOrigin;
1043 auto onAreaChanged = [&tempOldRect, &tempOldOrigin, &tempNewRect, &tempNewOrigin](
__anon3541bcd41c02( const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1044 const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {
1045 tempOldRect = oldRect;
1046 tempOldOrigin = oldOrigin;
1047 tempNewRect = rect;
1048 tempNewOrigin = origin;
1049 };
1050
1051 eventHub->SetOnAreaChanged(onAreaChanged);
1052 eventHub->GetOrCreateGestureEventHub();
1053 eventHub->GetOrCreateInputEventHub();
1054 eventHub->GetOrCreateFocusHub();
1055
1056 VisibleCallbackInfo callbackInfo;
__anon3541bcd41d02(bool isVisible, double radio) 1057 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
1058 callbackInfo.callback = jsCallback;
1059 callbackInfo.period = MIN_INTERVAL;
1060 callbackInfo.period = 0;
1061 std::vector<double> ratios = { 0, 1.0 };
1062 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
1063
1064 auto context = MockPipelineContext::GetCurrent();
1065 eventHub->OnDetachContext(AceType::RawPtr(context));
1066 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1067 }
1068
1069 /**
1070 * @tc.name: EventHubTest009
1071 * @tc.desc: OnDetachContext
1072 * @tc.type: FUNC
1073 */
1074 HWTEST_F(EventHubTestNg, EventHubTest009, TestSize.Level1)
1075 {
1076 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1077 auto eventHub = frameNode->GetOrCreateEventHub<EventHub>();
1078 eventHub->GetOrCreateGestureEventHub();
1079 eventHub->GetOrCreateInputEventHub();
1080 eventHub->GetOrCreateFocusHub();
1081 bool flags = false;
1082 OnAreaChangedFunc onAreaChanged = [&flags](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect,
__anon3541bcd41e02(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1083 const OffsetF& origin) { flags = !flags; };
1084 eventHub->AddInnerOnAreaChangedCallback(1, std::move(onAreaChanged));
1085 VisibleCallbackInfo callbackInfo;
__anon3541bcd41f02(bool isVisible, double radio) 1086 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
1087 callbackInfo.callback = jsCallback;
1088 callbackInfo.period = MIN_INTERVAL;
1089 std::vector<double> ratios = { 0, 1.0 };
1090 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, false);
1091 auto context = MockPipelineContext::GetCurrent();
1092 eventHub->OnDetachContext(AceType::RawPtr(context));
1093 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1094 }
1095
1096 /**
1097 * @tc.name: EventHubTest010
1098 * @tc.desc: FireOnSizeChanged
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(EventHubTestNg, EventHubTest010, TestSize.Level1)
1102 {
1103 auto eventHub = AceType::MakeRefPtr<EventHub>();
1104 bool flags = false;
__anon3541bcd42002(const RectF& oldRect, const RectF& Rect) 1105 OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1106 RectF tempOldRect;
1107 RectF tempNewRect;
1108 eventHub->SetOnSizeChanged(std::move(onSizeChanged));
1109 eventHub->FireOnSizeChanged(tempOldRect, tempNewRect);
1110 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1111 }
1112
1113 /**
1114 * @tc.name: EventHubTest011
1115 * @tc.desc: FireOnSizeChanged
1116 * @tc.type: FUNC
1117 */
1118 HWTEST_F(EventHubTestNg, EventHubTest011, TestSize.Level1)
1119 {
1120 auto eventHub = AceType::MakeRefPtr<EventHub>();
1121 RectF tempOldRect;
1122 RectF tempNewRect;
1123 eventHub->FireOnSizeChanged(tempOldRect, tempNewRect);
1124 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1125 }
1126
1127 /**
1128 * @tc.name: EventHubTest012
1129 * @tc.desc: FireJSFrameNodeOnSizeChanged
1130 * @tc.type: FUNC
1131 */
1132 HWTEST_F(EventHubTestNg, EventHubTest012, TestSize.Level1)
1133 {
1134 auto eventHub = AceType::MakeRefPtr<EventHub>();
1135 bool flags = false;
__anon3541bcd42102(const RectF& oldRect, const RectF& Rect) 1136 OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1137 RectF tempOldRect;
1138 RectF tempNewRect;
1139 eventHub->SetJSFrameNodeOnSizeChangeCallback(std::move(onSizeChanged));
1140 eventHub->FireJSFrameNodeOnSizeChanged(tempOldRect, tempNewRect);
1141 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1142 }
1143
1144 /**
1145 * @tc.name: EventHubTest013
1146 * @tc.desc: FireJSFrameNodeOnSizeChanged
1147 * @tc.type: FUNC
1148 */
1149 HWTEST_F(EventHubTestNg, EventHubTest013, TestSize.Level1)
1150 {
1151 auto eventHub = AceType::MakeRefPtr<EventHub>();
1152 RectF tempOldRect;
1153 RectF tempNewRect;
1154 eventHub->FireJSFrameNodeOnSizeChanged(tempOldRect, tempNewRect);
1155 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1156 }
1157
1158 /**
1159 * @tc.name: EventHubTest014
1160 * @tc.desc:ClearJSFrameNodeOnSizeChange
1161 * @tc.type: FUNC
1162 */
1163 HWTEST_F(EventHubTestNg, EventHubTest014, TestSize.Level1)
1164 {
1165 auto eventHub = AceType::MakeRefPtr<EventHub>();
1166 eventHub->ClearJSFrameNodeOnSizeChange();
1167 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1168 }
1169
1170 /**
1171 * @tc.name: EventHubTest015
1172 * @tc.desc: ClearJSFrameNodeOnSizeChange
1173 * @tc.type: FUNC
1174 */
1175 HWTEST_F(EventHubTestNg, EventHubTest015, TestSize.Level1)
1176 {
1177 auto eventHub = AceType::MakeRefPtr<EventHub>();
1178 bool flags = false;
__anon3541bcd42202(const RectF& oldRect, const RectF& Rect) 1179 OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1180 eventHub->SetJSFrameNodeOnSizeChangeCallback(std::move(onSizeChanged));
1181 eventHub->ClearJSFrameNodeOnSizeChange();
1182 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1183 }
1184
1185 /**
1186 * @tc.name: EventHubTest016
1187 * @tc.desc: FireInnerOnSizeChanged
1188 * @tc.type: FUNC
1189 */
1190 HWTEST_F(EventHubTestNg, EventHubTest016, TestSize.Level1)
1191 {
1192 auto eventHub = AceType::MakeRefPtr<EventHub>();
1193 bool flags = false;
__anon3541bcd42302(const RectF& oldRect, const RectF& Rect) 1194 OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1195 eventHub->AddInnerOnSizeChanged(1, std::move(onSizeChanged));
1196 eventHub->AddInnerOnSizeChanged(2, std::move(onSizeChanged));
1197 RectF tempOldRect;
1198 RectF tempNewRect;
1199 eventHub->FireInnerOnSizeChanged(tempOldRect, tempNewRect);
1200 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1201 }
1202
1203 /**
1204 * @tc.name: EventHubTest017
1205 * @tc.desc: FireInnerOnSizeChanged
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(EventHubTestNg, EventHubTest017, TestSize.Level1)
1209 {
1210 auto eventHub = AceType::MakeRefPtr<EventHub>();
1211 RectF tempOldRect;
1212 RectF tempNewRect;
1213 eventHub->FireInnerOnSizeChanged(tempOldRect, tempNewRect);
1214 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1215 }
1216
1217 /**
1218 * @tc.name: EventHubTest018
1219 * @tc.desc: FireOnAttach
1220 * @tc.type: FUNC
1221 */
1222 HWTEST_F(EventHubTestNg, EventHubTest018, TestSize.Level1)
1223 {
1224 auto eventHub = AceType::MakeRefPtr<EventHub>();
__anon3541bcd42402() 1225 std::function<void()> onAttachCallback = []() {};
1226 eventHub->SetOnAttach(std::move(onAttachCallback));
1227 eventHub->FireOnAttach();
1228 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1229 }
1230
1231 /**
1232 * @tc.name: EventHubTest019
1233 * @tc.desc: FireOnAttach
1234 * @tc.type: FUNC
1235 */
1236 HWTEST_F(EventHubTestNg, EventHubTest019, TestSize.Level1)
1237 {
1238 auto eventHub = AceType::MakeRefPtr<EventHub>();
__anon3541bcd42502() 1239 std::function<void()> onAttachCallback = []() {};
1240 eventHub->SetOnDetach(std::move(onAttachCallback));
1241 eventHub->FireOnDetach();
1242 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1243 }
1244
1245 /**
1246 * @tc.name: EventHubTest020
1247 * @tc.desc: debugEnabled_
1248 * @tc.type: FUNC
1249 */
1250 HWTEST_F(EventHubTestNg, EventHubTest020, TestSize.Level1)
1251 {
1252 auto eventHub = AceType::MakeRefPtr<EventHub>();
1253 SystemProperties::debugEnabled_ = true;
1254 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
1255 eventHub->FireOnDragEnter(dragEvent, DRAG_ENTER_EVENT_TYPE);
1256 eventHub->FireOnDragLeave(dragEvent, DRAG_ENTER_EVENT_TYPE);
1257 eventHub->FireOnDragMove(dragEvent, DRAG_ENTER_EVENT_TYPE);
1258 eventHub->FireOnDrop(dragEvent, DRAG_ENTER_EVENT_TYPE);
1259 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1260 }
1261
1262 /**
1263 * @tc.name: EventHubTest021
1264 * @tc.desc: FireOnWillBind
1265 * @tc.type: FUNC
1266 */
1267 HWTEST_F(EventHubTestNg, EventHubTest021, TestSize.Level1)
1268 {
1269 auto eventHub = AceType::MakeRefPtr<EventHub>();
1270 auto frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
1271 CHECK_NULL_VOID(frameNode);
1272 auto nodeContainerId = frameNode->GetId();
__anon3541bcd42602(int32_t) 1273 std::function<void(int32_t)> onWillBindCallback = [](int32_t) {};
1274 eventHub->SetOnWillBind(std::move(onWillBindCallback));
1275 eventHub->FireOnWillBind(nodeContainerId);
1276 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1277 }
1278
1279 /**
1280 * @tc.name: EventHubTest022
1281 * @tc.desc: FireOnWillUnbind
1282 * @tc.type: FUNC
1283 */
1284 HWTEST_F(EventHubTestNg, EventHubTest022, TestSize.Level1)
1285 {
1286 auto eventHub = AceType::MakeRefPtr<EventHub>();
1287 auto frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
1288 CHECK_NULL_VOID(frameNode);
1289 auto nodeContainerId = frameNode->GetId();
__anon3541bcd42702(int32_t) 1290 std::function<void(int32_t)> onWillUnbindCallback = [](int32_t) {};
1291 eventHub->SetOnWillUnbind(std::move(onWillUnbindCallback));
1292 eventHub->FireOnWillUnbind(nodeContainerId);
1293 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1294 }
1295
1296 /**
1297 * @tc.name: EventHubTest023
1298 * @tc.desc: FireOnBind
1299 * @tc.type: FUNC
1300 */
1301 HWTEST_F(EventHubTestNg, EventHubTest023, TestSize.Level1)
1302 {
1303 auto eventHub = AceType::MakeRefPtr<EventHub>();
1304 auto frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
1305 CHECK_NULL_VOID(frameNode);
1306 auto nodeContainerId = frameNode->GetId();
__anon3541bcd42802(int32_t) 1307 std::function<void(int32_t)> onBindCallback = [](int32_t) {};
1308 eventHub->SetOnBind(std::move(onBindCallback));
1309 eventHub->FireOnBind(nodeContainerId);
1310 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1311 }
1312
1313 /**
1314 * @tc.name: EventHubTest024
1315 * @tc.desc: FireOnUnbind
1316 * @tc.type: FUNC
1317 */
1318 HWTEST_F(EventHubTestNg, EventHubTest024, TestSize.Level1)
1319 {
1320 auto eventHub = AceType::MakeRefPtr<EventHub>();
1321 auto frameNode = NG::ViewStackProcessor::GetInstance()->GetMainFrameNode();
1322 CHECK_NULL_VOID(frameNode);
1323 auto nodeContainerId = frameNode->GetId();
__anon3541bcd42902(int32_t) 1324 std::function<void(int32_t)> onUnbindCallback = [](int32_t) {};
1325 eventHub->SetOnUnbind(std::move(onUnbindCallback));
1326 eventHub->FireOnUnbind(nodeContainerId);
1327 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1328 }
1329
1330 /**
1331 * @tc.name: EventHubTest025
1332 * @tc.desc: AddSupportedUIStateWithCallback
1333 * @tc.type: FUNC
1334 */
1335 HWTEST_F(EventHubTestNg, EventHubTest025, TestSize.Level1)
1336 {
1337 /**
1338 * @tc.steps: step1. Create EventHub.
1339 * @tc.expected: eventHub is not null.
1340 */
1341 auto eventHub = AceType::MakeRefPtr<EventHub>();
1342 EXPECT_NE(eventHub, nullptr);
1343
1344 /**
1345 * @tc.steps: step2. Call AddSupportedUIStateWithCallback using UI_STATE_PRESSED | UI_STATE_NORMAL.
1346 * @tc.expected: retFlag is true.
1347 */
__anon3541bcd42a02(UIState state) 1348 std::function<void(UIState)> callback = [](UIState state) {};
1349 eventHub->AddSupportedUIStateWithCallback(UI_STATE_PRESSED | UI_STATE_NORMAL, callback, true);
1350 bool retFlag = eventHub->stateStyleMgr_->HasStateStyle(UI_STATE_PRESSED | UI_STATE_NORMAL);
1351 EXPECT_TRUE(retFlag);
1352 }
1353
1354 /**
1355 * @tc.name: EventHubTest026
1356 * @tc.desc: AddSupportedUIStateWithCallback
1357 * @tc.type: FUNC
1358 */
1359 HWTEST_F(EventHubTestNg, EventHubTest026, TestSize.Level1)
1360 {
1361 /**
1362 * @tc.steps: step1. Create EventHub.
1363 * @tc.expected: eventHub is not null.
1364 */
1365 auto eventHub = AceType::MakeRefPtr<EventHub>();
1366 EXPECT_NE(eventHub, nullptr);
1367
1368 /**
1369 * @tc.steps: step2. Call AddSupportedUIStateWithCallback using UI_STATE_PRESSED | UI_STATE_NORMAL.
1370 * @tc.expected: stateStyleMgr_ is true.
1371 */
1372 eventHub->stateStyleMgr_ = nullptr;
__anon3541bcd42b02(UIState state) 1373 std::function<void(UIState)> callback = [](UIState state) {};
1374 eventHub->AddSupportedUIStateWithCallback(UI_STATE_PRESSED | UI_STATE_NORMAL, callback, true);
1375 EXPECT_TRUE(eventHub->stateStyleMgr_);
1376 }
1377
1378 /**
1379 * @tc.name: EventHubTest027
1380 * @tc.desc: RemoveSupportedState
1381 * @tc.type: FUNC
1382 */
1383 HWTEST_F(EventHubTestNg, EventHubTest027, TestSize.Level1)
1384 {
1385 /**
1386 * @tc.steps: step1. Create EventHub.
1387 * @tc.expected: eventHub is not null.
1388 */
1389 auto eventHub = AceType::MakeRefPtr<EventHub>();
1390 EXPECT_NE(eventHub, nullptr);
1391
1392 /**
1393 * @tc.steps: step2. RemoveSupportedUIState in eventHub using UI_STATE_NORMAL.
1394 * @tc.expected: retFlag is true.
1395 */
1396 eventHub->RemoveSupportedUIState(UI_STATE_NORMAL, true);
1397 bool retFlag = eventHub->stateStyleMgr_->HasStateStyle(UI_STATE_NORMAL);
1398 EXPECT_TRUE(retFlag);
1399 }
1400
1401 /**
1402 * @tc.name: EventHubTest028
1403 * @tc.desc: RemoveSupportedState
1404 * @tc.type: FUNC
1405 */
1406 HWTEST_F(EventHubTestNg, EventHubTest028, TestSize.Level1)
1407 {
1408 /**
1409 * @tc.steps: step1. Create EventHub.
1410 * @tc.expected: eventHub is not null.
1411 */
1412 auto eventHub = AceType::MakeRefPtr<EventHub>();
1413 EXPECT_NE(eventHub, nullptr);
1414
1415 /**
1416 * @tc.steps: step2. Call AddSupportedUIStateWithCallback using UI_STATE_PRESSED | UI_STATE_NORMAL.
1417 * @tc.expected: retFlag is true.
1418 */
__anon3541bcd42c02(UIState state) 1419 std::function<void(UIState)> callback = [](UIState state) {};
1420 eventHub->AddSupportedUIStateWithCallback(UI_STATE_PRESSED | UI_STATE_NORMAL, callback, true);
1421
1422 /**
1423 * @tc.steps: step3. Call RemoveSupportedState using UI_STATE_PRESSED.
1424 * @tc.expected: stateStyleMgr_ is true. retFlag is true.
1425 */
1426 eventHub->stateStyleMgr_ = nullptr;
1427 eventHub->RemoveSupportedUIState(UI_STATE_PRESSED, true);
1428 EXPECT_TRUE(eventHub->stateStyleMgr_);
1429 bool retFlag = eventHub->stateStyleMgr_->HasStateStyle(UI_STATE_PRESSED);
1430 EXPECT_FALSE(retFlag);
1431 }
1432
1433 /**
1434 * @tc.name: EventHubTest029
1435 * @tc.desc: AddSupportedUIStateWithCallback
1436 * @tc.type: FUNC
1437 */
1438 HWTEST_F(EventHubTestNg, EventHubTest029, TestSize.Level1)
1439 {
1440 /**
1441 * @tc.steps: step1. Create EventHub.
1442 * @tc.expected: eventHub is not null.
1443 */
1444 auto eventHub = AceType::MakeRefPtr<EventHub>();
1445 ASSERT_NE(eventHub, nullptr);
1446
1447 /**
1448 * @tc.steps: step2. Call AddSupportedUIStateWithCallback.
1449 * @tc.expected: userSubscribersExcludeConfigs_ value is correct.
1450 */
1451 UIState uiState = UI_STATE_DISABLED | UI_STATE_FOCUSED | UI_STATE_PRESSED | UI_STATE_NORMAL;
1452 uint64_t expectedValue = uiState;
__anon3541bcd42d02(UIState state) 1453 std::function<void(UIState)> callback = [](UIState state) {};
1454 eventHub->AddSupportedUIStateWithCallback(uiState, callback, false, true);
1455 EXPECT_EQ(expectedValue, eventHub->stateStyleMgr_->userSubscribersExcludeConfigs_);
1456
1457 expectedValue = UI_STATE_FOCUSED | UI_STATE_PRESSED | UI_STATE_NORMAL;
1458 eventHub->AddSupportedUIStateWithCallback(UI_STATE_DISABLED, callback, false, false);
1459 EXPECT_EQ(expectedValue, eventHub->stateStyleMgr_->userSubscribersExcludeConfigs_);
1460
1461 eventHub->AddSupportedUIStateWithCallback(UI_STATE_FOCUSED, callback, true, false);
1462 EXPECT_EQ(expectedValue, eventHub->stateStyleMgr_->userSubscribersExcludeConfigs_);
1463
1464 expectedValue = UI_STATE_PRESSED | UI_STATE_NORMAL;
1465 eventHub->AddSupportedUIStateWithCallback(UI_STATE_FOCUSED, callback, false);
1466 EXPECT_EQ(expectedValue, eventHub->stateStyleMgr_->userSubscribersExcludeConfigs_);
1467
1468 /**
1469 * @tc.steps: step3. Call RemoveSupportedUIState.
1470 * @tc.expected: userSubscribersExcludeConfigs_ value is correct.
1471 */
1472 uiState = UI_STATE_FOCUSED | UI_STATE_PRESSED | UI_STATE_NORMAL;
1473 expectedValue = uiState;
1474 eventHub->AddSupportedUIStateWithCallback(uiState, callback, false, true);
1475 EXPECT_EQ(expectedValue, eventHub->stateStyleMgr_->userSubscribersExcludeConfigs_);
1476
1477 expectedValue = UI_STATE_PRESSED | UI_STATE_NORMAL;
1478 eventHub->RemoveSupportedUIState(UI_STATE_FOCUSED, false);
1479 EXPECT_EQ(expectedValue, eventHub->stateStyleMgr_->userSubscribersExcludeConfigs_);
1480 eventHub->RemoveSupportedUIState(UI_STATE_PRESSED, false);
1481 EXPECT_EQ(EXCLUDE_INNER_FLAG_NONE, eventHub->stateStyleMgr_->userSubscribersExcludeConfigs_);
1482 }
1483 } // namespace OHOS::Ace::NG
1484