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 eventHub = AceType::MakeRefPtr<EventHub>();
115     eventHub->MarkModifyDone();
116     EXPECT_NE(eventHub, nullptr);
117 
118     /**
119      * @tc.steps: step2. Get EventHub's properties.
120      * @tc.expected: These properties are null when GetOrCreateEventHub functions have not been invoked.
121      */
122     EXPECT_EQ(eventHub->GetGestureEventHub(), nullptr);
123     EXPECT_EQ(eventHub->GetInputEventHub(), nullptr);
124     EXPECT_EQ(eventHub->GetFocusHub(), nullptr);
125     EXPECT_EQ(eventHub->GetFrameNode(), nullptr);
126     EXPECT_EQ(eventHub->GetOnDragStart(), nullptr);
127 
128     /**
129      * @tc.steps: step3. Test EventHub's default properties.
130      */
131     EXPECT_TRUE(!eventHub->HasOnAreaChanged());
132     EXPECT_TRUE(!eventHub->HasOnDragStart());
133     EXPECT_TRUE(!eventHub->HasOnDrop());
134     EXPECT_TRUE(eventHub->IsEnabled());
135 }
136 
137 /**
138  * @tc.name: EventHubPropertyTest002
139  * @tc.desc: Create EventHub and invoke GetOrCreateEventHub functions.
140  * @tc.type: FUNC
141  */
142 HWTEST_F(EventHubTestNg, EventHubPropertyTest002, TestSize.Level1)
143 {
144     /**
145      * @tc.steps: step1. Create EventHub.
146      * @tc.expected: eventHub is not null.
147      */
148     auto eventHub = AceType::MakeRefPtr<EventHub>();
149     EXPECT_NE(eventHub, nullptr);
150 
151     /**
152      * @tc.steps: step2. Invoke GetOrCreateEventHub functions.
153      * @tc.expected: These eventHub properties are not null.
154      */
155     eventHub->GetOrCreateGestureEventHub();
156     eventHub->GetOrCreateInputEventHub();
157     eventHub->GetOrCreateFocusHub();
158     EXPECT_NE(eventHub->GetGestureEventHub(), nullptr);
159     EXPECT_NE(eventHub->GetInputEventHub(), nullptr);
160     EXPECT_NE(eventHub->GetFocusHub(), nullptr);
161 
162     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
163     eventHub->AttachHost(frameNode);
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](
__anon77f4936a0202( 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      */
__anon77f4936a0302() 212     eventHub->SetOnAppear([]() {});
213     eventHub->FireOnAppear();
214 
__anon77f4936a0402() 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 */,
__anon77f4936a0502(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 */,
__anon77f4936a0602(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;
__anon77f4936a0702() 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 
__anon77f4936a0802() 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 
__anon77f4936a0902() 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 */,
__anon77f4936a0a02(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      */
__anon77f4936a0b02(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](
__anon77f4936a0c02( 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;
__anon77f4936a0d02() 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      */
__anon77f4936a0e02() 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;
__anon77f4936a0f02() 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      */
__anon77f4936a1002() 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 */,
__anon77f4936a1102(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](
__anon77f4936a1202( 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      */
__anon77f4936a1302() 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      */
__anon77f4936a1402() 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      */
__anon77f4936a1502() 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      */
__anon77f4936a1602() 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;
__anon77f4936a1702(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 eventHub = AceType::MakeRefPtr<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](
__anon77f4936a1802( 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;
__anon77f4936a1902(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     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
994     eventHub->AttachHost(frameNode);
995 
996     auto context = MockPipelineContext::GetCurrent();
997     eventHub->OnAttachContext(AceType::RawPtr(context));
998     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
999 }
1000 
1001 /**
1002  * @tc.name: EventHubTest007
1003  * @tc.desc: OnAttachContext
1004  * @tc.type: FUNC
1005  */
1006 HWTEST_F(EventHubTestNg, EventHubTest007, TestSize.Level1)
1007 {
1008     auto eventHub = AceType::MakeRefPtr<EventHub>();
1009 
1010     eventHub->GetOrCreateGestureEventHub();
1011     eventHub->GetOrCreateInputEventHub();
1012     eventHub->GetOrCreateFocusHub();
1013     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1014     eventHub->AttachHost(frameNode);
1015     bool flags = false;
1016     OnAreaChangedFunc onAreaChanged = [&flags](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect,
__anon77f4936a1a02(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1017                                           const OffsetF& origin) { flags = !flags; };
1018     eventHub->AddInnerOnAreaChangedCallback(1, std::move(onAreaChanged));
1019     VisibleCallbackInfo callbackInfo;
__anon77f4936a1b02(bool isVisible, double radio) 1020     const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
1021     callbackInfo.callback = jsCallback;
1022     callbackInfo.period = MIN_INTERVAL;
1023     std::vector<double> ratios = { 0, 1.0 };
1024     eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, false);
1025 
1026     auto context = MockPipelineContext::GetCurrent();
1027     eventHub->OnAttachContext(AceType::RawPtr(context));
1028     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1029 }
1030 
1031 /**
1032  * @tc.name: EventHubTest008
1033  * @tc.desc: OnDetachContext
1034  * @tc.type: FUNC
1035  */
1036 HWTEST_F(EventHubTestNg, EventHubTest008, TestSize.Level1)
1037 {
1038     auto eventHub = AceType::MakeRefPtr<EventHub>();
1039     auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
1040     RectF tempOldRect;
1041     OffsetF tempOldOrigin;
1042     RectF tempNewRect;
1043     OffsetF tempNewOrigin;
1044     auto onAreaChanged = [&tempOldRect, &tempOldOrigin, &tempNewRect, &tempNewOrigin](
__anon77f4936a1c02( const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1045                              const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) {
1046         tempOldRect = oldRect;
1047         tempOldOrigin = oldOrigin;
1048         tempNewRect = rect;
1049         tempNewOrigin = origin;
1050     };
1051 
1052     eventHub->SetOnAreaChanged(onAreaChanged);
1053     eventHub->GetOrCreateGestureEventHub();
1054     eventHub->GetOrCreateInputEventHub();
1055     eventHub->GetOrCreateFocusHub();
1056 
1057     VisibleCallbackInfo callbackInfo;
__anon77f4936a1d02(bool isVisible, double radio) 1058     const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
1059     callbackInfo.callback = jsCallback;
1060     callbackInfo.period = MIN_INTERVAL;
1061     callbackInfo.period = 0;
1062     std::vector<double> ratios = { 0, 1.0 };
1063     eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, true);
1064     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1065     eventHub->AttachHost(frameNode);
1066 
1067     auto context = MockPipelineContext::GetCurrent();
1068     eventHub->OnDetachContext(AceType::RawPtr(context));
1069     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1070 }
1071 
1072 /**
1073  * @tc.name: EventHubTest009
1074  * @tc.desc: OnDetachContext
1075  * @tc.type: FUNC
1076  */
1077 HWTEST_F(EventHubTestNg, EventHubTest009, TestSize.Level1)
1078 {
1079     auto eventHub = AceType::MakeRefPtr<EventHub>();
1080     eventHub->GetOrCreateGestureEventHub();
1081     eventHub->GetOrCreateInputEventHub();
1082     eventHub->GetOrCreateFocusHub();
1083     auto frameNode = AceType::MakeRefPtr<FrameNode>(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1084     eventHub->AttachHost(frameNode);
1085     bool flags = false;
1086     OnAreaChangedFunc onAreaChanged = [&flags](const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect,
__anon77f4936a1e02(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin) 1087                                           const OffsetF& origin) { flags = !flags; };
1088     eventHub->AddInnerOnAreaChangedCallback(1, std::move(onAreaChanged));
1089     VisibleCallbackInfo callbackInfo;
__anon77f4936a1f02(bool isVisible, double radio) 1090     const std::function<void(bool, double)>&& jsCallback = [](bool isVisible, double radio) { flag++; };
1091     callbackInfo.callback = jsCallback;
1092     callbackInfo.period = MIN_INTERVAL;
1093     std::vector<double> ratios = { 0, 1.0 };
1094     eventHub->SetVisibleAreaRatiosAndCallback(callbackInfo, ratios, false);
1095     auto context = MockPipelineContext::GetCurrent();
1096     eventHub->OnDetachContext(AceType::RawPtr(context));
1097     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1098 }
1099 
1100 /**
1101  * @tc.name: EventHubTest010
1102  * @tc.desc: FireOnSizeChanged
1103  * @tc.type: FUNC
1104  */
1105 HWTEST_F(EventHubTestNg, EventHubTest010, TestSize.Level1)
1106 {
1107     auto eventHub = AceType::MakeRefPtr<EventHub>();
1108     bool flags = false;
__anon77f4936a2002(const RectF& oldRect, const RectF& Rect) 1109     OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1110     RectF tempOldRect;
1111     RectF tempNewRect;
1112     eventHub->SetOnSizeChanged(std::move(onSizeChanged));
1113     eventHub->FireOnSizeChanged(tempOldRect, tempNewRect);
1114     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1115 }
1116 
1117 /**
1118  * @tc.name: EventHubTest011
1119  * @tc.desc: FireOnSizeChanged
1120  * @tc.type: FUNC
1121  */
1122 HWTEST_F(EventHubTestNg, EventHubTest011, TestSize.Level1)
1123 {
1124     auto eventHub = AceType::MakeRefPtr<EventHub>();
1125     RectF tempOldRect;
1126     RectF tempNewRect;
1127     eventHub->FireOnSizeChanged(tempOldRect, tempNewRect);
1128     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1129 }
1130 
1131 /**
1132  * @tc.name: EventHubTest012
1133  * @tc.desc: FireJSFrameNodeOnSizeChanged
1134  * @tc.type: FUNC
1135  */
1136 HWTEST_F(EventHubTestNg, EventHubTest012, TestSize.Level1)
1137 {
1138     auto eventHub = AceType::MakeRefPtr<EventHub>();
1139     bool flags = false;
__anon77f4936a2102(const RectF& oldRect, const RectF& Rect) 1140     OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1141     RectF tempOldRect;
1142     RectF tempNewRect;
1143     eventHub->SetJSFrameNodeOnSizeChangeCallback(std::move(onSizeChanged));
1144     eventHub->FireJSFrameNodeOnSizeChanged(tempOldRect, tempNewRect);
1145     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1146 }
1147 
1148 /**
1149  * @tc.name: EventHubTest013
1150  * @tc.desc: FireJSFrameNodeOnSizeChanged
1151  * @tc.type: FUNC
1152  */
1153 HWTEST_F(EventHubTestNg, EventHubTest013, TestSize.Level1)
1154 {
1155     auto eventHub = AceType::MakeRefPtr<EventHub>();
1156     RectF tempOldRect;
1157     RectF tempNewRect;
1158     eventHub->FireJSFrameNodeOnSizeChanged(tempOldRect, tempNewRect);
1159     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1160 }
1161 
1162 /**
1163  * @tc.name: EventHubTest014
1164  * @tc.desc:ClearJSFrameNodeOnSizeChange
1165  * @tc.type: FUNC
1166  */
1167 HWTEST_F(EventHubTestNg, EventHubTest014, TestSize.Level1)
1168 {
1169     auto eventHub = AceType::MakeRefPtr<EventHub>();
1170     eventHub->ClearJSFrameNodeOnSizeChange();
1171     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1172 }
1173 
1174 /**
1175  * @tc.name: EventHubTest015
1176  * @tc.desc: ClearJSFrameNodeOnSizeChange
1177  * @tc.type: FUNC
1178  */
1179 HWTEST_F(EventHubTestNg, EventHubTest015, TestSize.Level1)
1180 {
1181     auto eventHub = AceType::MakeRefPtr<EventHub>();
1182     bool flags = false;
__anon77f4936a2202(const RectF& oldRect, const RectF& Rect) 1183     OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1184     eventHub->SetJSFrameNodeOnSizeChangeCallback(std::move(onSizeChanged));
1185     eventHub->ClearJSFrameNodeOnSizeChange();
1186     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1187 }
1188 
1189 /**
1190  * @tc.name: EventHubTest016
1191  * @tc.desc: FireInnerOnSizeChanged
1192  * @tc.type: FUNC
1193  */
1194 HWTEST_F(EventHubTestNg, EventHubTest016, TestSize.Level1)
1195 {
1196     auto eventHub = AceType::MakeRefPtr<EventHub>();
1197     bool flags = false;
__anon77f4936a2302(const RectF& oldRect, const RectF& Rect) 1198     OnSizeChangedFunc onSizeChanged = [&flags](const RectF& oldRect, const RectF& Rect) { flags = !flags; };
1199     eventHub->AddInnerOnSizeChanged(1, std::move(onSizeChanged));
1200     eventHub->AddInnerOnSizeChanged(2, std::move(onSizeChanged));
1201     RectF tempOldRect;
1202     RectF tempNewRect;
1203     eventHub->FireInnerOnSizeChanged(tempOldRect, tempNewRect);
1204     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1205 }
1206 
1207 /**
1208  * @tc.name: EventHubTest017
1209  * @tc.desc: FireInnerOnSizeChanged
1210  * @tc.type: FUNC
1211  */
1212 HWTEST_F(EventHubTestNg, EventHubTest017, TestSize.Level1)
1213 {
1214     auto eventHub = AceType::MakeRefPtr<EventHub>();
1215     RectF tempOldRect;
1216     RectF tempNewRect;
1217     eventHub->FireInnerOnSizeChanged(tempOldRect, tempNewRect);
1218     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1219 }
1220 
1221 /**
1222  * @tc.name: EventHubTest018
1223  * @tc.desc: FireOnAttach
1224  * @tc.type: FUNC
1225  */
1226 HWTEST_F(EventHubTestNg, EventHubTest018, TestSize.Level1)
1227 {
1228     auto eventHub = AceType::MakeRefPtr<EventHub>();
__anon77f4936a2402() 1229     std::function<void()> onAttachCallback = []() {};
1230     eventHub->SetOnAttach(std::move(onAttachCallback));
1231     eventHub->FireOnAttach();
1232     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1233 }
1234 
1235 /**
1236  * @tc.name: EventHubTest019
1237  * @tc.desc: FireOnAttach
1238  * @tc.type: FUNC
1239  */
1240 HWTEST_F(EventHubTestNg, EventHubTest019, TestSize.Level1)
1241 {
1242     auto eventHub = AceType::MakeRefPtr<EventHub>();
__anon77f4936a2502() 1243     std::function<void()> onAttachCallback = []() {};
1244     eventHub->SetOnDetach(std::move(onAttachCallback));
1245     eventHub->FireOnDetach();
1246     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1247 }
1248 
1249 /**
1250  * @tc.name: EventHubTest020
1251  * @tc.desc: debugEnabled_
1252  * @tc.type: FUNC
1253  */
1254 HWTEST_F(EventHubTestNg, EventHubTest020, TestSize.Level1)
1255 {
1256     auto eventHub = AceType::MakeRefPtr<EventHub>();
1257     SystemProperties::debugEnabled_ = true;
1258     auto dragEvent = AceType::MakeRefPtr<OHOS::Ace::DragEvent>();
1259     eventHub->FireOnDragEnter(dragEvent, DRAG_ENTER_EVENT_TYPE);
1260     eventHub->FireOnDragLeave(dragEvent, DRAG_ENTER_EVENT_TYPE);
1261     eventHub->FireOnDragMove(dragEvent, DRAG_ENTER_EVENT_TYPE);
1262     eventHub->FireOnDrop(dragEvent, DRAG_ENTER_EVENT_TYPE);
1263     EXPECT_NE(eventHub->GetOrCreateGestureEventHub(), nullptr);
1264 }
1265 } // namespace OHOS::Ace::NG
1266