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 #include "test/unittest/core/event/focus_hub_test_ng.h"
16 
17 using namespace testing;
18 using namespace testing::ext;
19 
20 namespace OHOS::Ace::NG {
SetUpTestSuite()21 void FocusHubTestNg::SetUpTestSuite()
22 {
23     MockPipelineContext::SetUp();
24     GTEST_LOG_(INFO) << "FocusHubTestNg SetUpTestCase";
25 }
26 
TearDownTestSuite()27 void FocusHubTestNg::TearDownTestSuite()
28 {
29     MockPipelineContext::TearDown();
30     GTEST_LOG_(INFO) << "FocusHubTestNg TearDownTestCase";
31 }
32 
SetUp()33 void FocusHubTestNg::SetUp() {}
34 
TearDown()35 void FocusHubTestNg::TearDown() {}
36 
37 /**
38  * @tc.name: FocusHubCreateTest001
39  * @tc.desc: Create FocusHub.
40  * @tc.type: FUNC
41  */
42 HWTEST_F(FocusHubTestNg, FocusHubCreateTest001, TestSize.Level1)
43 {
44     /**
45      * @tc.steps: step1. Create FocusHub with passing is null as parameter.
46      * @tc.expected: eventHub_ cannot be updated.
47      */
48     auto focusHub1 = AceType::MakeRefPtr<FocusHub>(nullptr);
49     EXPECT_TRUE(focusHub1->GetFrameNode() == nullptr);
50     EXPECT_TRUE(focusHub1->IsEnabled());
51     EXPECT_TRUE(!focusHub1->IsFocusableNode());
52 
53     /**
54      * @tc.steps: step2. Create FocusHub with the WeakPtr eventHub_ which does not own frameNode.
55      * @tc.expected: eventHub can be updated, but cannot get frameNode and its related properties.
56      */
57     auto eventHub2 = AceType::MakeRefPtr<EventHub>();
58     auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub2);
59     EXPECT_TRUE(focusHub2 != nullptr);
60     EXPECT_TRUE(focusHub2->GetFrameNode() == nullptr);
61     EXPECT_TRUE(focusHub2->GetGeometryNode() == nullptr);
62     EXPECT_EQ(focusHub2->GetFrameName(), "NULL");
63     EXPECT_EQ(focusHub2->GetInspectorKey(), std::nullopt);
64 
65     /**
66      * @tc.steps: step3. Invoke GetParentFocusHub without parameter.
67      * @tc.expected: FocusHub will return frameNode' parent focusHub which is also nullptr.
68      */
69     EXPECT_TRUE(focusHub2->GetParentFocusHub() == nullptr);
70 
71     /**
72      * @tc.steps: step4. Invoke GetParentFocusHub passing node as parameter which does not have parent.
73      * @tc.expected: FocusHub will return node' parent focusHub which does not exist.
74      */
75     auto node = FrameNodeOnTree(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
76     EXPECT_TRUE(focusHub2->GetParentFocusHub() == nullptr);
77 }
78 
79 /**
80  * @tc.name: FocusHubCreateTest002
81  * @tc.desc: Create FocusHub.
82  * @tc.type: FUNC
83  */
84 HWTEST_F(FocusHubTestNg, FocusHubCreateTest002, TestSize.Level1)
85 {
86     /**
87      * @tc.steps: step1. Create FocusHub with the WeakPtr eventHub_ owning frameNode.
88      * @tc.expected: eventHub can be updated and can get frameNode and its related properties.
89      */
90     auto eventHub = AceType::MakeRefPtr<EventHub>();
91     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::TEXT_ETS_TAG, -1,
92         AceType::MakeRefPtr<Pattern>());
93     eventHub->AttachHost(frameNode);
94     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
95     EXPECT_TRUE(focusHub->GetFrameNode() != nullptr);
96     EXPECT_TRUE(focusHub->GetGeometryNode() != nullptr);
97     EXPECT_EQ(focusHub->GetFrameName(), V2::TEXT_ETS_TAG);
98     EXPECT_EQ(focusHub->GetInspectorKey(), std::nullopt);
99 
100     /**
101      * @tc.steps: step2. Invoke GetParentFocusHub without passing parameter.
102      * @tc.expected: FocusHub will return frameNode' parent focusHub which is also nullptr.
103      */
104     EXPECT_TRUE(focusHub->GetParentFocusHub() == nullptr);
105 
106     /**
107      * @tc.steps: step3. Create focusHub and its frameNode has parent node.
108      * @tc.expected: FocusHub will return frameNode' parent focusHub.
109      */
110     auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1,
111         AceType::MakeRefPtr<FlexLayoutPattern>());
112     nodeParent->GetOrCreateFocusHub();
113     frameNode->SetParent(nodeParent);
114     eventHub->AttachHost(frameNode);
115     auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub);
116     EXPECT_TRUE(focusHub2->GetParentFocusHub() != nullptr);
117 }
118 
119 /**
120  * @tc.name: FocusHubFlushChildrenFocusHubTest003
121  * @tc.desc: Create FocusHub and invoke FlushChildrenFocusHub.
122  * @tc.type: FUNC
123  */
124 HWTEST_F(FocusHubTestNg, FocusHubFlushChildrenFocusHubTest003, TestSize.Level1)
125 {
126     /**
127      * @tc.steps: step1. Create frameNode and add button as its children which focus type is enable.
128      */
129     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
130         AceType::MakeRefPtr<Pattern>());
131     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
132         AceType::MakeRefPtr<ButtonPattern>());
133     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
134         AceType::MakeRefPtr<ButtonPattern>());
135     child->GetOrCreateFocusHub();
136     child2->GetOrCreateFocusHub();
137     frameNode->AddChild(child);
138     frameNode->AddChild(child2);
139 
140     /**
141      * @tc.steps: step2. Create FocusHub.
142      */
143     auto eventHub = AceType::MakeRefPtr<EventHub>();
144     eventHub->AttachHost(frameNode);
145     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
146 
147     /**
148      * @tc.steps: step3. Invoke FlushChildrenFocusHub to get the focusable children.
149      * @tc.expected: Button is the focusable child which will be emplace_back in focusNodes_.
150      */
151     std::list<RefPtr<FocusHub>> focusNodes;
152     focusHub->FlushChildrenFocusHub(focusNodes);
153     EXPECT_EQ(focusNodes.size(), FOCUS_NODE_SIZE);
154     EXPECT_EQ(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
155 
156     /**
157      * @tc.steps: step4. lastWeakFocusNode_ is not nullptr.
158      * @tc.expected: itLastFocusNode_ will be assigned the iter corresponding lastWeakFocusNode_ found in focusNodes_.
159      */
160     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(*(focusNodes.begin())));
161     EXPECT_EQ(focusHub->lastWeakFocusNode_.Upgrade(), *(focusNodes.begin()));
162 }
163 
164 /**
165  * @tc.name: FocusHubRemoveSelfTest004
166  * @tc.desc: Create FocusHub and invoke RemoveSelf.
167  * @tc.type: FUNC
168  */
169 HWTEST_F(FocusHubTestNg, FocusHubRemoveSelfTest004, TestSize.Level1)
170 {
171     /**
172      * @tc.steps: step1. Create frameNode and add its parent.
173      */
174     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::TEXT_ETS_TAG, -1,
175         AceType::MakeRefPtr<Pattern>());
176     auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1,
177         AceType::MakeRefPtr<FlexLayoutPattern>());
178     nodeParent->GetOrCreateFocusHub();
179     frameNode->SetParent(nodeParent);
180 
181     /**
182      * @tc.steps: step2. Create FocusHub.
183      */
184     auto eventHub = AceType::MakeRefPtr<EventHub>();
185     eventHub->AttachHost(frameNode);
186     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
187 
188     /**
189      * @tc.steps: step3. Remove self.
190      * @tc.expected: The nodeParent children size is 0.
191      */
192     focusHub->focusScopeId_="1";
193     focusHub->RemoveSelf();
194     EXPECT_EQ(nodeParent->GetChildren().size(), NODE_SIZE);
195 }
196 
197 /**
198  * @tc.name: FocusHubLostFocusTest005
199  * @tc.desc: Create FocusHub and invoke LostFocus.
200  * @tc.type: FUNC
201  */
202 HWTEST_F(FocusHubTestNg, FocusHubLostFocusTest005, TestSize.Level1)
203 {
204     /**
205      * @tc.steps: step1. Create frameNode and add button as its children which focus type is enable.
206      */
207     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
208         AceType::MakeRefPtr<Pattern>());
209 
210     /**
211      * @tc.steps: step2. Create FocusHub.
212      */
213     auto eventHub = AceType::MakeRefPtr<EventHub>();
214     eventHub->AttachHost(frameNode);
215     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
216 
217     /**
218      * @tc.steps: step3. Invoke LostFocus, when FocusType is DISABLE and  the blur reason is FOCUS_SWITCH.
219      * @tc.expected: currentFocus_ is false.
220      */
221     focusHub->currentFocus_ = true;
222     focusHub->LostFocus(BLUR_REASON_FOCUS_SWITCH);
223     EXPECT_EQ(focusHub->blurReason_, BLUR_REASON_FOCUS_SWITCH);
224     EXPECT_FALSE(focusHub->currentFocus_);
225 
226     /**
227      * @tc.steps: step4. Invoke LostFocus, when FocusType is NODE and  the blur reason is WINDOW_BLUR.
228      * @tc.expected: currentFocus_ is false.
229      */
230     focusHub->currentFocus_ = true;
231     focusHub->focusType_ = FocusType::NODE;
232     focusHub->LostFocus(BLUR_REASON_WINDOW_BLUR);
233     EXPECT_EQ(focusHub->blurReason_, BLUR_REASON_WINDOW_BLUR);
234     EXPECT_FALSE(focusHub->currentFocus_);
235 
236     /**
237      * @tc.steps: step5. Invoke LostFocus, when FocusType is SCOPE and  the blur reason is WINDOW_BLUR.
238      * @tc.expected: currentFocus_ is false.
239      */
240     focusHub->currentFocus_ = true;
241     focusHub->focusType_ = FocusType::SCOPE;
242     focusHub->LostFocus(BLUR_REASON_WINDOW_BLUR);
243     EXPECT_FALSE(focusHub->currentFocus_);
244 }
245 
246 /**
247  * @tc.name: FocusHubHandleKeyEventTest006
248  * @tc.desc: Create FocusHub and invoke HandleKeyEvent.
249  * @tc.type: FUNC
250  */
251 HWTEST_F(FocusHubTestNg, FocusHubHandleKeyEventTest006, TestSize.Level1)
252 {
253     /**
254      * @tc.steps: step1. Create frameNode.
255      */
256     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
257         AceType::MakeRefPtr<Pattern>());
258     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
259         AceType::MakeRefPtr<ButtonPattern>());
260     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
261         AceType::MakeRefPtr<ButtonPattern>());
262     child->GetOrCreateFocusHub();
263     child2->GetOrCreateFocusHub();
264     frameNode->AddChild(child);
265     frameNode->AddChild(child2);
266 
267     /**
268      * @tc.steps: step2. Create FocusHub.
269      */
270     auto eventHub = AceType::MakeRefPtr<EventHub>();
271     eventHub->AttachHost(frameNode);
272     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
273 
274     /**
275      * @tc.steps: step3. Focus hub does not currently focused and FocusType is DISABLE.
276      * @tc.expected: Do not handle key event.
277      */
278     KeyEvent keyEvent;
279     keyEvent.code = KeyCode::TV_CONTROL_UP;
280     EXPECT_FALSE(focusHub->HandleKeyEvent(keyEvent));
281 
282     /**
283      * @tc.steps: step4. Focus hub is currently focused, FocusType is DISABLE and key code is TV_CONTROL_UP.
284      * @tc.expected: OnKeyEventScope -> RequestNextFocus.
285      */
286     focusHub->focusType_ = FocusType::SCOPE;
287     focusHub->currentFocus_ = true;
288     EXPECT_FALSE(focusHub->HandleKeyEvent(keyEvent));
289 }
290 
291 /**
292  * @tc.name: FocusHubTestNg007
293  * @tc.desc: Test the function IsFocusableScope.
294  * @tc.type: FUNC
295  */
296 HWTEST_F(FocusHubTestNg, FocusHubTestNg007, TestSize.Level1)
297 {
298     /**
299      * @tc.steps1: initialize parameters.
300      */
301     auto eventHub = AceType::MakeRefPtr<EventHub>();
302     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
303     focusHub->focusable_ = true;
304     focusHub->parentFocusable_ = true;
305 
306     /**
307      * @tc.steps2: call the function SetEnabled with false
308      * @tc.expected: The return value of IsFocusableScope is false.
309      */
310     eventHub->SetEnabled(false);
311     EXPECT_FALSE(focusHub->IsFocusableScope());
312 
313     /**
314      * @tc.steps3: call the function SetEnabled with true.
315      * @tc.expected: The return value of IsFocusableScope is false.
316      */
317     eventHub->SetEnabled(true);
318     EXPECT_FALSE(focusHub->IsFocusableScope());
319 }
320 
321 /**
322  * @tc.name: FocusHubTestNg008
323  * @tc.desc: Test the function SetFocusable.
324  * @tc.type: FUNC
325  */
326 HWTEST_F(FocusHubTestNg, FocusHubTestNg008, TestSize.Level1)
327 {
328     /**
329      * @tc.steps1: initialize parameters.
330      * @tc.expected: The default value of focusable_ is false.
331      */
332     auto eventHub = AceType::MakeRefPtr<EventHub>();
333     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
334     EXPECT_FALSE(focusHub->focusable_);
335 
336     /**
337      * @tc.steps2: Set focusable_ to true implicitly.
338      * @tc.expected: The value of focusable_ is true.
339      */
340     focusHub->SetFocusable(true, false);
341     EXPECT_TRUE(focusHub->focusable_);
342 
343     /**
344      * @tc.steps3:Set focusable_ to false explicitly.
345      * @tc.expected: The value of focusable_ is false.
346      */
347     focusHub->SetFocusable(false);
348 
349     /**
350      * @tc.steps4:Set focusable_ to true implicitly.
351      * @tc.expected: The value of focusable_ is false.
352      */
353     focusHub->SetFocusable(true, false);
354     EXPECT_FALSE(focusHub->focusable_);
355 
356     /**
357      * @tc.steps5:Set focusable_ to true explicitly.
358      * @tc.expected: The value of focusable_ is true.
359      */
360     focusHub->SetFocusable(true);
361     EXPECT_TRUE(focusHub->focusable_);
362 }
363 
364 /**
365  * @tc.name: FocusHubTestNg009
366  * @tc.desc: Test the function IsFocusable.
367  * @tc.type: FUNC
368  */
369 HWTEST_F(FocusHubTestNg, FocusHubTestNg009, TestSize.Level1)
370 {
371     /**
372      * @tc.steps1: initialize parameters.
373      */
374     auto eventHub = AceType::MakeRefPtr<EventHub>();
375     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
376     eventHub->SetEnabled(false);
377 
378     /**
379      * @tc.steps2: call the function IsFocusable with FocusType::NODE
380      * @tc.expected: The return value of IsFocusable is false.
381      */
382     focusHub->SetFocusType(FocusType::NODE);
383     EXPECT_FALSE(focusHub->IsFocusable());
384 
385     /**
386      * @tc.steps3: call the function IsFocusable with FocusType::SCOPE
387      * @tc.expected: The return value of IsFocusable is false.
388      */
389     focusHub->SetFocusType(FocusType::SCOPE);
390     EXPECT_FALSE(focusHub->IsFocusable());
391 
392     /**
393      * @tc.steps4: call the function IsFocusable with FocusType::DISABLE
394      * @tc.expected: The return value of IsFocusable is false.
395      */
396     focusHub->SetFocusType(FocusType::DISABLE);
397     EXPECT_FALSE(focusHub->IsFocusable());
398 }
399 
400 /**
401  * @tc.name: FocusHubTestNg010
402  * @tc.desc: Test the function RequestFocusImmediately.
403  * @tc.type: FUNC
404  */
405 HWTEST_F(FocusHubTestNg, FocusHubTestNg0010, TestSize.Level1)
406 {
407     /**
408      * @tc.steps1: initialize parameters.
409      */
410     auto eventHub = AceType::MakeRefPtr<EventHub>();
411     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
412     auto context = PipelineContext::GetCurrentContext();
413     ASSERT_NE(context, nullptr);
414 
415     /**
416      * @tc.steps2: call the function SetFocusType with currentFocus_ = false.
417      * @tc.expected: The return value of RequestFocusImmediately is false.
418      */
419     context->SetIsFocusingByTab(true);
420     focusHub->SetFocusType(FocusType::DISABLE);
421     EXPECT_FALSE(focusHub->RequestFocusImmediately());
422 
423     /**
424      * @tc.steps3: call the function SetFocusType with currentFocus_ = true
425      * @tc.expected: The return value of RequestFocusImmediately is true.
426      */
427     context->SetIsFocusingByTab(false);
428     focusHub->SetFocusType(FocusType::DISABLE);
429     focusHub->currentFocus_ = true;
430     EXPECT_TRUE(focusHub->RequestFocusImmediately());
431 }
432 
433 /**
434  * @tc.name: FocusHubTestNg011
435  * @tc.desc: Test the function LostFocus.
436  * @tc.type: FUNC
437  */
438 HWTEST_F(FocusHubTestNg, FocusHubTestNg0011, TestSize.Level1)
439 {
440     /**
441      * @tc.steps1: initialize parameters.
442      */
443     auto eventHub = AceType::MakeRefPtr<EventHub>();
444     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
445 
446     /**
447      * @tc.steps2: call the function LostFocus with currentFocus_ = false.
448      * @tc.expected: The value of blurReason_ is changed to BlurReason::WINDOW_BLUR.
449      */
450     focusHub->blurReason_ = BlurReason::WINDOW_BLUR;
451     focusHub->currentFocus_ = false;
452     focusHub->LostFocus(BlurReason::FOCUS_SWITCH);
453     EXPECT_EQ(focusHub->blurReason_, BlurReason::WINDOW_BLUR);
454 
455     /**
456      * @tc.steps3: call the function LostFocus with currentFocus_ = true.
457      * @tc.expected: The value of blurReason_ is changed to BlurReason::FOCUS_SWITCH.
458      */
459     focusHub->currentFocus_ = true;
460     focusHub->LostFocus(BlurReason::FOCUS_SWITCH);
461     EXPECT_EQ(focusHub->blurReason_, BlurReason::FOCUS_SWITCH);
462 }
463 
464 /**
465  * @tc.name: FocusHubTestNg012
466  * @tc.desc: Test the function LostSelfFocus.
467  * @tc.type: FUNC
468  */
469 HWTEST_F(FocusHubTestNg, FocusHubTestNg0012, TestSize.Level1)
470 {
471     /**
472      * @tc.steps1: initialize parameters.
473      */
474     auto eventHub = AceType::MakeRefPtr<EventHub>();
475     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
476 
477     /**
478      * @tc.steps2: call the function LostSelfFocus with currentFocus_ = false.
479      * @tc.expected: The value of focusable_ is changed to false.
480      */
481     focusHub->currentFocus_ = false;
482     focusHub->SetFocusable(false);
483     focusHub->LostSelfFocus();
484     EXPECT_FALSE(focusHub->focusable_);
485 
486     /**
487      * @tc.steps3: call the function LostSelfFocus with currentFocus_ = true.
488      * @tc.expected: The value of focusable_ is changed to true.
489      */
490     focusHub->currentFocus_ = true;
491     focusHub->LostSelfFocus();
492     EXPECT_TRUE(focusHub->focusable_);
493 }
494 
495 /**
496  * @tc.name: FocusHubTestNg013
497  * @tc.desc: Test the function SetShow, SetEnabled, SetEnabledNode and SetEnabledScope.
498  * @tc.type: FUNC
499  */
500 HWTEST_F(FocusHubTestNg, FocusHubTestNg0013, TestSize.Level1)
501 {
502     /**
503      * @tc.steps1: initialize parameters.
504      */
505     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
506         AceType::MakeRefPtr<Pattern>());
507     auto eventHub = AceType::MakeRefPtr<EventHub>();
508     eventHub->AttachHost(frameNode);
509     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
510     auto context = PipelineContext::GetCurrentContext();
511     ASSERT_NE(context, nullptr);
512 
513     /**
514      * @tc.steps2: call the function SetShow with FocusType::NODE.
515      * @tc.expected: The value of show_ is changed to true.
516      */
517     focusHub->SetFocusType(FocusType::NODE);
518     focusHub->SetShow(true);
519     focusHub->SetEnabled(true);
520     EXPECT_TRUE(focusHub->IsShow());
521 
522     /**
523      * @tc.steps3: call the function SetShow with FocusType::SCOPE.
524      * @tc.expected: The value of show_ is changed to false.
525      */
526     focusHub->SetFocusType(FocusType::SCOPE);
527     focusHub->SetShow(false);
528     focusHub->SetEnabled(false);
529     frameNode->layoutProperty_->propVisibility_ = VisibleType::INVISIBLE;
530     EXPECT_FALSE(focusHub->IsShow());
531 
532     /**
533      * @tc.steps4: call the function SetShow with FocusType::DISABLE.
534      * @tc.expected: The value of show_ is changed to false.
535      */
536     focusHub->SetFocusType(FocusType::DISABLE);
537     focusHub->SetShow(true);
538     focusHub->SetEnabled(true);
539     EXPECT_FALSE(focusHub->IsShow());
540 }
541 
542 /**
543  * @tc.name: FocusHubTestNg014
544  * @tc.desc: Test functions OnFocus, OnFocusNode and OnFocusScope.
545  * @tc.type: FUNC
546  */
547 HWTEST_F(FocusHubTestNg, FocusHubTestNg0014, TestSize.Level1)
548 {
549     /**
550      * @tc.steps1: initialize parameters.
551      */
552     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
553         AceType::MakeRefPtr<Pattern>());
554     auto eventHub = AceType::MakeRefPtr<EventHub>();
555     eventHub->AttachHost(frameNode);
556     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
557 
558     /**
559      * @tc.steps2: call the function OnFocus with FocusType::SCOPE.
560      * @tc.expected: The focusNodes_ is empty.
561      */
562     focusHub->SetFocusType(FocusType::SCOPE);
563     focusHub->OnFocus();
564     std::list<RefPtr<FocusHub>> focusNodes;
565     focusHub->FlushChildrenFocusHub(focusNodes);
566     EXPECT_TRUE(focusNodes.empty());
567 
568     /**
569      * @tc.steps3: call the function OnFocus with FocusType::NODE.
570      * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
571      */
572     focusHub->SetFocusType(FocusType::NODE);
573     focusHub->OnFocus();
574     bool flagCbk1 = false;
575     bool flagCbk2 = false;
__anonc1fb89a80102() 576     focusHub->onFocusInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
577     focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
__anonc1fb89a80202() 578     focusHub->SetOnFocusCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
579     focusHub->OnFocus();
580     EXPECT_TRUE(flagCbk1);
581     EXPECT_TRUE(flagCbk2);
582 }
583 
584 /**
585  * @tc.name: FocusHubTestNg015
586  * @tc.desc: Test functions OnBlur, OnBlurNode and OnBlurScope.
587  * @tc.type: FUNC
588  */
589 HWTEST_F(FocusHubTestNg, FocusHubTestNg0015, TestSize.Level1)
590 {
591     /**
592      * @tc.steps1: initialize parameters.
593      */
594     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
595         AceType::MakeRefPtr<ButtonPattern>());
596     auto eventHub = AceType::MakeRefPtr<EventHub>();
597     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
598     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
599 
600     /**
601      * @tc.steps2: call the function OnBlur with FocusType::NODE.
602      * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
603      */
604     focusHub->SetFocusType(FocusType::NODE);
605     focusHub->OnBlur();
606     bool flagCbk1 = false;
607     bool flagCbk2 = false;
608     BlurReason flagReason = BlurReason::WINDOW_BLUR;
__anonc1fb89a80302() 609     focusHub->onBlurInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
__anonc1fb89a80402(BlurReason reason) 610     focusHub->onBlurReasonInternal_ = [&flagReason](BlurReason reason) { flagReason = reason; };
__anonc1fb89a80502() 611     focusHub->SetOnBlurCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
612     focusHub->OnBlur();
613     EXPECT_TRUE(flagCbk1);
614     EXPECT_TRUE(flagCbk2);
615     EXPECT_EQ(flagReason, BlurReason::FOCUS_SWITCH);
616 
617     /**
618      * @tc.steps3: call the function OnBlur with FocusType::SCOPE.
619      * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
620      */
621     focusHub->SetFocusType(FocusType::SCOPE);
622     focusHub->OnFocus();
623     flagCbk1 = false;
624     flagCbk2 = false;
625     flagReason = BlurReason::WINDOW_BLUR;
__anonc1fb89a80602() 626     focusHub->onBlurInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
__anonc1fb89a80702(BlurReason reason) 627     focusHub->onBlurReasonInternal_ = [&flagReason](BlurReason reason) { flagReason = reason; };
__anonc1fb89a80802() 628     focusHub->SetOnBlurCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
629     focusHub->OnBlur();
630     EXPECT_TRUE(flagCbk1);
631     EXPECT_TRUE(flagCbk2);
632     EXPECT_EQ(flagReason, BlurReason::FOCUS_SWITCH);
633 }
634 
635 /**
636  * @tc.name: FocusHubTestNg016
637  * @tc.desc: Test the function OnKeyEvent, OnKeyEventScope and OnKeyEventNode.
638  * @tc.type: FUNC
639  */
640 HWTEST_F(FocusHubTestNg, FocusHubTestNg0016, TestSize.Level1)
641 {
642     /**
643      * @tc.steps1: initialize parameters.
644      */
645     auto eventHub = AceType::MakeRefPtr<EventHub>();
646     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
647     auto context = PipelineContext::GetCurrentContext();
648     ASSERT_NE(context, nullptr);
649     KeyEvent keyEvent;
650     keyEvent.action = KeyAction::DOWN;
651     keyEvent.code = KeyCode::KEY_SPACE;
652     keyEvent.isRedispatch = true;
653     keyEvent.isPreIme = true;
654 
655     /**
656      * @tc.steps2: call the function OnKeyEvent with FocusType::NODE.
657      * @tc.expected: The return value of OnKeyEvent is false.
658      */
659     focusHub->SetFocusType(FocusType::NODE);
660     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
661 
662     /**
663      * @tc.steps3: call the function OnKeyEvent with FocusType::SCOPE.
664      * @tc.expected: The return value of OnKeyEvent is false.
665      */
666     focusHub->SetFocusType(FocusType::SCOPE);
667     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
668 
669     /**
670      * @tc.steps4: call the function OnKeyEvent with FocusType::DISABLE.
671      * @tc.expected: The return value of OnKeyEvent is false.
672      */
673     focusHub->SetFocusType(FocusType::DISABLE);
674     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
675 }
676 
677 /**
678  * @tc.name: FocusHubTestNg017
679  * @tc.desc: Test the function HandleFocusByTabIndex.
680  * @tc.type: FUNC
681  */
682 HWTEST_F(FocusHubTestNg, FocusHubTestNg0017, TestSize.Level1)
683 {
684     /**
685      * @tc.steps1: initialize parameters.
686      */
687     auto eventHub = AceType::MakeRefPtr<EventHub>();
688     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
689     KeyEvent keyEvent;
690 
691     /**
692      * @tc.steps2: call the function HandleFocusByTabIndex with code != KeyCode::KEY_TAB and action != KeyAction::DOWN.
693      * @tc.expected: The return value of HandleFocusByTabIndex is false.
694      */
695     keyEvent.action = KeyAction::UNKNOWN;
696     keyEvent.code = KeyCode::KEY_UNKNOWN;
697     EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
698 
699     /**
700      * @tc.steps3: call the function HandleFocusByTabIndex with code != KeyCode::KEY_TAB and action == KeyAction::DOWN.
701      * @tc.expected: The return value of HandleFocusByTabIndex is false.
702      */
703     keyEvent.action = KeyAction::DOWN;
704     keyEvent.code = KeyCode::KEY_UNKNOWN;
705     EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
706 
707     /**
708      * @tc.steps4: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action != KeyAction::DOWN.
709      * @tc.expected: The return value of HandleFocusByTabIndex is false.
710      */
711     keyEvent.action = KeyAction::UNKNOWN;
712     keyEvent.code = KeyCode::KEY_TAB;
713     EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
714 
715     /**
716      * @tc.steps5: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action == KeyAction::DOWN
717      *             and curPage == null.
718      * @tc.expected: The return value of HandleFocusByTabIndex is false.
719      */
720     keyEvent.action = KeyAction::DOWN;
721     keyEvent.code = KeyCode::KEY_TAB;
722     EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
723 
724     /**
725      * @tc.steps6: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action == KeyAction::DOWN
726      *             and curPage == focusHub.
727      * @tc.expected: The return value of HandleFocusByTabIndex is false.
728      */
729     keyEvent.action = KeyAction::DOWN;
730     keyEvent.code = KeyCode::KEY_TAB;
731     EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
732 }
733 
734 /**
735  * @tc.name: FocusHubTestNg018
736  * @tc.desc: Test the function HandleFocusByTabIndex.
737  * @tc.type: FUNC
738  */
739 HWTEST_F(FocusHubTestNg, FocusHubTestNg0018, TestSize.Level1)
740 {
741     /**
742      * @tc.steps1: initialize parameters.
743      */
744     auto eventHub = AceType::MakeRefPtr<EventHub>();
745     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
746     KeyEvent keyEvent;
747 
748     /**
749      * @tc.steps2: call the function GetFocusingTabNodeIdx with the empty TabIndexNodeList.
750      * @tc.expected: The return value of the function is NONE_TAB_FOCUSED_INDEX.
751      */
752     TabIndexNodeList tabIndexNodes;
753     EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
754 
755     /**
756      * @tc.steps3: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
757      * @tc.expected: The return value of the function is DEFAULT_TAB_FOCUSED_INDEX.
758      */
759     int32_t nodeId = 1;
760     focusHub->lastTabIndexNodeId_ = nodeId;
761     tabIndexNodes.emplace_back(focusHub->GetTabIndex(), focusHub);
762     EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
763 
764     /**
765      * @tc.steps4: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
766      * @tc.expected: The return value of the function is 0.
767      */
768     nodeId = -1;
769     focusHub->lastTabIndexNodeId_ = nodeId;
770     focusHub->currentFocus_ = true;
771     EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), 0);
772 
773     /**
774      * @tc.steps5: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
775      * @tc.expected: The return value of the function is NONE_TAB_FOCUSED_INDEX.
776      */
777     focusHub->currentFocus_ = false;
778     EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
779 }
780 
781 /**
782  * @tc.name: FocusHubTestNg019
783  * @tc.desc: Test the function RequestFocusImmediatelyById and GetChildFocusNodeById.
784  * @tc.type: FUNC
785  */
786 HWTEST_F(FocusHubTestNg, FocusHubTestNg0019, TestSize.Level1)
787 {
788     /**
789      * @tc.steps1: initialize parameters.
790      */
791     auto eventHub = AceType::MakeRefPtr<EventHub>();
792     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::TEXT_ETS_TAG, -1,
793         AceType::MakeRefPtr<Pattern>());
794     eventHub->AttachHost(frameNode);
795     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
796 
797     /**
798      * @tc.steps2: call the function RequestFocusImmediatelyById with the empty id.
799      * @tc.expected: The return value of the function is false.
800      */
801     const std::string nullStr("");
802     EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(nullStr));
803 
804     /**
805      * @tc.steps3: call the function RequestFocusImmediatelyById with the idStr.
806      * @tc.expected: The return value of the function is false.
807      */
808     const std::string idStr(V2::TEXT_ETS_TAG);
809     EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
810 
811     /**
812      * @tc.steps4: call the function RequestFocusImmediatelyById with the idStr and FocusType::NODE.
813      * @tc.expected: The return value of the function is false.
814      */
815     focusHub->SetFocusType(FocusType::NODE);
816     EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
817 
818     /**
819      * @tc.steps5: call the function RequestFocusImmediatelyById with the idStr and FocusType::SCOPE.
820      * @tc.expected: The return value of the function is false.
821      */
822     focusHub->SetFocusType(FocusType::SCOPE);
823     EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
824 }
825 
826 /**
827  * @tc.name: FocusHubTestNg020
828  * @tc.desc: Test the function GetChildFocusNodeByType.
829  * @tc.type: FUNC
830  */
831 HWTEST_F(FocusHubTestNg, FocusHubTestNg0020, TestSize.Level1)
832 {
833     /**
834      * @tc.steps1: initialize parameters.
835      */
836     auto eventHub = AceType::MakeRefPtr<EventHub>();
837     eventHub->SetEnabled(true);
838     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
839 
840     /**
841      * @tc.steps2: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT.
842      * @tc.expected: The return value of the function is focusHub.
843      */
844     focusHub->SetFocusType(FocusType::NODE);
845     focusHub->SetShow(true);
846     focusHub->focusable_ = true;
847     focusHub->parentFocusable_ = true;
848     focusHub->SetIsDefaultFocus(true);
849     EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), focusHub);
850 
851     /**
852      * @tc.steps3: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = false.
853      * @tc.expected: The return value of the function is nullptr.
854      */
855     focusHub->focusable_ = false;
856     focusHub->SetShow(false);
857     EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), nullptr);
858 
859     /**
860      * @tc.steps4: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and IsDefaultFocus = false.
861      * @tc.expected: The return value of the function is nullptr.
862      */
863     focusHub->SetIsDefaultFocus(false);
864     EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), nullptr);
865 
866     /**
867      * @tc.steps5: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = true.
868      * @tc.expected: The return value of the function is focusHub.
869      */
870     focusHub->SetShow(true);
871     focusHub->focusable_ = true;
872     focusHub->SetIsDefaultGroupFocus(true);
873     EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), focusHub);
874 
875     /**
876      * @tc.steps6: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = false.
877      * @tc.expected: The return value of the function is nullptr.
878      */
879     focusHub->focusable_ = false;
880     focusHub->SetShow(false);
881     EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
882 
883     /**
884      * @tc.steps7: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = true and
885      *             IsDefaultGroupFocus = false.
886      * @tc.expected: The return value of the function is nullptr.
887      */
888     focusHub->SetShow(true);
889     focusHub->SetIsDefaultGroupFocus(false);
890     EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
891 
892     /**
893      * @tc.steps8: call the function GetChildFocusNodeByType with FocusType::SCOPE.
894      * @tc.expected: The return value of the function is nullptr.
895      */
896     focusHub->SetFocusType(FocusType::SCOPE);
897     EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
898 }
899 
900 /**
901  * @tc.name: FocusHubTestNg021
902  * @tc.desc: Test the function GoToFocusByTabNodeIdx.
903  * @tc.type: FUNC
904  */
905 HWTEST_F(FocusHubTestNg, FocusHubTestNg0021, TestSize.Level1)
906 {
907     /**
908      * @tc.steps1: initialize parameters.
909      */
910     auto eventHub = AceType::MakeRefPtr<EventHub>();
911     eventHub->SetEnabled(true);
912     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
913 
914     /**
915      * @tc.steps2: call the function GoToFocusByTabNodeIdx with the empty TabIndexNodeList.
916      * @tc.expected: The return value of the function is false.
917      */
918     TabIndexNodeList tabIndexNodes;
919     EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 0));
920 
921     /**
922      * @tc.steps3: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
923      * @tc.expected: The return value of the function is false.
924      */
925     tabIndexNodes.emplace_back(focusHub->GetTabIndex(), nullptr);
926     EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 0));
927 
928     /**
929      * @tc.steps4: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
930      * @tc.expected: The return value of the function is false.
931      */
932     tabIndexNodes.emplace_back(focusHub->GetTabIndex(), focusHub);
933     EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
934 
935     /**
936      * @tc.steps5: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
937      * @tc.expected: The return value of the function is false.
938      */
939     focusHub->SetIsDefaultGroupHasFocused(false);
940     focusHub->SetFocusType(FocusType::SCOPE);
941     EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
942 
943     /**
944      * @tc.steps6: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
945      * @tc.expected: The return value of the function is false.
946      */
947     focusHub->SetIsDefaultGroupHasFocused(true);
948     focusHub->SetFocusType(FocusType::NODE);
949     EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
950 
951     /**
952      * @tc.steps7: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
953      * @tc.expected: The return value of the function is true.
954      */
955     focusHub->SetShow(true);
956     focusHub->focusable_ = true;
957     focusHub->parentFocusable_ = true;
958     EXPECT_TRUE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
959 }
960 
961 /**
962  * @tc.name: FocusHubTestNg022
963  * @tc.desc: Test the function IsFocusableByTab, IsFocusableNodeByTab and IsFocusableScopeByTab.
964  * @tc.type: FUNC
965  */
966 HWTEST_F(FocusHubTestNg, FocusHubTestNg0022, TestSize.Level1)
967 {
968     /**
969      * @tc.steps1: initialize parameters.
970      */
971     auto eventHub = AceType::MakeRefPtr<EventHub>();
972     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
973 
974     /**
975      * @tc.steps2: call the function IsFocusableByTab with FocusType::NODE.
976      * @tc.expected: The return value of the function is true.
977      */
978     focusHub->SetFocusType(FocusType::NODE);
979     EXPECT_TRUE(focusHub->IsFocusableByTab());
980 
981     /**
982      * @tc.steps3: call the function IsFocusableByTab with FocusType::SCOPE.
983      * @tc.expected: The return value of the function is true.
984      */
985     focusHub->SetFocusType(FocusType::SCOPE);
986     EXPECT_TRUE(focusHub->IsFocusableByTab());
987 
988     /**
989      * @tc.steps4: call the function IsFocusableByTab with FocusType::DISABLE.
990      * @tc.expected: The return value of the function is false.
991      */
992     focusHub->SetFocusType(FocusType::DISABLE);
993     EXPECT_FALSE(focusHub->IsFocusableByTab());
994 }
995 
996 /**
997  * @tc.name: FocusHubHandleDumpFocusTreeTest023
998  * @tc.desc: Test the function DumpFocusTree.
999  * @tc.type: FUNC
1000  */
1001 HWTEST_F(FocusHubTestNg, FocusHubHandleDumpFocusTreeTest023, TestSize.Level1)
1002 {
1003     /**
1004      * @tc.steps: step1. Create frameNode.
1005      */
1006     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1007         AceType::MakeRefPtr<Pattern>());
1008 
1009     /**
1010      * @tc.steps: step2. Create FocusHub.
1011      */
1012     auto eventHub = AceType::MakeRefPtr<EventHub>();
1013     eventHub->AttachHost(frameNode);
1014     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1015 
1016     /**
1017      * @tc.steps: step3. test function DumpFocusNodeTree.
1018      * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty.
1019      */
1020     int32_t depth = 1;
1021     focusHub->focusType_ = FocusType::NODE;
1022     auto ss = std::make_unique<std::ostringstream>();
1023     DumpLog::GetInstance().SetDumpFile(std::move(ss));
1024     focusHub->currentFocus_ = true;
1025     focusHub->DumpFocusTree(depth);
1026     EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1027 
1028     DumpLog::GetInstance().description_.push_back("test");
1029     focusHub->currentFocus_ = false;
1030     focusHub->focusable_ = false;
1031     focusHub->DumpFocusTree(depth);
1032     EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1033 
1034     /**
1035      * @tc.steps: step4. test function DumpFocusScopeTree.
1036      * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty.
1037      */
1038     DumpLog::GetInstance().description_.push_back("test");
1039     focusHub->focusType_ = FocusType::SCOPE;
1040     focusHub->currentFocus_ = true;
1041     focusHub->DumpFocusTree(depth);
1042     EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1043 
1044     DumpLog::GetInstance().description_.push_back("test");
1045     focusHub->currentFocus_ = false;
1046     focusHub->focusable_ = false;
1047     focusHub->DumpFocusTree(depth);
1048     EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1049 }
1050 
1051 /**
1052  * @tc.name: FocusHubRemoveChildTest001
1053  * @tc.desc: Test the function RemoveChild.
1054  * @tc.type: FUNC
1055  */
1056 HWTEST_F(FocusHubTestNg, FocusHubRemoveChildTest001, TestSize.Level1)
1057 {
1058     /**
1059      * @tc.steps: step1. Create frameNode.
1060      */
1061     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1062         AceType::MakeRefPtr<Pattern>());
1063     auto frameNode2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1064         AceType::MakeRefPtr<Pattern>());
1065     auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1,
1066         AceType::MakeRefPtr<FlexLayoutPattern>());
1067     frameNode->GetOrCreateFocusHub();
1068     frameNode2->GetOrCreateFocusHub();
1069     nodeParent->GetOrCreateFocusHub();
1070     frameNode->SetParent(nodeParent);
1071     frameNode2->SetParent(nodeParent);
1072 
1073     /**
1074      * @tc.steps: step2. Create FocusHub.
1075      */
1076     auto eventHub = AceType::MakeRefPtr<EventHub>();
1077     eventHub->AttachHost(frameNode);
1078     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1079 
1080     /**
1081      * @tc.steps: step3. Get parentFocusHub.
1082      */
1083     focusHub->currentFocus_ = true;
1084     auto parent = focusHub->GetParentFocusHub();
1085 
1086     /**
1087      * @tc.steps: step4. Test RemoveChild and parentFocusHub RemoveSelf.
1088      * @tc.expected: focusHub and parentFocusHub both lostFocus.
1089      */
1090     parent->currentFocus_ = true;
1091     parent->RemoveChild(focusHub);
1092     EXPECT_EQ(parent->blurReason_, BlurReason::FOCUS_SWITCH);
1093     EXPECT_EQ(focusHub->blurReason_, BlurReason::FRAME_DESTROY);
1094 }
1095 
1096 /**
1097  * @tc.name: FocusHubSetIsFocusOnTouch001
1098  * @tc.desc: Test the function SetIsFocusOnTouch.
1099  * @tc.type: FUNC
1100  */
1101 HWTEST_F(FocusHubTestNg, FocusHubSetIsFocusOnTouch001, TestSize.Level1)
1102 {
1103     /**
1104      * @tc.steps1: create frameNode.
1105      */
1106     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1107         AceType::MakeRefPtr<Pattern>());
1108 
1109     /**
1110      * @tc.steps2: create eventHub and focusHub.
1111      */
1112     auto eventHub = AceType::MakeRefPtr<EventHub>();
1113     eventHub->AttachHost(frameNode);
1114     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1115 
1116     /**
1117      * @tc.steps3: test SetIsFocusOnTouch.
1118      * @tc.expected: create touchEvents and set FocusOnTouch success.
1119      */
1120     focusHub->SetIsFocusOnTouch(true);
1121     auto gesture = frameNode->GetOrCreateGestureEventHub();
1122     EXPECT_FALSE(gesture->touchEventActuator_->touchEvents_.empty());
1123 
1124     /**
1125      * @tc.steps4: test SetIsFocusOnTouch.
1126      * @tc.expected: when touchEvents has been set, return.
1127      */
1128     focusHub->SetIsFocusOnTouch(true);
1129     EXPECT_TRUE(focusHub->IsFocusOnTouch().value());
1130 
1131     /**
1132      * @tc.steps4: test SetIsFocusOnTouch.
1133      * @tc.expected: set touchEvents false.
1134      */
1135     focusHub->SetIsFocusOnTouch(false);
1136     EXPECT_TRUE(gesture->touchEventActuator_->touchEvents_.empty());
1137 
1138     /**
1139      * @tc.steps5: test SetIsFocusOnTouch.
1140      * @tc.expected: set focusOnTouchListener_ success.
1141      */
1142     focusHub->SetIsFocusOnTouch(false);
1143     focusHub->focusOnTouchListener_ = nullptr;
1144     focusHub->SetIsFocusOnTouch(true);
1145     EXPECT_TRUE(focusHub->focusOnTouchListener_);
1146     auto touchCallback = focusHub->focusOnTouchListener_;
1147     TouchEventInfo touchEventInfo("onTouchUp");
1148     (*touchCallback)(touchEventInfo);
1149     TouchLocationInfo touchLocationInfo(1);
1150     touchLocationInfo.SetTouchType(TouchType::UP);
1151     touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
1152     focusHub->SetFocusType(FocusType::NODE);
1153     focusHub->focusable_ = true;
1154     (*touchCallback)(touchEventInfo);
1155     EXPECT_TRUE(focusHub->currentFocus_);
1156 }
1157 
1158 /**
1159  * @tc.name: FocusHubOnKeyEvent002
1160  * @tc.desc: Test the function OnKeyEvent.
1161  * @tc.type: FUNC
1162  */
1163 HWTEST_F(FocusHubTestNg, FocusHubOnKeyEvent002, TestSize.Level1)
1164 {
1165     /**
1166      * @tc.steps1: create frameNode.
1167      */
1168     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1169         AceType::MakeRefPtr<Pattern>());
1170 
1171     /**
1172      * @tc.steps2: create eventHub and focusHub.
1173      */
1174     auto eventHub = AceType::MakeRefPtr<EventHub>();
1175     eventHub->AttachHost(frameNode);
1176     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1177     KeyEvent keyEvent;
1178     keyEvent.action = KeyAction::UP;
1179     keyEvent.code = KeyCode::KEY_SPACE;
1180 
1181     /**
1182      * @tc.steps3: call the function OnKeyEvent with FocusType::NODE.
1183      * @tc.expected: The return value of OnKeyEvent is true.
1184      */
1185     focusHub->SetFocusType(FocusType::NODE);
__anonc1fb89a80902(KeyEventInfo& eventInfo) 1186     auto onKeyEventCallback = [](KeyEventInfo& eventInfo) -> bool {
1187         eventInfo.SetStopPropagation(true);
1188         return false;
1189     };
__anonc1fb89a80a02(const KeyEvent& event) 1190     auto onKeyEvent = [](const KeyEvent& event) -> bool { return true; };
1191     focusHub->SetOnKeyEventInternal(std::move(onKeyEvent));
1192     focusHub->SetOnKeyCallback(std::move(onKeyEventCallback));
1193     EXPECT_TRUE(focusHub->OnKeyEvent(keyEvent));
1194 }
1195 
1196 /**
1197  * @tc.name: FocusHubOnKeyEvent004
1198  * @tc.desc: Test the function OnKeyEvent.
1199  * @tc.type: FUNC
1200  */
1201 HWTEST_F(FocusHubTestNg, FocusHubOnKeyEvent004, TestSize.Level1)
1202 {
1203     /**
1204      * @tc.steps1: create frameNode.
1205      */
1206     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1207         AceType::MakeRefPtr<Pattern>());
1208     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1209         AceType::MakeRefPtr<ButtonPattern>());
1210     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1211         AceType::MakeRefPtr<ButtonPattern>());
1212     child->GetOrCreateFocusHub();
1213     child2->GetOrCreateFocusHub();
1214     frameNode->AddChild(child);
1215     frameNode->AddChild(child2);
1216 
1217     /**
1218      * @tc.steps2: create eventHub and focusHub.
1219      */
1220     auto eventHub = AceType::MakeRefPtr<EventHub>();
1221     eventHub->AttachHost(frameNode);
1222     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1223     auto childEventHub = AceType::MakeRefPtr<EventHub>();
1224     childEventHub->AttachHost(child);
1225 
1226     /**
1227      * @tc.steps3: create lastWeakFocusNode_.
1228      */
1229     std::list<RefPtr<FocusHub>> focusNodes;
1230     focusHub->FlushChildrenFocusHub(focusNodes);
1231     auto childFocusHub = *focusNodes.begin();
1232     childFocusHub->eventHub_ = childEventHub;
1233     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(childFocusHub));
1234 
1235     KeyEvent keyEvent;
1236     keyEvent.action = KeyAction::UP;
1237     auto pipeline = PipelineContext::GetCurrentContext();
1238     pipeline->isFocusActive_ = true;
1239 
1240     /**
1241      * @tc.steps5: test keyEvent with keyEvent.code == KeyCode::TV_CONTROL_UP.
1242      * @tc.expected: The return value of OnKeyEvent is false.
1243      */
1244     keyEvent.code = KeyCode::TV_CONTROL_UP;
1245     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1246 
1247     keyEvent.code = KeyCode::TV_CONTROL_DOWN;
1248     focusHub->SetScopeFocusAlgorithm();
1249     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1250 
1251     keyEvent.code = KeyCode::TV_CONTROL_LEFT;
1252     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1253 
1254     keyEvent.code = KeyCode::TV_CONTROL_RIGHT;
1255     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1256 
1257     keyEvent.code = KeyCode::KEY_TAB;
1258     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1259 
1260     keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
1261     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1262 
1263     keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB);
1264     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1265 
1266     keyEvent.code = KeyCode::KEY_MOVE_HOME;
1267     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1268 
1269     keyEvent.code = KeyCode::KEY_MOVE_END;
1270     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1271 
1272     keyEvent.code = KeyCode::KEY_SPACE;
1273     EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1274 }
1275 
1276 /**
1277  * @tc.name: FocusHubGoToNextFocusLinear001
1278  * @tc.desc: Test the function GoToNextFocusLinear.
1279  * @tc.type: FUNC
1280  */
1281 HWTEST_F(FocusHubTestNg, FocusHubGoToNextFocusLinear001, TestSize.Level1)
1282 {
1283     /**
1284      * @tc.steps: step1. Create frameNode.
1285      */
1286     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1287         AceType::MakeRefPtr<Pattern>());
1288     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1289         AceType::MakeRefPtr<ButtonPattern>());
1290     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1291         AceType::MakeRefPtr<ButtonPattern>());
1292     child->GetOrCreateFocusHub();
1293     child2->GetOrCreateFocusHub();
1294     frameNode->AddChild(child);
1295     frameNode->AddChild(child2);
1296 
1297     /**
1298      * @tc.steps: step2. Create FocusHub.
1299      */
1300     auto eventHub = AceType::MakeRefPtr<EventHub>();
1301     eventHub->AttachHost(frameNode);
1302     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1303 
1304     focusHub->currentFocus_ = true;
1305 
1306     std::list<RefPtr<FocusHub>> focusNodes;
1307     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1308 
1309     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1310     EXPECT_TRUE(focusHub->GoToNextFocusLinear(FocusStep::TAB));
1311 }
1312 
1313 /**
1314  * @tc.name: FocusHubPaintFocusState001
1315  * @tc.desc: Test the function PaintFocusState.
1316  * @tc.type: FUNC
1317  */
1318 HWTEST_F(FocusHubTestNg, PaintFocusState001, TestSize.Level1)
1319 {
1320     /**
1321      * @tc.steps1: create frameNode.
1322      */
1323     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1324         AceType::MakeRefPtr<Pattern>());
1325     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1326         AceType::MakeRefPtr<ButtonPattern>());
1327     child->GetOrCreateFocusHub();
1328     frameNode->AddChild(child);
1329 
1330     /**
1331      * @tc.steps2: create eventHub and focusHub.
1332      */
1333     auto eventHub = AceType::MakeRefPtr<EventHub>();
1334     ASSERT_NE(eventHub, nullptr);
1335     eventHub->AttachHost(frameNode);
1336     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1337     ASSERT_NE(focusHub, nullptr);
1338     auto context = PipelineContext::GetCurrentContext();
1339     ASSERT_NE(context, nullptr);
1340     auto renderContext = frameNode->GetRenderContext();
1341     ASSERT_NE(renderContext, nullptr);
1342 
1343     /**
1344      * @tc.steps3: create KeyEvent.
1345      */
1346     KeyEvent keyEvent;
1347     keyEvent.action = KeyAction::DOWN;
1348     keyEvent.code = KeyCode::KEY_SPACE;
1349 
1350     focusHub->SetFocusType(FocusType::SCOPE);
1351     EXPECT_EQ(focusHub->focusStyleType_, FocusStyleType::NONE);
1352 }
1353 
1354 /**
1355  * @tc.name: FocusHubSetIsDefaultFocus001
1356  * @tc.desc: Test the function SetIsDefaultFocus.
1357  * @tc.type: FUNC
1358  */
1359 HWTEST_F(FocusHubTestNg, SetIsDefaultFocus001, TestSize.Level1)
1360 {
1361     /**
1362      * @tc.steps1: create frameNode.
1363      */
1364     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1365         AceType::MakeRefPtr<Pattern>());
1366 
1367     auto eventHub = AceType::MakeRefPtr<EventHub>();
1368     ASSERT_NE(eventHub, nullptr);
1369     eventHub->AttachHost(frameNode);
1370     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1371     ASSERT_NE(focusHub, nullptr);
1372 
1373     auto pipeline = PipelineContext::GetCurrentContext();
1374     ASSERT_NE(pipeline, nullptr);
1375     auto manager = pipeline->GetOverlayManager();
1376     ASSERT_NE(manager, nullptr);
1377     auto rootNode = pipeline->GetRootElement();
1378     EXPECT_NE(rootNode, nullptr);
1379 
1380     focusHub->focusCallbackEvents_ = nullptr;
1381     focusHub->SetIsDefaultGroupFocus(false);
1382     EXPECT_NE(focusHub->focusCallbackEvents_, nullptr);
1383 }
1384 
1385 /**
1386  * @tc.name: FocusHubTestDisableFocus001
1387  * @tc.desc: Test disable functions Onfocus.
1388  * @tc.type: FUNC
1389  */
1390 HWTEST_F(FocusHubTestNg, FocusHubTestDisableFocus001, TestSize.Level1)
1391 {
1392     /**
1393      * @tc.steps1: initialize parameters.
1394      */
1395     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1396         AceType::MakeRefPtr<ButtonPattern>());
1397     auto eventHub = AceType::MakeRefPtr<EventHub>();
1398     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1399     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1400 
1401     /**
1402      * @tc.steps2: call the function OnFocus with FocusType::NODE.
1403      * @tc.expected: The result is right.
1404      */
1405     focusHub->SetFocusType(FocusType::NODE);
1406     std::string result;
__anonc1fb89a80b02() 1407     auto onFocus = [&result]() { result = RESULT_SUCCESS_ONE; };
1408     focusHub->SetOnFocusCallback(onFocus);
1409     EXPECT_NE(focusHub->GetOnFocusCallback(), nullptr);
1410 
1411     focusHub->OnFocus();
1412     EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1413 
1414     /**
1415      * @tc.steps3: clear the function.
1416      * @tc.expected: The result is nullptr.
1417      */
1418     focusHub->ClearUserOnFocus();
1419     EXPECT_EQ(focusHub->GetOnFocusCallback(), nullptr);
1420 
1421     /**
1422      * @tc.steps3: set the function again.
1423      * @tc.expected: The result is right.
1424      */
__anonc1fb89a80c02() 1425     auto onFocus2 = [&result]() { result = RESULT_SUCCESS_TWO; };
1426     focusHub->SetOnFocusCallback(onFocus2);
1427     EXPECT_NE(focusHub->GetOnFocusCallback(), nullptr);
1428 
1429     focusHub->OnFocus();
1430     EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1431 }
1432 
1433 /**
1434  * @tc.name: FocusHubTestDisableBlur001
1435  * @tc.desc: Test disable functions OnBlur.
1436  * @tc.type: FUNC
1437  */
1438 HWTEST_F(FocusHubTestNg, FocusHubTestDisableBlur001, TestSize.Level1)
1439 {
1440     /**
1441      * @tc.steps1: initialize parameters.
1442      */
1443     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1444         AceType::MakeRefPtr<ButtonPattern>());
1445     auto eventHub = AceType::MakeRefPtr<EventHub>();
1446     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1447     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1448 
1449     /**
1450      * @tc.steps2: call the function OnBlur with FocusType::NODE.
1451      * @tc.expected: The result is right.
1452      */
1453     focusHub->SetFocusType(FocusType::NODE);
1454     std::string result;
__anonc1fb89a80d02() 1455     auto onBlur = [&result]() { result = RESULT_SUCCESS_ONE; };
1456     focusHub->SetOnBlurCallback(onBlur);
1457     EXPECT_NE(focusHub->GetOnBlurCallback(), nullptr);
1458 
1459     focusHub->OnBlur();
1460     EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1461 
1462     /**
1463      * @tc.steps3: clear the function OnBlur.
1464      * @tc.expected: The result is nullptr.
1465      */
1466     focusHub->ClearUserOnBlur();
1467     EXPECT_EQ(focusHub->GetOnBlurCallback(), nullptr);
1468 
1469     /**
1470      * @tc.steps3: set the function OnBlur again.
1471      * @tc.expected: The result is right.
1472      */
__anonc1fb89a80e02() 1473     auto onBlur2 = [&result]() { result = RESULT_SUCCESS_TWO; };
1474     focusHub->SetOnBlurCallback(onBlur2);
1475     EXPECT_NE(focusHub->GetOnBlurCallback(), nullptr);
1476 
1477     focusHub->OnBlur();
1478     EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1479 }
1480 
1481 /**
1482  * @tc.name: FocusHubTestDisableKey001
1483  * @tc.desc: Test disable functions OnKey.
1484  * @tc.type: FUNC
1485  */
1486 HWTEST_F(FocusHubTestNg, FocusHubTestDisableKey001, TestSize.Level1)
1487 {
1488     /**
1489      * @tc.steps1: initialize parameters.
1490      */
1491     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1492         AceType::MakeRefPtr<ButtonPattern>());
1493     auto eventHub = AceType::MakeRefPtr<EventHub>();
1494     eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1495     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1496 
1497     /**
1498      * @tc.steps2: call the function OnKey with FocusType::NODE.
1499      * @tc.expected: The result is right.
1500      */
1501     focusHub->SetFocusType(FocusType::NODE);
1502     std::string result;
__anonc1fb89a80f02(KeyEventInfo& info) 1503     auto onKey = [&result](KeyEventInfo& info) -> bool {
1504         result = RESULT_SUCCESS_ONE;
1505         return false;
1506     };
1507     focusHub->SetOnKeyCallback(onKey);
1508     EXPECT_NE(focusHub->GetOnKeyCallback(), nullptr);
1509     KeyEvent keyEvent;
1510     keyEvent.action = KeyAction::UP;
1511     focusHub->OnKeyEvent(keyEvent);
1512     EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1513 
1514     /**
1515      * @tc.steps3: clear the function OnKey.
1516      * @tc.expected: The result is nullptr.
1517      */
1518     focusHub->ClearUserOnKey();
1519     EXPECT_EQ(focusHub->GetOnKeyCallback(), nullptr);
1520 
1521     /**
1522      * @tc.steps4: set the function OnKey again.
1523      * @tc.expected: The result is right.
1524      */
__anonc1fb89a81002(KeyEventInfo& info) 1525     auto onKey2 = [&result](KeyEventInfo& info) -> bool {
1526         result = RESULT_SUCCESS_TWO;
1527         return false;
1528     };
1529     focusHub->SetOnKeyCallback(onKey2);
1530     EXPECT_NE(focusHub->GetOnKeyCallback(), nullptr);
1531 
1532     focusHub->OnKeyEvent(keyEvent);
1533     EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1534 }
1535 
1536 /**
1537  * @tc.name: FocusHubTestNg0030
1538  * @tc.desc: Test the function GoToNextFocusLinear.
1539  * @tc.type: FUNC
1540  */
1541 HWTEST_F(FocusHubTestNg, FocusHubTestNg0030, TestSize.Level1)
1542 {
1543     /**
1544      * @tc.steps: step1. Create frameNode.
1545      */
1546     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1547         AceType::MakeRefPtr<Pattern>());
1548     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1549         AceType::MakeRefPtr<ButtonPattern>());
1550     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1551         AceType::MakeRefPtr<ButtonPattern>());
1552     child->GetOrCreateFocusHub();
1553     child2->GetOrCreateFocusHub();
1554     frameNode->AddChild(child);
1555     frameNode->AddChild(child2);
1556     auto eventHub = AceType::MakeRefPtr<EventHub>();
1557     eventHub->AttachHost(frameNode);
1558     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1559     focusHub->currentFocus_ = true;
1560     std::list<RefPtr<FocusHub>> focusNodes;
1561     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1562     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1563     EXPECT_FALSE(focusHub->GoToNextFocusLinear(FocusStep::NONE));
1564 }
1565 
1566 /**
1567  * @tc.name: FocusHubTestNg0031
1568  * @tc.desc: Test the function IsNeedPaintFocusState.
1569  * @tc.type: FUNC
1570  */
1571 HWTEST_F(FocusHubTestNg, FocusHubTestNg0031, TestSize.Level1)
1572 {
1573     /**
1574      * @tc.steps: step1. Create frameNode.
1575      */
1576     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1577         AceType::MakeRefPtr<Pattern>());
1578     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1579         AceType::MakeRefPtr<ButtonPattern>());
1580     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1581         AceType::MakeRefPtr<ButtonPattern>());
1582     child->GetOrCreateFocusHub();
1583     child2->GetOrCreateFocusHub();
1584     frameNode->AddChild(child);
1585     frameNode->AddChild(child2);
1586     auto eventHub = AceType::MakeRefPtr<EventHub>();
1587     eventHub->AttachHost(frameNode);
1588     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1589     std::list<RefPtr<FocusHub>> focusNodes;
1590     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1591     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1592     focusHub->IsNeedPaintFocusState();
1593     focusHub->focusType_ = FocusType::NODE;
1594     focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
1595     focusHub->IsNeedPaintFocusState();
1596     focusHub->focusType_ = FocusType::NODE;
1597     EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
1598 }
1599 
1600 /**
1601  * @tc.name: FocusHubTestNg0032
1602  * @tc.desc: Test the function PaintFocusState.
1603  * @tc.type: FUNC
1604  */
1605 HWTEST_F(FocusHubTestNg, FocusHubTestNg0032, TestSize.Level1)
1606 {
1607     /**
1608      * @tc.steps: step1. Create frameNode.
1609      */
1610     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1611         AceType::MakeRefPtr<Pattern>());
1612     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1613         AceType::MakeRefPtr<ButtonPattern>());
1614     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1615         AceType::MakeRefPtr<ButtonPattern>());
1616     child->GetOrCreateFocusHub();
1617     child2->GetOrCreateFocusHub();
1618     frameNode->AddChild(child);
1619     frameNode->AddChild(child2);
1620     auto eventHub = AceType::MakeRefPtr<EventHub>();
1621     eventHub->AttachHost(frameNode);
1622     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1623     auto context = PipelineContext::GetCurrentContext();
1624     ASSERT_NE(context, nullptr);
1625     context->isFocusActive_ = true;
1626     focusHub->focusType_ = FocusType::NODE;
1627     focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
1628     std::list<RefPtr<FocusHub>> focusNodes;
1629     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1630     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1631     EXPECT_FALSE(focusHub->PaintFocusState());
1632 }
1633 
1634 /**
1635  * @tc.name: FocusHubTestNg0033
1636  * @tc.desc: Test the function AcceptFocusOfSpecifyChild.
1637  * @tc.type: FUNC
1638  */
1639 HWTEST_F(FocusHubTestNg, FocusHubTestNg0033, TestSize.Level1)
1640 {
1641     /**
1642      * @tc.steps: step1. Create frameNode.
1643      */
1644     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1645         AceType::MakeRefPtr<Pattern>());
1646     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1647         AceType::MakeRefPtr<ButtonPattern>());
1648     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1649         AceType::MakeRefPtr<ButtonPattern>());
1650     child->GetOrCreateFocusHub();
1651     child2->GetOrCreateFocusHub();
1652     frameNode->AddChild(child);
1653     frameNode->AddChild(child2);
1654     auto eventHub = AceType::MakeRefPtr<EventHub>();
1655     eventHub->AttachHost(frameNode);
1656     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1657     focusHub->focusType_ = FocusType::DISABLE;
1658     std::list<RefPtr<FocusHub>> focusNodes;
1659     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1660     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1661     focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
1662     focusHub->focusType_ = FocusType::SCOPE;
1663     EXPECT_FALSE(focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB));
1664     EXPECT_FALSE(focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB));
1665 }
1666 
1667 /**
1668  * @tc.name: FocusHubTestNg0034
1669  * @tc.desc: Test the function ClearFocusState.
1670  * @tc.type: FUNC
1671  */
1672 HWTEST_F(FocusHubTestNg, FocusHubTestNg0034, TestSize.Level1)
1673 {
1674     /**
1675      * @tc.steps: step1. Create frameNode.
1676      */
1677     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1678         AceType::MakeRefPtr<Pattern>());
1679     auto eventHub = AceType::MakeRefPtr<EventHub>();
1680     eventHub->AttachHost(frameNode);
1681     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1682     focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
1683     std::list<RefPtr<FocusHub>> focusNodes;
1684     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1685     EXPECT_EQ(itNewFocusNode, focusNodes.end());
__anonc1fb89a81102() 1686     focusHub->onClearFocusStateCallback_ = []() {};
1687     focusHub->ClearFocusState();
1688     EXPECT_NE(focusHub->focusStyleType_, FocusStyleType::NONE);
1689 }
1690 
1691 /**
1692  * @tc.name: FocusHubTestNg0035
1693  * @tc.desc: Test the function RequestFocusImmediately.
1694  * @tc.type: FUNC
1695  */
1696 HWTEST_F(FocusHubTestNg, FocusHubTestNg0035, TestSize.Level1)
1697 {
1698     auto eventHub = AceType::MakeRefPtr<EventHub>();
1699     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1700     auto context = PipelineContext::GetCurrentContext();
1701     ASSERT_NE(context, nullptr);
1702 
1703     context->SetIsFocusingByTab(true);
1704     focusHub->SetFocusType(FocusType::DISABLE);
1705     focusHub->focusType_ = FocusType::NODE;
1706     focusHub->currentFocus_ = false;
__anonc1fb89a81202() 1707     focusHub->onPreFocusCallback_ = []() {};
1708     EXPECT_FALSE(focusHub->RequestFocusImmediately());
1709     EXPECT_FALSE(focusHub->RequestFocusImmediately());
1710     context->SetIsFocusingByTab(false);
1711     focusHub->SetFocusType(FocusType::DISABLE);
1712     focusHub->currentFocus_ = true;
1713     EXPECT_TRUE(focusHub->RequestFocusImmediately());
1714 }
1715 
1716 /**
1717  * @tc.name: FocusHubTestNg0036
1718  * @tc.desc: Test the function OnFocusScope.
1719  * @tc.type: FUNC
1720  */
1721 HWTEST_F(FocusHubTestNg, FocusHubTestNg0036, TestSize.Level1)
1722 {
1723     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1724         AceType::MakeRefPtr<Pattern>());
1725     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1726         AceType::MakeRefPtr<ButtonPattern>());
1727     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1728         AceType::MakeRefPtr<ButtonPattern>());
1729     child->GetOrCreateFocusHub();
1730     child2->GetOrCreateFocusHub();
1731     frameNode->AddChild(child);
1732     frameNode->AddChild(child2);
1733     auto eventHub = AceType::MakeRefPtr<EventHub>();
1734     eventHub->AttachHost(frameNode);
1735     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1736     focusHub->currentFocus_ = true;
1737     std::list<RefPtr<FocusHub>> focusNodes;
1738     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1739     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1740     focusHub->OnFocusScope();
1741     EXPECT_TRUE(focusHub->currentFocus_);
1742 }
1743 
1744 /**
1745  * @tc.name: FocusHubTestNg0037
1746  * @tc.desc: Test the function IsFocusableScopeByTab.
1747  * @tc.type: FUNC
1748  */
1749 HWTEST_F(FocusHubTestNg, FocusHubTestNg0037, TestSize.Level1)
1750 {
1751     /**
1752      * @tc.steps: step1. Create frameNode.
1753      */
1754     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1755         AceType::MakeRefPtr<Pattern>());
1756     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1757         AceType::MakeRefPtr<ButtonPattern>());
1758     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1759         AceType::MakeRefPtr<ButtonPattern>());
1760     child->GetOrCreateFocusHub();
1761     child2->GetOrCreateFocusHub();
1762     frameNode->AddChild(child);
1763     frameNode->AddChild(child2);
1764     auto eventHub = AceType::MakeRefPtr<EventHub>();
1765     eventHub->AttachHost(frameNode);
1766     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1767     focusHub->currentFocus_ = true;
1768     std::list<RefPtr<FocusHub>> focusNodes;
1769     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1770     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1771     EXPECT_TRUE(focusHub->IsFocusableScopeByTab());
1772 }
1773 
1774 /**
1775  * @tc.name: FocusHubTestNg0038
1776  * @tc.desc: Test the function IsCurrentFocusWholePath.
1777  * @tc.type: FUNC
1778  */
1779 HWTEST_F(FocusHubTestNg, FocusHubTestNg0038, TestSize.Level1)
1780 {
1781     /**
1782      * @tc.steps: step1. Create frameNode.
1783      */
1784     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1785         AceType::MakeRefPtr<Pattern>());
1786     auto eventHub = AceType::MakeRefPtr<EventHub>();
1787     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1788     ASSERT_NE(focusHub, nullptr);
1789     EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1790     focusHub->currentFocus_ = true;
1791     EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1792     focusHub->focusType_ = FocusType::NODE;
1793     EXPECT_TRUE(focusHub->IsCurrentFocusWholePath());
1794     focusHub->focusType_ = FocusType::SCOPE;
1795     EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1796 }
1797 
1798 /**
1799  * @tc.name: FocusHubTestNg0039
1800  * @tc.desc: Test the function DumpFocusTree.
1801  * @tc.type: FUNC
1802  */
1803 HWTEST_F(FocusHubTestNg, FocusHubTestNg0039, TestSize.Level1)
1804 {
1805     /**
1806      * @tc.steps: step1. Create frameNode.
1807      */
1808     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1809         AceType::MakeRefPtr<Pattern>());
1810     auto eventHub = AceType::MakeRefPtr<EventHub>();
1811     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1812     ASSERT_NE(focusHub, nullptr);
1813     int32_t depth = 1;
1814     focusHub->focusType_ = FocusType::DISABLE;
1815     focusHub->DumpFocusTree(depth);
1816 }
1817 
1818 /**
1819  * @tc.name: FocusHubTestNg0040
1820  * @tc.desc: Test the function AcceptFocusOfLastFocus and AcceptFocusByRectOfLastFocus.
1821  * @tc.type: FUNC
1822  */
1823 HWTEST_F(FocusHubTestNg, FocusHubTestNg0040, TestSize.Level1)
1824 {
1825     /**
1826      * @tc.steps: step1. Create frameNode.
1827      */
1828     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1829         AceType::MakeRefPtr<Pattern>());
1830     auto eventHub = AceType::MakeRefPtr<EventHub>();
1831     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1832     ASSERT_NE(focusHub, nullptr);
1833     RectF childRect;
1834     focusHub->focusType_ = FocusType::SCOPE;
1835     EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1836     EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1837     focusHub->focusType_ = FocusType::NODE;
1838     EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1839     EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1840     focusHub->focusType_ = FocusType::DISABLE;
1841     EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1842     EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1843 }
1844 
1845 /**
1846  * @tc.name: FocusHubTestNg0041
1847  * @tc.desc: Test the function SetShow, SetEnabled, SetEnabledNode and SetEnabledScope.
1848  * @tc.type: FUNC
1849  */
1850 HWTEST_F(FocusHubTestNg, FocusHubTestNg0041, TestSize.Level1)
1851 {
1852     /**
1853      * @tc.steps: step1. Create frameNode.
1854      */
1855     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1856         AceType::MakeRefPtr<Pattern>());
1857     auto eventHub = AceType::MakeRefPtr<EventHub>();
1858     eventHub->AttachHost(frameNode);
1859     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1860     ASSERT_NE(focusHub, nullptr);
1861     auto frameNode_test = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_COMPONENT_TAG, -1,
1862         AceType::MakeRefPtr<Pattern>());
1863     frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode_test));
1864     AceType::DynamicCast<FrameNodeOnTree>(frameNode->GetParent())
1865         ->GetLayoutProperty()
1866         ->UpdateVisibility(VisibleType::INVISIBLE);
1867     focusHub->IsShow();
1868 }
1869 
1870 /**
1871  * @tc.name: FocusHubTestNg0042
1872  * @tc.desc: Test the function OnClick.
1873  * @tc.type: FUNC
1874  */
1875 HWTEST_F(FocusHubTestNg, FocusHubTestNg0042, TestSize.Level1)
1876 {
1877     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1878         AceType::MakeRefPtr<Pattern>());
1879     auto eventHub = AceType::MakeRefPtr<EventHub>();
1880     eventHub->AttachHost(frameNode);
1881     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1882     ASSERT_NE(focusHub, nullptr);
1883     KeyEvent keyEvent;
__anonc1fb89a81302(GestureEvent&) 1884     focusHub->SetOnClickCallback([](GestureEvent&) { return; });
1885     focusHub->OnClick(keyEvent);
1886 }
1887 
1888 /**
1889  * @tc.name: HasBackwardFocusMovementInChildren001
1890  * @tc.desc: Test the function HasBackwardFocusMovementInChildren.
1891  * @tc.type: FUNC
1892  */
1893 HWTEST_F(FocusHubTestNg, HasBackwardFocusMovementInChildren001, TestSize.Level1)
1894 {
1895     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1896     auto eventHub = AceType::MakeRefPtr<EventHub>();
1897     eventHub->AttachHost(frameNode);
1898     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1899     ASSERT_NE(focusHub, nullptr);
1900     KeyEvent keyEvent;
1901     ASSERT_FALSE(focusHub->HasBackwardFocusMovementInChildren());
1902 }
1903 
1904 /**
1905  * @tc.name: HasForwardFocusMovementInChildren001
1906  * @tc.desc: Test the function HasForwardFocusMovementInChildren.
1907  * @tc.type: FUNC
1908  */
1909 HWTEST_F(FocusHubTestNg, HasForwardFocusMovementInChildren001, TestSize.Level1)
1910 {
1911     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1912     auto eventHub = AceType::MakeRefPtr<EventHub>();
1913     eventHub->AttachHost(frameNode);
1914     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1915     ASSERT_NE(focusHub, nullptr);
1916     KeyEvent keyEvent;
1917     ASSERT_FALSE(focusHub->HasForwardFocusMovementInChildren());
1918 }
1919 
1920 /**
1921  * @tc.name: ClearFocusMovementFlagsInChildren001
1922  * @tc.desc: Test the function ClearFocusMovementFlagsInChildren.
1923  * @tc.type: FUNC
1924  */
1925 HWTEST_F(FocusHubTestNg, ClearFocusMovementFlagsInChildren001, TestSize.Level1)
1926 {
1927     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1928     auto eventHub = AceType::MakeRefPtr<EventHub>();
1929     eventHub->AttachHost(frameNode);
1930     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1931     ASSERT_NE(focusHub, nullptr);
1932     KeyEvent keyEvent;
1933     ASSERT_FALSE(focusHub->HasBackwardFocusMovement());
1934 }
1935 
1936 /**
1937  * @tc.name: SetLastWeakFocusToPreviousInFocusView001
1938  * @tc.desc: Test the function SetLastWeakFocusToPreviousInFocusView.
1939  * @tc.type: FUNC
1940  */
1941 HWTEST_F(FocusHubTestNg, SetLastWeakFocusToPreviousInFocusView001, TestSize.Level1)
1942 {
1943     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1944     auto eventHub = AceType::MakeRefPtr<EventHub>();
1945     eventHub->AttachHost(frameNode);
1946     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1947     ASSERT_NE(focusHub, nullptr);
1948     KeyEvent keyEvent;
1949     focusHub->SetLastWeakFocusToPreviousInFocusView();
1950     ASSERT_FALSE(focusHub->lastWeakFocusNode_.Upgrade());
1951 }
1952 } // namespace OHOS::Ace::NG
1953