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->GetEventHub<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->GetEventHub<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](
__anon0b2cc9720202( 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 */
__anon0b2cc9720302() 212 eventHub->SetOnAppear([]() {});
213 eventHub->FireOnAppear();
214
__anon0b2cc9720402() 215 eventHub->SetOnDisappear([]() {});
216 eventHub->FireOnDisappear();
217 }
218
219 /**
220 * @tc.name: EventHubDragEventsTest004
221 * @tc.desc: Create EventHub and set/fire drag related functions.
222 * @tc.type: FUNC
223 */
224 HWTEST_F(EventHubTestNg, EventHubDragEventsTest004, TestSize.Level1)
225 {
226 /**
227 * @tc.steps: step1. Create EventHub.
228 * @tc.expected: eventHub is not null.
229 */
230 auto eventHub = AceType::MakeRefPtr<EventHub>();
231 EXPECT_NE(eventHub, nullptr);
232
233 /**
234 * @tc.steps: step2. Set EventHub OnDragStart event and fire it.
235 * @tc.expected: OnDragStart is invoked and the temp values are assigned with correct values.
236 */
237 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
238 std::string dragEventType;
239 auto OnDragStartFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon0b2cc9720502(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 240 const std::string& eventType) -> DragDropInfo {
241 dragEventType = eventType;
242 return {};
243 };
244 eventHub->SetOnDragStart(OnDragStartFunc);
245 EXPECT_TRUE(eventHub->HasOnDragStart());
246 EXPECT_NE(eventHub->GetOnDragStart(), nullptr);
247 eventHub->GetOnDragStart()(dragEvent, DRAG_STARR_EVENT_TYPE);
248 EXPECT_EQ(dragEventType, DRAG_STARR_EVENT_TYPE);
249
250 /**
251 * @tc.steps: step3. Set EventHub OnDragEnter event and fire it.
252 * @tc.expected: OnDragEnter is invoked and the temp values are assigned with correct values.
253 */
254 auto OnDragFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon0b2cc9720602(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 255 const std::string& eventType) { dragEventType = eventType; };
256 auto onDragEnter = OnDragFunc;
257 eventHub->SetOnDragEnter(onDragEnter);
258 eventHub->FireOnDragEnter(dragEvent, DRAG_ENTER_EVENT_TYPE);
259 EXPECT_EQ(dragEventType, DRAG_ENTER_EVENT_TYPE);
260
261 /**
262 * @tc.steps: step4. Set EventHub OnDragLeave event and fire it.
263 * @tc.expected: OnDragLeave is invoked and the temp values are assigned with correct values.
264 */
265 auto onDragLeave = OnDragFunc;
266 eventHub->SetOnDragLeave(onDragLeave);
267 eventHub->FireOnDragLeave(dragEvent, DRAG_LEAVE_EVENT_TYPE);
268 EXPECT_EQ(dragEventType, DRAG_LEAVE_EVENT_TYPE);
269
270 /**
271 * @tc.steps: step5. Set EventHub OnDragMove event and fire it.
272 * @tc.expected: OnDragMove is invoked and the temp values are assigned with correct values.
273 */
274 auto onDragMove = OnDragFunc;
275 eventHub->SetOnDragMove(onDragMove);
276 eventHub->FireOnDragMove(dragEvent, DRAG_MOVE_EVENT_TYPE);
277 EXPECT_EQ(dragEventType, DRAG_MOVE_EVENT_TYPE);
278
279 /**
280 * @tc.steps: step6. Set EventHub OnDrop event and fire it.
281 * @tc.expected: OnDrop is invoked and the temp values are assigned with correct values.
282 */
283 auto onDragDrop = OnDragFunc;
284 eventHub->SetOnDrop(onDragDrop);
285 eventHub->FireOnDragMove(dragEvent, DRAG_DROP_EVENT_TYPE);
286 EXPECT_TRUE(eventHub->HasOnDrop());
287 EXPECT_EQ(dragEventType, DRAG_DROP_EVENT_TYPE);
288 }
289
290 /**
291 * @tc.name: EventHubCreateTest005
292 * @tc.desc: Create EventHub.
293 * @tc.type: FUNC
294 */
295 HWTEST_F(EventHubTestNg, EventHubDragEventsTest005, TestSize.Level1)
296 {
297 auto eventHub = AceType::MakeRefPtr<EventHub>();
298 ASSERT_NE(eventHub, nullptr);
299 std::vector<KeyboardShortcut> keyboardShortcut;
__anon0b2cc9720702() 300 eventHub->SetKeyboardShortcut(STRINGCTER_A, NUM_CTRL_VALUE, []() {});
301 keyboardShortcut = eventHub->GetKeyboardShortcut();
302 for (auto iter = keyboardShortcut.begin(); iter != keyboardShortcut.end(); iter++) {
303 EXPECT_EQ(STRINGCTER_A, (*iter).value);
304 EXPECT_EQ(NUM_CTRL_VALUE, (*iter).keys);
305 }
306 keyboardShortcut.clear();
307
__anon0b2cc9720802() 308 eventHub->SetKeyboardShortcut(STRINGCTER_Q, NUM_SHIFT_VALUE, []() {});
309 eventHub->GetKeyboardShortcut();
310 for (auto iter = keyboardShortcut.begin(); iter != keyboardShortcut.end(); iter++) {
311 EXPECT_EQ(STRINGCTER_Q, (*iter).value);
312 EXPECT_EQ(NUM_SHIFT_VALUE, (*iter).keys);
313 }
314 keyboardShortcut.clear();
315
__anon0b2cc9720902() 316 eventHub->SetKeyboardShortcut(STRINGCTER_E, NUM_ALT_VALUE, []() {});
317 eventHub->GetKeyboardShortcut();
318 for (auto iter = keyboardShortcut.begin(); iter != keyboardShortcut.end(); iter++) {
319 EXPECT_EQ(STRINGCTER_E, (*iter).value);
320 EXPECT_EQ(NUM_CTRL_VALUE, (*iter).keys);
321 }
322 keyboardShortcut.clear();
323 }
324
325 /**
326 * @tc.name: EventHubDragEventsTest006
327 * @tc.desc: Create EventHub and set/fire drag related customer functions.
328 * @tc.type: FUNC
329 */
330 HWTEST_F(EventHubTestNg, EventHubDragEventsTest006, TestSize.Level1)
331 {
332 /**
333 * @tc.steps: step1. Create EventHub.
334 * @tc.expected: eventHub is not null.
335 */
336 auto eventHub = AceType::MakeRefPtr<EventHub>();
337 EXPECT_NE(eventHub, nullptr);
338
339 /**
340 * @tc.steps: step2. Set EventHub Customer OnDragEnter event and fire it.
341 * @tc.expected: OnDragEnter is invoked and the temp values are assigned with correct values.
342 */
343 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
344 std::string dragEventType;
345 auto OnDragFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon0b2cc9720a02(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 346 const std::string& eventType) { dragEventType = eventType; };
347 auto onDragEnter = OnDragFunc;
348 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_ENTER, onDragEnter);
349 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_ENTER, dragEvent, DRAG_ENTER_EVENT_TYPE);
350 EXPECT_EQ(dragEventType, DRAG_ENTER_EVENT_TYPE);
351
352 /**
353 * @tc.steps: step3. Set EventHub Customer OnDragLeave event and fire it.
354 * @tc.expected: OnDragLeave is invoked and the temp values are assigned with correct values.
355 */
356 auto onDragLeave = OnDragFunc;
357 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_LEAVE, onDragLeave);
358 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_LEAVE, dragEvent, DRAG_LEAVE_EVENT_TYPE);
359 EXPECT_EQ(dragEventType, DRAG_LEAVE_EVENT_TYPE);
360
361 /**
362 * @tc.steps: step4. Set EventHub Customer OnDragMove event and fire it.
363 * @tc.expected: OnDragMove is invoked and the temp values are assigned with correct values.
364 */
365 auto onDragMove = OnDragFunc;
366 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_MOVE, onDragMove);
367 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_MOVE, dragEvent, DRAG_MOVE_EVENT_TYPE);
368 EXPECT_EQ(dragEventType, DRAG_MOVE_EVENT_TYPE);
369
370 /**
371 * @tc.steps: step6. Set EventHub Customer OnDrop event and fire it.
372 * @tc.expected: OnDrop is invoked and the temp values are assigned with correct values.
373 */
374 auto onDragDrop = OnDragFunc;
375 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_DROP, onDragDrop);
376 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_DROP, dragEvent, DRAG_DROP_EVENT_TYPE);
377 EXPECT_TRUE(eventHub->HasCustomerOnDrop());
378 EXPECT_EQ(dragEventType, DRAG_DROP_EVENT_TYPE);
379
380 /**
381 * @tc.steps: step7. Set EventHub Customer OnDragEnd event and fire it.
382 * @tc.expected: OnDragEnd is invoked and the temp values are assigned with correct values.
383 */
__anon0b2cc9720b02(const RefPtr<OHOS::Ace::DragEvent>& ) 384 auto OnDragEnd = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */) {
385 dragEventType = DRAG_END_EVENT_TYPE;
386 };
387 eventHub->SetCustomerOnDragFunc(DragFuncType::DRAG_END, OnDragEnd);
388 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_END, dragEvent);
389 EXPECT_EQ(dragEventType, DRAG_END_EVENT_TYPE);
390 }
391
392 /**
393 * @tc.name: EventHubDisableAreaChange001
394 * @tc.desc: Create EventHub and test disable areaChange function.
395 * @tc.type: FUNC
396 */
397 HWTEST_F(EventHubTestNg, EventHubDisableAreaChange001, TestSize.Level1)
398 {
399 /**
400 * @tc.steps: step1. Create EventHub.
401 * @tc.expected: eventHub is not null.
402 */
403 auto eventHub = AceType::MakeRefPtr<EventHub>();
404 EXPECT_NE(eventHub, nullptr);
405
406 /**
407 * @tc.steps: step2. Set EventHub OnAreaChanged function and fire it.
408 * @tc.expected: onAreaChanged is invoked and the temp values are assigned with correct values.
409 */
410 RectF tempOldRect;
411 OffsetF tempOldOrigin;
412 RectF tempNewRect;
413 OffsetF tempNewOrigin;
414 auto onAreaChanged = [&tempOldRect, &tempOldOrigin, &tempNewRect, &tempNewOrigin](
__anon0b2cc9720c02( const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 415 const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {
416 tempOldRect = oldRect;
417 tempOldOrigin = oldOrigin;
418 tempNewRect = rect;
419 tempNewOrigin = origin;
420 };
421
422 eventHub->SetOnAreaChanged(onAreaChanged);
423 eventHub->FireOnAreaChanged(OLD_RECT, OLD_ORIGIN, NEW_RECT, NEW_ORIGIN);
424 EXPECT_TRUE(eventHub->HasOnAreaChanged());
425 EXPECT_EQ(tempOldRect, OLD_RECT);
426 EXPECT_EQ(tempOldOrigin, OLD_ORIGIN);
427 EXPECT_EQ(tempNewRect, NEW_RECT);
428 EXPECT_EQ(tempNewOrigin, NEW_ORIGIN);
429
430 /**
431 * @tc.steps: step3. Clear the callback.
432 * @tc.expected: onAreaChanged is empty.
433 */
434 eventHub->ClearUserOnAreaChanged();
435 eventHub->FireOnAreaChanged(
436 OLD_RECT + OFFSET_DELTA, OLD_ORIGIN + ORIGIN_DELTA, NEW_RECT + OFFSET_DELTA, NEW_ORIGIN + ORIGIN_DELTA);
437 EXPECT_FALSE(eventHub->HasOnAreaChanged());
438 EXPECT_EQ(tempOldRect, OLD_RECT);
439 EXPECT_EQ(tempOldOrigin, OLD_ORIGIN);
440 EXPECT_EQ(tempNewRect, NEW_RECT);
441 EXPECT_EQ(tempNewOrigin, NEW_ORIGIN);
442
443 /**
444 * @tc.steps: step3. Set/fire areaChange function.
445 * @tc.expected: areaChange is assigned with correct value.
446 */
447 eventHub->SetOnAreaChanged(onAreaChanged);
448 eventHub->FireOnAreaChanged(
449 OLD_RECT + OFFSET_DELTA, OLD_ORIGIN + ORIGIN_DELTA, NEW_RECT + OFFSET_DELTA, NEW_ORIGIN + ORIGIN_DELTA);
450 EXPECT_TRUE(eventHub->HasOnAreaChanged());
451 EXPECT_EQ(tempOldRect, OLD_RECT + OFFSET_DELTA);
452 EXPECT_EQ(tempOldOrigin, OLD_ORIGIN + ORIGIN_DELTA);
453 EXPECT_EQ(tempNewRect, NEW_RECT + OFFSET_DELTA);
454 EXPECT_EQ(tempNewOrigin, NEW_ORIGIN + ORIGIN_DELTA);
455 }
456
457 /**
458 * @tc.name: EventHubDisableAppear001
459 * @tc.desc: Create EventHub and test disable onAppear function.
460 * @tc.type: FUNC
461 */
462 HWTEST_F(EventHubTestNg, EventHubDisableAppear001, TestSize.Level1)
463 {
464 /**
465 * @tc.steps: step1. Create EventHub.
466 * @tc.expected: eventHub is not null.
467 */
468 auto eventHub = AceType::MakeRefPtr<EventHub>();
469 EXPECT_NE(eventHub, nullptr);
470
471 /**
472 * @tc.steps: step2. Set EventHub onAppear function and fire it.
473 * @tc.expected: onAppear is invoked and the temp values are assigned with correct values.
474 */
475 std::string result;
__anon0b2cc9720d02() 476 auto onAppear = [&result]() { result = RESULT_SUCCESS_ONE; };
477
478 eventHub->SetOnAppear(onAppear);
479 EXPECT_NE(eventHub->onAppear_, nullptr);
480 eventHub->onAppear_();
481 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
482 /**
483 * @tc.steps: step3. Clear the callback.
484 * @tc.expected: onAppear is empty.
485 */
486 eventHub->ClearUserOnAppear();
487 EXPECT_EQ(eventHub->onAppear_, nullptr);
488
489 /**
490 * @tc.steps: step3. Set/fire EventHub onAppear function.
491 * @tc.expected: onAppear is assigned with correct value.
492 */
__anon0b2cc9720e02() 493 auto onAppear2 = [&result]() { result = RESULT_SUCCESS_TWO; };
494
495 eventHub->SetOnAppear(onAppear2);
496 EXPECT_NE(eventHub->onAppear_, nullptr);
497 eventHub->onAppear_();
498 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
499 }
500
501 /**
502 * @tc.name: EventHubDisableDisAppear001
503 * @tc.desc: Create EventHub and test disable onDisAppear function.
504 * @tc.type: FUNC
505 */
506 HWTEST_F(EventHubTestNg, EventHubDisableDisAppear001, TestSize.Level1)
507 {
508 /**
509 * @tc.steps: step1. Create EventHub.
510 * @tc.expected: eventHub is not null.
511 */
512 auto eventHub = AceType::MakeRefPtr<EventHub>();
513 EXPECT_NE(eventHub, nullptr);
514
515 /**
516 * @tc.steps: step2. Set EventHub onDisAppear function and fire it.
517 * @tc.expected: onDisAppear is invoked and the temp values are assigned with correct values.
518 */
519 std::string result;
__anon0b2cc9720f02() 520 auto onDisAppear = [&result]() { result = RESULT_SUCCESS_ONE; };
521
522 eventHub->SetOnDisappear(onDisAppear);
523 EXPECT_NE(eventHub->onDisappear_, nullptr);
524 eventHub->onDisappear_();
525 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
526 /**
527 * @tc.steps: step3. Clear the callback.
528 * @tc.expected: onDisAppear is empty.
529 */
530 eventHub->ClearUserOnDisAppear();
531 EXPECT_EQ(eventHub->onDisappear_, nullptr);
532
533 /**
534 * @tc.steps: step3. Set/fire EventHub onDisappear function.
535 * @tc.expected: disAppear is assigned with correct value.
536 */
__anon0b2cc9721002() 537 auto onDisAppear2 = [&result]() { result = RESULT_SUCCESS_TWO; };
538
539 eventHub->SetOnDisappear(onDisAppear2);
540 EXPECT_NE(eventHub->onDisappear_, nullptr);
541 eventHub->onDisappear_();
542 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
543 }
544
545 /**
546 * @tc.name: SetCurrentUIState001
547 * @tc.desc: Create EventHub and test disable onDisAppear function.
548 * @tc.type: FUNC
549 */
550 HWTEST_F(EventHubTestNg, SetCurrentUIState002, TestSize.Level1)
551 {
552 /**
553 * @tc.steps: step1. Create EventHub.
554 * @tc.expected: eventHub is not null.
555 */
556 auto eventHub = AceType::MakeRefPtr<EventHub>();
557 EXPECT_NE(eventHub, nullptr);
558 bool temp = true;
559
560 /**
561 * @tc.steps: Use SetCurrentUIState to set the UIState state
562 * @tc.expected: Use 'GetCurrentUIState' to obtain the already set UIState
563 */
564 eventHub->AddSupportedState(UI_STATE_NORMAL);
565 eventHub->SetSupportedStates(UI_STATE_NORMAL);
566 eventHub->MarkModifyDone();
567
568 eventHub->SetCurrentUIState(UI_STATE_NORMAL, temp);
569 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_NORMAL);
570
571 eventHub->IsCurrentStateOn(UI_STATE_NORMAL);
572 eventHub->CreateGetEventTargetImpl();
573
574 eventHub->SetCurrentUIState(UI_STATE_PRESSED, temp);
575 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_PRESSED);
576
577 eventHub->SetCurrentUIState(UI_STATE_FOCUSED, temp);
578 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_NORMAL | UI_STATE_PRESSED | UI_STATE_FOCUSED);
579 eventHub->MarkModifyDone();
580
581 eventHub->SetCurrentUIState(UI_STATE_DISABLED, temp);
582 EXPECT_EQ(eventHub->GetCurrentUIState(), UI_STATE_NORMAL | UI_STATE_PRESSED | UI_STATE_FOCUSED | UI_STATE_DISABLED);
583
584 eventHub->SetCurrentUIState(UI_STATE_SELECTED, temp);
585 EXPECT_EQ(eventHub->GetCurrentUIState(),
586 UI_STATE_SELECTED | UI_STATE_NORMAL | UI_STATE_PRESSED | UI_STATE_FOCUSED | UI_STATE_DISABLED);
587 }
588
589 /**
590 * @tc.name: EventHubTest001
591 * @tc.desc: Default branch in test FireCustomerOnDragFunc
592 * @tc.type: FUNC
593 */
594 HWTEST_F(EventHubTestNg, EventHubTest001, TestSize.Level1)
595 {
596 /**
597 * @tc.steps: step1. Create EventHub.
598 * @tc.expected: eventHub is not null.
599 */
600 auto eventHub = AceType::MakeRefPtr<EventHub>();
601 EXPECT_NE(eventHub, nullptr);
602
603 /**
604 * @tc.steps: step2. Create DragEvent.
605 * @tc.expected: DragEvent is not null.
606 */
607 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
608 EXPECT_NE(dragEvent, nullptr);
609
610 /**
611 * @tc.steps: step3. Calling DRAG in FirecustomerOnDragFunc_ CustomerOnDragEnd in END_ Empty branch.
612 * @tc.expected: retFlag is false.
613 */
614 eventHub->FireCustomerOnDragFunc(DragFuncType::DRAG_END, dragEvent, DRAG_DROP_EVENT_TYPE);
615 auto retFlag = eventHub->HasCustomerOnDrop();
616 EXPECT_FALSE(retFlag);
617
618 /**
619 * @tc.steps: step4. Calling the default branch in FirecustomerOnDragFunc.
620 * @tc.expected: retFlag is false.
621 */
622 eventHub->FireCustomerOnDragFunc(DragFuncType(10), dragEvent, DRAG_DROP_EVENT_TYPE);
623 retFlag = eventHub->HasCustomerOnDrop();
624 EXPECT_FALSE(retFlag);
625 }
626
627 /**
628 * @tc.name: EventHubTest002
629 * @tc.desc: Default Branch in Test SetCustomerOnDragFunc(OnDragFunc)
630 * @tc.type: FUNC
631 */
632 HWTEST_F(EventHubTestNg, EventHubTest002, TestSize.Level1)
633 {
634 /**
635 * @tc.steps: step1. Create EventHub.
636 * @tc.expected: eventHub is not null.
637 */
638 auto eventHub = AceType::MakeRefPtr<EventHub>();
639 EXPECT_NE(eventHub, nullptr);
640
641 /**
642 * @tc.steps: step2. Create DragEvent.
643 * @tc.expected: DragEvent is not null.
644 */
645 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
646 EXPECT_NE(dragEvent, nullptr);
647
648 /**
649 * @tc.steps: step3. construct OnDragFunc.
650 */
651 std::string dragEventType;
652 auto onDragFunc = [&dragEventType](const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */,
__anon0b2cc9721102(const RefPtr<OHOS::Ace::DragEvent>& , const std::string& eventType) 653 const std::string& eventType) { dragEventType = eventType; };
654
655 /**
656 * @tc.steps: step4. Calling the default branch in SetCustomerOnDragFunc.
657 * @tc.expected: eventHub->customerOnDragEnd_ is false.
658 */
659 eventHub->SetCustomerOnDragFunc(DragFuncType(10), onDragFunc);
660 EXPECT_FALSE(eventHub->customerOnDragEnd_);
661 }
662
663 /**
664 * @tc.name: EventHubTest003
665 * @tc.desc: Default Branch in Test SetCustomerOnDragFunc(OnNewDragFunc)
666 * @tc.type: FUNC
667 */
668 HWTEST_F(EventHubTestNg, EventHubTest003, TestSize.Level1)
669 {
670 /**
671 * @tc.steps: step1. Create EventHub.
672 * @tc.expected: eventHub is not null.
673 */
674 auto eventHub = AceType::MakeRefPtr<EventHub>();
675 EXPECT_NE(eventHub, nullptr);
676
677 /**
678 * @tc.steps: step2. Create DragEvent.
679 * @tc.expected: DragEvent is not null.
680 */
681 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
682 EXPECT_NE(dragEvent, nullptr);
683
684 /**
685 * @tc.steps: step3. construct OnDragFunc.
686 */
687 std::string dragEventType;
688 auto onDragFunc = [&dragEventType](
__anon0b2cc9721202( const RefPtr<OHOS::Ace::DragEvent>& ) 689 const RefPtr<OHOS::Ace::DragEvent>& /* dragEvent */) { dragEventType = DRAG_END_EVENT_TYPE; };
690
691 /**
692 * @tc.steps: step4. Call SetCustomerOnDragFunc with OnDragFunc.
693 * @tc.expected: eventHub->customerOnDragEnter_ is false.
694 */
695 eventHub->SetCustomerOnDragFunc(DragFuncType(10), onDragFunc);
696 EXPECT_FALSE(eventHub->customerOnDragEnter_);
697 }
698
699 /**
700 * @tc.name: EventHubTest004
701 * @tc.desc: Test MarkModifyDone
702 * @tc.type: FUNC
703 */
704 HWTEST_F(EventHubTestNg, EventHubTest004, TestSize.Level1)
705 {
706 /**
707 * @tc.steps: step1. Create EventHub.
708 * @tc.expected: eventHub is not null.
709 */
710 auto eventHub = AceType::MakeRefPtr<EventHub>();
711 EXPECT_NE(eventHub, nullptr);
712
713 /**
714 * @tc.steps: step2. Update SupportedState in eventHub using UI_STATE_PRESSED.
715 */
716 eventHub->AddSupportedState(UI_STATE_PRESSED);
717 eventHub->SetSupportedStates(UI_STATE_PRESSED);
718
719 /**
720 * @tc.steps: step3. Call MarkModifyDone, stateStyleMgr_->HasStateStyle(UI_STATE_PRESSED) is a true branch.
721 * @tc.expected: retFlag is true.
722 */
723 eventHub->MarkModifyDone();
724 bool retFlag = eventHub->stateStyleMgr_->HasStateStyle(UI_STATE_PRESSED);
725 EXPECT_TRUE(retFlag);
726
727 /**
728 * @tc.steps: step4. Update SupportedState in eventHub using UI_STATE_DISABLED.
729 */
730 eventHub->AddSupportedState(UI_STATE_DISABLED);
731 eventHub->SetSupportedStates(UI_STATE_DISABLED);
732
733 /**
734 * @tc.steps: step5. Call MarkModifyDone, stateStyleMgr_->HasStateStyle(UI_STATE_DISABLED) is a true branch.
735 * @tc.expected: retFlag is true.
736 */
737 eventHub->MarkModifyDone();
738 retFlag = eventHub->stateStyleMgr_->HasStateStyle(UI_STATE_DISABLED);
739 EXPECT_TRUE(retFlag);
740
741 /**
742 * @tc.steps: step6. Update SupportedState in eventHub using UI_STATE_DISABLED.
743 */
744 eventHub->AddSupportedState(UI_STATE_DISABLED);
745 eventHub->SetSupportedStates(UI_STATE_DISABLED);
746 eventHub->SetEnabled(false);
747
748 /**
749 * @tc.steps: step7. Call MarkModifyDone, enabled_ is a false branch.
750 * @tc.expected: eventHub->IsEnabled() return value is false.
751 */
752 eventHub->MarkModifyDone();
753 EXPECT_FALSE(eventHub->IsEnabled());
754 }
755
756 /**
757 * @tc.name: EventHubTest005
758 * @tc.desc: stateStyleMgr_ in Test SetSupportedStates is a fake branch
759 * @tc.type: FUNC
760 */
761 HWTEST_F(EventHubTestNg, EventHubTest005, TestSize.Level1)
762 {
763 /**
764 * @tc.steps: step1. Create EventHub.
765 * @tc.expected: eventHub is not null.
766 */
767 auto eventHub = AceType::MakeRefPtr<EventHub>();
768 EXPECT_NE(eventHub, nullptr);
769
770 /**
771 * @tc.steps: step2. Call SetSupportedStates with UI_STATE_PRESSED.
772 * @tc.expected: eventHub->stateStyleMgr_ is true.
773 */
774 eventHub->stateStyleMgr_ = nullptr;
775 eventHub->SetSupportedStates(UI_STATE_PRESSED);
776 EXPECT_TRUE(eventHub->stateStyleMgr_);
777 }
778
779 /**
780 * @tc.name: EventHubFrameNodeTest001
781 * @tc.desc: test ClearJSFrameNodeOnDisappear
782 * @tc.type: FUNC
783 */
784 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest001, TestSize.Level1)
785 {
786 /**
787 * @tc.steps: step1. Create EventHub.
788 * @tc.expected: eventHub is not null.
789 */
790 auto eventHub = AceType::MakeRefPtr<EventHub>();
791 EXPECT_NE(eventHub, nullptr);
792
793 /**
794 * @tc.steps: step2. Call ClearJSFrameNodeOnDisappear with onJSFrameNodeDisappear_ is nullptr.
795 * @tc.expected: eventHub->onJSFrameNodeDisappear_ is nullptr.
796 */
797 eventHub->onJSFrameNodeDisappear_ = nullptr;
798 eventHub->ClearJSFrameNodeOnDisappear();
799 EXPECT_EQ(eventHub->onJSFrameNodeDisappear_, nullptr);
800
801 /**
802 * @tc.steps: step3. Call ClearJSFrameNodeOnDisappear with onJSFrameNodeDisappear_ is not nullptr.
803 * @tc.expected: flag is equal 1.
804 */
__anon0b2cc9721302() 805 std::function<void()> flagFunc = []() { ++flag; };
806 eventHub->SetJSFrameNodeOnDisappear(std::move(flagFunc));
807 EXPECT_NE(eventHub->onJSFrameNodeDisappear_, nullptr);
808 eventHub->ClearJSFrameNodeOnDisappear();
809 EXPECT_EQ(eventHub->onJSFrameNodeDisappear_, nullptr);
810 }
811
812 /**
813 * @tc.name: EventHubFrameNodeTest002
814 * @tc.desc: test ClearJSFrameNodeOnAppear
815 * @tc.type: FUNC
816 */
817 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest002, TestSize.Level1)
818 {
819 /**
820 * @tc.steps: step1. Create EventHub.
821 * @tc.expected: eventHub is not null.
822 */
823 auto eventHub = AceType::MakeRefPtr<EventHub>();
824 EXPECT_NE(eventHub, nullptr);
825
826 /**
827 * @tc.steps: step2. Call ClearJSFrameNodeOnAppear with onJSFrameNodeAppear_ is nullptr.
828 * @tc.expected: eventHub->onJSFrameNodeAppear_ is nullptr.
829 */
830 eventHub->onJSFrameNodeAppear_ = nullptr;
831 eventHub->ClearJSFrameNodeOnAppear();
832 EXPECT_EQ(eventHub->onJSFrameNodeAppear_, nullptr);
833
834 /**
835 * @tc.steps: step3. Call ClearJSFrameNodeOnAppear with onJSFrameNodeDisappear_ is not nullptr.
836 * @tc.expected:onJSFrameNodeAppear_ is nullptr.
837 */
__anon0b2cc9721402() 838 std::function<void()> flagFunc = []() { ++flag; };
839 eventHub->SetJSFrameNodeOnAppear(std::move(flagFunc));
840 EXPECT_NE(eventHub->onJSFrameNodeAppear_, nullptr);
841 eventHub->ClearJSFrameNodeOnAppear();
842 EXPECT_EQ(eventHub->onJSFrameNodeAppear_, nullptr);
843 }
844
845 /**
846 * @tc.name: EventHubFrameNodeTest003
847 * @tc.desc: test FireOnAppear
848 * @tc.type: FUNC
849 */
850 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest003, TestSize.Level1)
851 {
852 /**
853 * @tc.steps: step1. Create EventHub.
854 * @tc.expected: eventHub is not null.
855 */
856 auto eventHub = AceType::MakeRefPtr<EventHub>();
857 EXPECT_NE(eventHub, nullptr);
858
859 /**
860 * @tc.steps: step2. Call FireOnAppear with onAppear_ and onJSFrameNodeAppear_ are both nullptr.
861 * @tc.expected: flag is equal 0.
862 */
863 eventHub->onAppear_ = nullptr;
864 eventHub->onJSFrameNodeAppear_ = nullptr;
865 eventHub->FireOnAppear();
866 EXPECT_EQ(flag, 0);
867
868 /**
869 * @tc.steps: step3. Call FireOnAppear with onAppear_ is nullptr and onJSFrameNodeAppear_ are is not nullptr.
870 * @tc.expected: onJSFrameNodeAppear_ is not nullptr.
871 */
__anon0b2cc9721502() 872 std::function<void()> flagFunc = []() { ++flag; };
873 eventHub->SetJSFrameNodeOnAppear(std::move(flagFunc));
874 eventHub->FireOnAppear();
875 EXPECT_NE(eventHub->onJSFrameNodeAppear_, nullptr);
876 }
877
878 /**
879 * @tc.name: EventHubFrameNodeTest004
880 * @tc.desc: test FireOnDisappear
881 * @tc.type: FUNC
882 */
883 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest004, TestSize.Level1)
884 {
885 /**
886 * @tc.steps: step1. Create EventHub.
887 * @tc.expected: eventHub is not null.
888 */
889 auto eventHub = AceType::MakeRefPtr<EventHub>();
890 EXPECT_NE(eventHub, nullptr);
891
892 /**
893 * @tc.steps: step2. Call FireOnDisappear with onAppear_ and onJSFrameNodeAppear_ are both nullptr.
894 * @tc.expected: flag is equal 0.
895 */
896 eventHub->onDisappear_ = nullptr;
897 eventHub->onJSFrameNodeDisappear_ = nullptr;
898 eventHub->FireOnDisappear();
899 EXPECT_EQ(flag, 0);
900
901 /**
902 * @tc.steps: step3. Call FireOnDisappear with onAppear_ is and onJSFrameNodeAppear_ are both not nullptr.
903 * @tc.expected: flag is equal 2.
904 */
__anon0b2cc9721602() 905 std::function<void()> flagFunc = []() { flag++; };
906 eventHub->onDisappear_ = flagFunc;
907 eventHub->onJSFrameNodeDisappear_ = flagFunc;
908 eventHub->FireOnDisappear();
909 EXPECT_EQ(flag, 2);
910 }
911
912 /**
913 * @tc.name: EventHubFrameNodeTest005
914 * @tc.desc: test set event about visibleAreaChange
915 * @tc.type: FUNC
916 */
917 HWTEST_F(EventHubTestNg, EventHubFrameNodeTest005, TestSize.Level1)
918 {
919 /**
920 * @tc.steps: step1. Create EventHub.
921 * @tc.expected: eventHub is not null.
922 */
923 auto eventHub = AceType::MakeRefPtr<EventHub>();
924 EXPECT_NE(eventHub, nullptr);
925
926 /**
927 * @tc.steps: step2. set throttledVisibleAreaRatios_, throttledVisibleAreaCallback_.
928 * @tc.expected: HasImmediatelyVisibleCallback is equal to false.
929 */
930 VisibleCallbackInfo callbackInfo;
__anon0b2cc9721702(bool isVisible, double radio) 931 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
932 callbackInfo.callback = jsCallback;
933 callbackInfo.period = MIN_INTERVAL;
934 std::vector<double> ratios = { 0, 1.0 };
935 flag = 0;
936 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
937 EXPECT_EQ(flag, 0);
938 EXPECT_NE(eventHub->HasImmediatelyVisibleCallback(), true);
939 EXPECT_EQ(eventHub->GetThrottledVisibleAreaRatios(), ratios);
940 EXPECT_NE(eventHub->GetThrottledVisibleAreaCallback().callback, nullptr);
941
942 /**
943 * @tc.steps: step3. clear throttledVisibleAreaRatios_, throttledVisibleAreaCallback_.
944 * @tc.expected:throttledVisibleAreaRatios_ is empty, callback in throttledVisibleAreaCallback_ is nullptr.
945 */
946 eventHub->CleanVisibleAreaCallback(true, true);
947 EXPECT_EQ(eventHub->GetThrottledVisibleAreaRatios().empty(), true);
948 EXPECT_EQ(eventHub->GetThrottledVisibleAreaCallback().callback, nullptr);
949
950 /**
951 * @tc.steps: step4. set visibleAreaUserCallback_.
952 * @tc.expected: HasImmediatelyVisibleCallback is equal to true.
953 */
954 callbackInfo.period = 0;
955 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
956 EXPECT_EQ(flag, 0);
957 EXPECT_EQ(eventHub->HasImmediatelyVisibleCallback(), true);
958 }
959
960 /**
961 * @tc.name: EventHubTest006
962 * @tc.desc: OnAttachContext
963 * @tc.type: FUNC
964 */
965 HWTEST_F(EventHubTestNg, EventHubTest006, TestSize.Level1)
966 {
967 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
968 auto eventHub = frameNode->GetEventHub<EventHub>();
969 auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
970 RectF tempOldRect;
971 OffsetF tempOldOrigin;
972 RectF tempNewRect;
973 OffsetF tempNewOrigin;
974 auto onAreaChanged = [&tempOldRect, &tempOldOrigin, &tempNewRect, &tempNewOrigin](
__anon0b2cc9721802( const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 975 const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {
976 tempOldRect = oldRect;
977 tempOldOrigin = oldOrigin;
978 tempNewRect = rect;
979 tempNewOrigin = origin;
980 };
981
982 eventHub->SetOnAreaChanged(onAreaChanged);
983 eventHub->GetOrCreateGestureEventHub();
984 eventHub->GetOrCreateInputEventHub();
985 eventHub->GetOrCreateFocusHub();
986
987 VisibleCallbackInfo callbackInfo;
__anon0b2cc9721902(bool isVisible, double radio) 988 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
989 callbackInfo.callback = jsCallback;
990 callbackInfo.period = MIN_INTERVAL;
991 callbackInfo.period = 0;
992 std::vector<double> ratios = { 0, 1.0 };
993 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
994
995 auto context = MockPipelineContext::GetCurrent();
996 eventHub->OnAttachContext(AceType::RawPtr(context));
997 EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
998 }
999
1000 /**
1001 * @tc.name: EventHubTest007
1002 * @tc.desc: OnAttachContext
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(EventHubTestNg, EventHubTest007, TestSize.Level1)
1006 {
1007 auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1008 auto eventHub = frameNode->GetEventHub<EventHub>();
1009
1010 eventHub->GetOrCreateGestureEventHub();
1011 eventHub->GetOrCreateInputEventHub();
1012 eventHub->GetOrCreateFocusHub();
1013 bool flags = false;
1014 OnAreaChangedFunc onAreaChanged = [&flags](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect,
__anon0b2cc9721a02(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1015 const OffsetF& origin) { flags = !flags; };
1016 eventHub->AddInnerOnAreaChangedCallback(1, std::move(onAreaChanged));
1017 VisibleCallbackInfo callbackInfo;
__anon0b2cc9721b02(bool isVisible, double radio) 1018 const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
1019 callbackInfo.callback = jsCallback;
1020 callbackInfo.period = MIN_INTERVAL;
1021 std::vector<double> ratios = { 0, 1.0 };
1022 eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, false);
1023
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->GetEventHub<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](
__anon0b2cc9721c02( 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;
__anon0b2cc9721d02(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->GetEventHub<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,
__anon0b2cc9721e02(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;
__anon0b2cc9721f02(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;
__anon0b2cc9722002(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;
__anon0b2cc9722102(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;
__anon0b2cc9722202(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;
__anon0b2cc9722302(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>();
__anon0b2cc9722402() 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>();
__anon0b2cc9722502() 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();
__anon0b2cc9722602(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();
__anon0b2cc9722702(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();
__anon0b2cc9722802(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();
__anon0b2cc9722902(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 } // namespace OHOS::Ace::NG
1330