1 /*
2  * Copyright (c) 2024 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 {
21 /**
22  * @tc.name: FocusHubTestNg0044
23  * @tc.desc: Test the function TryRequestFocus.
24  * @tc.type: FUNC
25  */
26 HWTEST_F(FocusHubTestNg, FocusHubTestNg0044, TestSize.Level1)
27 {
28     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
29         AceType::MakeRefPtr<Pattern>());
30     auto frameNode2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_COMPONENT_TAG, -1,
31         AceType::MakeRefPtr<Pattern>());
32     auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1,
33         AceType::MakeRefPtr<FlexLayoutPattern>());
34     frameNode->GetOrCreateFocusHub();
35     frameNode2->GetOrCreateFocusHub();
36     nodeParent->GetOrCreateFocusHub();
37     frameNode->SetParent(nodeParent);
38     frameNode2->SetParent(nodeParent);
39 
40     auto eventHub = AceType::MakeRefPtr<EventHub>();
41     eventHub->AttachHost(frameNode);
42     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
43     auto parent = focusHub->GetParentFocusHub();
44     RectF childRect;
45     parent->focusType_ = FocusType::SCOPE;
46     parent->TryRequestFocus(focusHub, childRect, FocusStep::TAB);
47 
48     parent->focusType_ = FocusType::SCOPE;
49     childRect.width_ = -1;
50     focusHub->GetGeometryNode() = AceType::MakeRefPtr<GeometryNode>();
51     parent->TryRequestFocus(focusHub, childRect, FocusStep::NONE);
52 }
53 
54 /**
55  * @tc.name: FocusHubTestNg0046
56  * @tc.desc: Test the function TriggerFocusScroll.
57  * @tc.type: FUNC
58  */
59 HWTEST_F(FocusHubTestNg, FocusHubTestNg0046, TestSize.Level1)
60 {
61     /**
62      * @tc.steps: step1. Create frameNode.
63      */
64     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
65         AceType::MakeRefPtr<Pattern>());    auto eventHub = AceType::MakeRefPtr<EventHub>();
66     eventHub->AttachHost(frameNode);
67     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
68     ASSERT_NE(focusHub, nullptr);
69     auto context = PipelineContext::GetCurrentContext();
70     ASSERT_NE(context, nullptr);
71     context->isFocusActive_ = true;
72     focusHub->isFocusUnit_ = true;
73     auto parentNode = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1,
74         AceType::MakeRefPtr<Pattern>());
75     auto parentFocusHub = parentNode->GetOrCreateFocusHub();
76     parentFocusHub->focusType_ = FocusType::SCOPE;
77     frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode));
__anon70c353110102() 78     focusHub->onPaintFocusStateCallback_ = []() { return true; };
79     focusHub->PaintAllFocusState();
80     focusHub->TriggerFocusScroll();
81     focusHub->focusType_ = FocusType::DISABLE;
82     focusHub->isFocusUnit_ = false;
83     focusHub->TriggerFocusScroll();
84     EXPECT_FALSE(focusHub->isFocusUnit_);
85 }
86 
87 /**
88  * @tc.name: FocusHubTestNg0048
89  * @tc.desc: Test the function ClearFocusState.
90  * @tc.type: FUNC
91  */
92 HWTEST_F(FocusHubTestNg, FocusHubTestNg0048, TestSize.Level1)
93 {
94     /**
95      * @tc.steps: step1. Create frameNode.
96      */
97     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
98     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
99     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
100     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
101         AceType::MakeRefPtr<Pattern>());
102     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
103         AceType::MakeRefPtr<ButtonPattern>());
104     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
105         AceType::MakeRefPtr<ButtonPattern>());
106     child->GetOrCreateFocusHub();
107     child2->GetOrCreateFocusHub();
108     frameNode->AddChild(child);
109     frameNode->AddChild(child2);
110     auto eventHub = AceType::MakeRefPtr<EventHub>();
111     eventHub->AttachHost(frameNode);
112     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
113     auto context = PipelineContext::GetCurrentContext();
114     ASSERT_NE(context, nullptr);
115     RoundRect focusRectInner;
116     context->isFocusActive_ = true;
117     focusHub->focusType_ = FocusType::NODE;
118     EXPECT_FALSE(focusHub->PaintInnerFocusState(focusRectInner));
119     focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
120     std::list<RefPtr<FocusHub>> focusNodes;
121     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
122     EXPECT_EQ(itNewFocusNode, focusNodes.end());
123     EXPECT_TRUE(focusHub->PaintInnerFocusState(focusRectInner));
124     focusHub->focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
125     focusHub->focusPaintParamsPtr_->paintColor = Color::RED;
126     focusHub->focusPaintParamsPtr_->paintWidth = Dimension(10);
127     EXPECT_TRUE(focusHub->PaintInnerFocusState(focusRectInner));
128 }
129 
130 /**
131  * @tc.name: FocusHubTestNg0049
132  * @tc.desc: Test the function PaintFocusState.
133  * @tc.type: FUNC
134  */
135 HWTEST_F(FocusHubTestNg, FocusHubTestNg0049, TestSize.Level1)
136 {
137     /**
138      * @tc.steps: step1. Create frameNode.
139      */
140     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
141     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
142     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
143     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
144         AceType::MakeRefPtr<Pattern>());
145     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
146         AceType::MakeRefPtr<ButtonPattern>());
147     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
148         AceType::MakeRefPtr<ButtonPattern>());
149     child->GetOrCreateFocusHub();
150     child2->GetOrCreateFocusHub();
151     frameNode->AddChild(child);
152     frameNode->AddChild(child2);
153     auto eventHub = AceType::MakeRefPtr<EventHub>();
154     eventHub->AttachHost(frameNode);
155     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
156     auto context = PipelineContext::GetCurrentContext();
157     ASSERT_NE(context, nullptr);
158     context->isFocusActive_ = true;
159     focusHub->focusType_ = FocusType::NODE;
160     std::list<RefPtr<FocusHub>> focusNodes;
161     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
162     EXPECT_EQ(itNewFocusNode, focusNodes.end());
163     focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
164     RoundRect paintRect;
__anon70c353110202(RoundRect) 165     focusHub->getInnerFocusRectFunc_ = [](RoundRect) {};
166     EXPECT_FALSE(focusHub->PaintFocusState());
167     focusHub->focusStyleType_ = FocusStyleType::CUSTOM_BORDER;
168     EXPECT_FALSE(focusHub->PaintFocusState());
169     focusHub->focusPaintParamsPtr_ = std::make_unique<FocusPaintParam>();
170     focusHub->focusPaintParamsPtr_->paintColor = Color::RED;
171     focusHub->focusPaintParamsPtr_->paintWidth = Dimension(10);
172     focusHub->focusPaintParamsPtr_->paintRect = RoundRect(RectF(), 0.0f, 0.0f);
173     EXPECT_TRUE(focusHub->PaintFocusState());
174     focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
175     EXPECT_TRUE(focusHub->PaintFocusState());
176     focusHub->focusStyleType_ = FocusStyleType::INNER_BORDER;
177     EXPECT_TRUE(focusHub->PaintFocusState());
178     focusHub->focusPaintParamsPtr_->focusPadding = Dimension(10);
179     EXPECT_TRUE(focusHub->PaintFocusState());
180 }
181 
182 /**
183  * @tc.name: FocusHubTestNg0050
184  * @tc.desc: Test the function ScrollToLastFocusIndex.
185  * @tc.type: FUNC
186  */
187 HWTEST_F(FocusHubTestNg, FocusHubTestNg0050, TestSize.Level1)
188 {
189     /**
190      * @tc.steps: step1. Create frameNode.
191      */
192     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
193         AceType::MakeRefPtr<Pattern>());
194     auto eventHub = AceType::MakeRefPtr<EventHub>();
195     eventHub->AttachHost(frameNode);
196     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
197     ASSERT_NE(focusHub, nullptr);
198     focusHub->currentFocus_ = true;
199     auto parentNode = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1,
200         AceType::MakeRefPtr<Pattern>());
201     auto parentFocusHub = parentNode->GetOrCreateFocusHub();
202     parentFocusHub->focusType_ = FocusType::SCOPE;
203     frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode));
204     focusHub->SetLastFocusNodeIndex(focusHub);
205     focusHub->ScrollToLastFocusIndex();
206     focusHub->lastFocusNodeIndex_ = 1;
207     focusHub->ScrollToLastFocusIndex();
208     EXPECT_NE(focusHub->focusType_, FocusType::SCOPE);
209 }
210 
211 /**
212  * @tc.name: FocusHubTestNg0051
213  * @tc.desc: Test the function RequestFocus.
214  * @tc.type: FUNC
215  */
216 HWTEST_F(FocusHubTestNg, FocusHubTestNg0051, TestSize.Level1)
217 {
218     /**
219      * @tc.steps: step1. Create frameNode.
220      */
221     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
222         AceType::MakeRefPtr<Pattern>());
223     auto eventHub = AceType::MakeRefPtr<EventHub>();
224     eventHub->AttachHost(frameNode);
225     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
226     ASSERT_NE(focusHub, nullptr);
227     focusHub->RequestFocus();
228     focusHub->currentFocus_ = true;
229     focusHub->RequestFocus();
230     EXPECT_TRUE(focusHub->currentFocus_);
231 }
232 
233 /**
234  * @tc.name: FocusHubTestNg0052
235  * @tc.desc: Test the function FocusToHeadOrTailChild.
236  * @tc.type: FUNC
237  */
238 HWTEST_F(FocusHubTestNg, FocusHubTestNg0052, TestSize.Level1)
239 {
240     /**
241      * @tc.steps: step1. Create frameNode.
242      */
243     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
244         AceType::MakeRefPtr<Pattern>());
245     auto eventHub = AceType::MakeRefPtr<EventHub>();
246     eventHub->AttachHost(frameNode);
247     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
248     focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
249     std::list<RefPtr<FocusHub>> focusNodes;
250     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
251     EXPECT_EQ(itNewFocusNode, focusNodes.end());
252     auto parentNode = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1,
253         AceType::MakeRefPtr<Pattern>());
254     auto parentFocusHub = parentNode->GetOrCreateFocusHub();
255     parentFocusHub->focusType_ = FocusType::SCOPE;
256     frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(parentNode));
257     focusHub->focusType_ = FocusType::NODE;
258     EXPECT_FALSE(focusHub->FocusToHeadOrTailChild(true));
259     focusHub->focusType_ = FocusType::SCOPE;
260     EXPECT_FALSE(focusHub->FocusToHeadOrTailChild(false));
261 }
262 
263 /**
264  * @tc.name: FocusHubTestNg0054
265  * @tc.desc: Test the function GoToNextFocusLinear.
266  * @tc.type: FUNC
267  */
268 HWTEST_F(FocusHubTestNg, FocusHubTestNg0054, TestSize.Level1)
269 {
270     /**
271      * @tc.steps: step1. Create frameNode.
272      */
273     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
274         AceType::MakeRefPtr<Pattern>());
275     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
276         AceType::MakeRefPtr<ButtonPattern>());
277     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
278         AceType::MakeRefPtr<ButtonPattern>());
279     child->GetOrCreateFocusHub();
280     child2->GetOrCreateFocusHub();
281     frameNode->AddChild(child);
282     frameNode->AddChild(child2);
283     auto eventHub = AceType::MakeRefPtr<EventHub>();
284     eventHub->AttachHost(frameNode);
285     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
286     focusHub->currentFocus_ = true;
287     std::list<RefPtr<FocusHub>> focusNodes;
288     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
289     EXPECT_EQ(itNewFocusNode, focusNodes.end());
290     EXPECT_FALSE(focusHub->GoToNextFocusLinear(FocusStep::LEFT));
291 }
292 
293 /**
294  * @tc.name: FocusHubTestNg0056
295  * @tc.desc: Test the function RequestNextFocus.
296  * @tc.type: FUNC
297  */
298 HWTEST_F(FocusHubTestNg, FocusHubTestNg0056, TestSize.Level1)
299 {
300     /**
301      * @tc.steps: step1. Create frameNode.
302      */
303     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
304         AceType::MakeRefPtr<Pattern>());
305     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
306         AceType::MakeRefPtr<ButtonPattern>());
307     child->GetOrCreateFocusHub();
308     frameNode->AddChild(child);
309     auto eventHub = AceType::MakeRefPtr<EventHub>();
310     auto eventHub1 = AceType::MakeRefPtr<EventHub>();
311     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
312     auto focusHub1 = AceType::MakeRefPtr<FocusHub>(eventHub1);
313     RectF childRect;
314     std::list<RefPtr<FocusHub>> focusNodes;
315     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
316     EXPECT_EQ(itNewFocusNode, focusNodes.end());
317     focusHub->focusAlgorithm_.scopeType = ScopeType::PROJECT_AREA;
318     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
319     EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::LEFT, childRect));
320     EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::SHIFT_TAB, childRect));
__anon70c353110302(FocusStep, const WeakPtr<FocusHub>&, WeakPtr<FocusHub>&) 321     focusHub->focusAlgorithm_.getNextFocusNode = [](FocusStep, const WeakPtr<FocusHub>&, WeakPtr<FocusHub>&) {};
322     EXPECT_FALSE(focusHub->RequestNextFocus(FocusStep::TAB, childRect));
323 }
324 
325 /**
326  * @tc.name: FocusHubTestNg0057
327  * @tc.desc: Test the function GetNearestNodeByProjectArea.
328  * @tc.type: FUNC
329  */
330 HWTEST_F(FocusHubTestNg, FocusHubTestNg0057, TestSize.Level1)
331 {
332     /**
333      * @tc.steps: step1. Create frameNode.
334      */
335     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
336         AceType::MakeRefPtr<Pattern>());
337     auto frameNode2 = FrameNodeOnTree::CreateFrameNode(V2::ROW_ETS_TAG, 1, AceType::MakeRefPtr<Pattern>());
338     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
339         AceType::MakeRefPtr<ButtonPattern>());
340     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
341         AceType::MakeRefPtr<ButtonPattern>());
342     child->GetOrCreateFocusHub();
343     child2->GetOrCreateFocusHub();
344     frameNode->AddChild(child);
345     frameNode->AddChild(child2);
346     auto eventHub = AceType::MakeRefPtr<EventHub>();
347     auto eventHub2 = AceType::MakeRefPtr<EventHub>();
348     eventHub->AttachHost(frameNode);
349     eventHub2->AttachHost(frameNode2);
350     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
351     auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub2);
352     focusHub->currentFocus_ = true;
353     std::list<RefPtr<FocusHub>> focusNodes;
354     focusNodes.emplace_back(focusHub2);
355     EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::NONE), nullptr);
356     EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::TAB), nullptr);
357     EXPECT_EQ(focusHub->GetNearestNodeByProjectArea(focusNodes, FocusStep::SHIFT_TAB), nullptr);
358 }
359 
360 /**
361  * @tc.name: FocusHubTestNg058
362  * @tc.desc: Test the function HandleFocusByTabIndex.
363  * @tc.type: FUNC
364  */
365 HWTEST_F(FocusHubTestNg, FocusHubTestNg0058, TestSize.Level1)
366 {
367     /**
368      * @tc.steps1: initialize parameters.
369      */
370     auto eventHub = AceType::MakeRefPtr<EventHub>();
371     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
372     KeyEvent keyEvent;
373     TabIndexNodeList tabIndexNodes;
374     keyEvent.action = KeyAction::DOWN;
375     keyEvent.code = KeyCode::KEY_TAB;
376     focusHub->currentFocus_ = true;
377     EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
378 }
379 
380 /**
381  * @tc.name: FocusHubTestNg059
382  * @tc.desc: Test the function HandleFocusByTabIndex.
383  * @tc.type: FUNC
384  */
385 HWTEST_F(FocusHubTestNg, FocusHubTestNg0059, TestSize.Level1)
386 {
387     /**
388      * @tc.steps1: create focusHub and construct allNodes.
389      */
390     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101, AceType::MakeRefPtr<ButtonPattern>());
391     frameNode->GetOrCreateFocusHub();
392     auto focusHub = frameNode->GetFocusHub();
393     frameNode->geometryNode_->SetFrameSize(SizeF(20, 20));
394     frameNode->geometryNode_->SetFrameOffset(OffsetF(20, 20));
395     ASSERT_NE(focusHub, nullptr);
396     std::list<RefPtr<FocusHub>> allNodes;
397 
398     auto focus1 = AceType::MakeRefPtr<FocusHub>(AceType::WeakClaim<EventHub>(nullptr), FocusType::NODE, true);
399 
400     auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode2", 102,
401         AceType::MakeRefPtr<ButtonPattern>());
402     frameNode2->GetOrCreateFocusHub();
403     auto focusHub2 = frameNode2->GetFocusHub();
404     frameNode2->geometryNode_->SetFrameOffset(OffsetF(15, 15));
405     frameNode2->geometryNode_->SetFrameSize(SizeF(30, 30));
406 
407     auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode3", 103,
408         AceType::MakeRefPtr<ButtonPattern>());
409     frameNode3->GetOrCreateFocusHub();
410     auto focusHub3 = frameNode3->GetFocusHub();
411     frameNode3->geometryNode_->SetFrameOffset(OffsetF(20, 20));
412     frameNode3->geometryNode_->SetFrameSize(SizeF(30, 30));
413 
414     auto frameNode4 = FrameNodeOnTree::CreateFrameNode("frameNode4", 104,
415         AceType::MakeRefPtr<ButtonPattern>());
416     frameNode4->GetOrCreateFocusHub();
417     auto focusHub4 = frameNode4->GetFocusHub();
418     frameNode4->geometryNode_->SetFrameOffset(OffsetF(10, 20));
419     frameNode4->geometryNode_->SetFrameSize(SizeF(20, 20));
420 
421     auto frameNode5 = FrameNodeOnTree::CreateFrameNode("frameNode5", 105,
422         AceType::MakeRefPtr<ButtonPattern>());
423     frameNode5->GetOrCreateFocusHub();
424     auto focusHub5 = frameNode5->GetFocusHub();
425     frameNode5->geometryNode_->SetFrameOffset(OffsetF(20, 20));
426     frameNode5->geometryNode_->SetFrameSize(SizeF(30, 30));
427 
428     allNodes.push_back(nullptr);
429     allNodes.push_back(focus1);
430     allNodes.push_back(focusHub);
431     allNodes.push_back(focusHub2);
432     allNodes.push_back(focusHub3);
433     allNodes.push_back(focusHub4);
434     allNodes.push_back(focusHub5);
435 
436     auto res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::UP);
437     ASSERT_NE(res, nullptr);
438     res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::DOWN);
439     ASSERT_NE(res, nullptr);
440     res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::LEFT);
441     ASSERT_NE(res, nullptr);
442     res = focusHub->GetNearestNodeByProjectArea(allNodes, FocusStep::RIGHT);
443     ASSERT_NE(res, nullptr);
444 }
445 
446 /**
447  * @tc.name: FocusHubTestNg064
448  * @tc.desc: Test the function CollectTabIndexNodes.
449  * @tc.type: FUNC
450  */
451 HWTEST_F(FocusHubTestNg, FocusHubTestNg0064, TestSize.Level1)
452 {
453     /**
454      * @tc.steps1: create focusHub and construct allNodes.
455      */
456     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
457         AceType::MakeRefPtr<ButtonPattern>());
458     frameNode->GetOrCreateFocusHub();
459     auto focusHub = frameNode->GetFocusHub();
460     ASSERT_NE(focusHub, nullptr);
461 
462     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
463         AceType::MakeRefPtr<ButtonPattern>());
464     frameNode1->GetOrCreateFocusHub();
465     auto focusHub1 = frameNode1->GetFocusHub();
466 
467     frameNode->children_.push_back(frameNode1);
468     focusHub->focusable_ = true;
469     focusHub->parentFocusable_ = true;
470     focusHub->focusType_ = FocusType::SCOPE;
471 
472     focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
473     focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
474     focusHub1->focusable_ = true;
475     focusHub1->parentFocusable_ = true;
476     focusHub1->focusType_ = FocusType::NODE;
477     focusHub1->focusCallbackEvents_->tabIndex_ = 1;
478 
479     TabIndexNodeList list;
480     focusHub->CollectTabIndexNodes(list);
481     ASSERT_FALSE(list.empty());
482 
483     focusHub->focusCallbackEvents_->tabIndex_ = 1;
484     focusHub->CollectTabIndexNodes(list);
485     ASSERT_FALSE(list.empty());
486 }
487 
488 /**
489  * @tc.name: FocusHubTestNg067
490  * @tc.desc: Test the function GetChildFocusNodeByType.
491  * @tc.type: FUNC
492  */
493 HWTEST_F(FocusHubTestNg, FocusHubTestNg0067, TestSize.Level1)
494 {
495     /**
496      * @tc.steps1: create focusHub and construct allNodes.
497      */
498     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
499         AceType::MakeRefPtr<ButtonPattern>());
500     frameNode->GetOrCreateFocusHub();
501     auto focusHub = frameNode->GetFocusHub();
502     ASSERT_NE(focusHub, nullptr);
503 
504     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
505         AceType::MakeRefPtr<ButtonPattern>());
506     frameNode1->GetOrCreateFocusHub();
507     auto focusHub1 = frameNode1->GetFocusHub();
508 
509     auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
510         AceType::MakeRefPtr<ButtonPattern>());
511     frameNode2->GetOrCreateFocusHub();
512     auto focusHub2 = frameNode2->GetFocusHub();
513 
514     auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
515         AceType::MakeRefPtr<ButtonPattern>());
516     frameNode3->GetOrCreateFocusHub();
517     auto focusHub3 = frameNode3->GetFocusHub();
518 
519     focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
520     focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
521     focusHub3->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
522 
523     focusHub3->focusCallbackEvents_->isDefaultGroupFocus_ = false;
524     focusHub1->focusCallbackEvents_->isDefaultGroupFocus_ = true;
525 
526     focusHub->focusType_ = FocusType::SCOPE;
527     frameNode->children_.push_back(frameNode3);
528     frameNode->children_.push_back(frameNode1);
529 
530     auto res = focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT);
531     ASSERT_NE(res, nullptr);
532 }
533 
534 /**
535  * @tc.name: FocusHubTestNg068
536  * @tc.desc: Test the function GoToFocusByTabNodeIdx.
537  * @tc.type: FUNC
538  */
539 HWTEST_F(FocusHubTestNg, FocusHubTestNg0068, TestSize.Level1)
540 {
541     /**
542      * @tc.steps1: create focusHub and construct allNodes.
543      */
544     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
545         AceType::MakeRefPtr<ButtonPattern>());
546     frameNode->GetOrCreateFocusHub();
547     auto focusHub = frameNode->GetFocusHub();
548     ASSERT_NE(focusHub, nullptr);
549 
550     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
551         AceType::MakeRefPtr<ButtonPattern>());
552     frameNode1->GetOrCreateFocusHub();
553     auto focusHub1 = frameNode1->GetFocusHub();
554 
555     auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
556         AceType::MakeRefPtr<ButtonPattern>());
557     frameNode2->GetOrCreateFocusHub();
558     auto focusHub2 = frameNode2->GetFocusHub();
559 
560     auto frameNode3 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
561         AceType::MakeRefPtr<ButtonPattern>());
562     frameNode3->GetOrCreateFocusHub();
563     auto focusHub3 = frameNode3->GetFocusHub();
564 
565     auto frameNode4 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
566         AceType::MakeRefPtr<ButtonPattern>());
567     frameNode4->GetOrCreateFocusHub();
568     auto focusHub4 = frameNode4->GetFocusHub();
569 
570     focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
571     focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
572     focusHub3->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
573     focusHub4->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
574 
575     frameNode4->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode2));
576     focusHub1->focusType_ = FocusType::SCOPE;
577     focusHub2->focusType_ = FocusType::SCOPE;
578     focusHub3->focusCallbackEvents_->isDefaultGroupFocus_ = true;
579     focusHub4->focusCallbackEvents_->isDefaultGroupFocus_ = true;
580     focusHub2->focusable_ = false;
581 
582     frameNode1->children_.push_back(frameNode3);
583     frameNode2->children_.push_back(frameNode4);
584 
585     TabIndexNodeList list;
586     list.push_back({1, AceType::WeakClaim(AceType::RawPtr(focusHub1))});
587     list.push_back({2, AceType::WeakClaim(AceType::RawPtr(focusHub2))});
588 
589     focusHub->focusType_ = FocusType::SCOPE;
590     auto res = focusHub->GoToFocusByTabNodeIdx(list, 0);
591     ASSERT_TRUE(res);
592     res = focusHub->GoToFocusByTabNodeIdx(list, 1);
593     ASSERT_FALSE(res);
594 }
595 
596 /**
597  * @tc.name: FocusHubTestNg069
598  * @tc.desc: Test the function CollectTabIndexNodes.
599  * @tc.type: FUNC
600  */
601 HWTEST_F(FocusHubTestNg, FocusHubTestNg0069, TestSize.Level1)
602 {
603     /**
604      * @tc.steps1: create focusHub and construct allNodes.
605      */
606     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
607         AceType::MakeRefPtr<ButtonPattern>());
608     frameNode->GetOrCreateFocusHub();
609     auto focusHub = frameNode->GetFocusHub();
610     ASSERT_NE(focusHub, nullptr);
611 
612     focusHub->focusable_ = false;
613     focusHub->focusType_ = FocusType::SCOPE;
614     TabIndexNodeList list;
615     focusHub->CollectTabIndexNodes(list);
616     ASSERT_TRUE(list.empty());
617 }
618 
619 /**
620  * @tc.name: FocusHubTestNg070
621  * @tc.desc: Test the function IsFocusableWholePath.
622  * @tc.type: FUNC
623  */
624 HWTEST_F(FocusHubTestNg, FocusHubTestNg0070, TestSize.Level1)
625 {
626     /**
627      * @tc.steps1: create focusHub and construct allNodes.
628      */
629     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
630         AceType::MakeRefPtr<ButtonPattern>());
631     frameNode->GetOrCreateFocusHub();
632     auto focusHub = frameNode->GetFocusHub();
633     ASSERT_NE(focusHub, nullptr);
634 
635     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
636         AceType::MakeRefPtr<ButtonPattern>());
637     frameNode1->GetOrCreateFocusHub();
638     auto focusHub1 = frameNode1->GetFocusHub();
639 
640     focusHub->focusType_ = FocusType::SCOPE;
641     frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
642     frameNode->children_.push_back(frameNode1);
643 
644     ASSERT_TRUE(focusHub->IsFocusableNode());
645     ASSERT_TRUE(focusHub->IsFocusableScope());
646     auto res = focusHub1->IsFocusableWholePath();
647     ASSERT_TRUE(res);
648 }
649 
650 /**
651  * @tc.name: FocusHubTestNg071
652  * @tc.desc: Test the function IsFocusableScopeByTab.
653  * @tc.type: FUNC
654  */
655 HWTEST_F(FocusHubTestNg, FocusHubTestNg0071, TestSize.Level1)
656 {
657     /**
658      * @tc.steps1: create focusHub and construct allNodes.
659      */
660     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
661         AceType::MakeRefPtr<ButtonPattern>());
662     frameNode->GetOrCreateFocusHub();
663     auto focusHub = frameNode->GetFocusHub();
664     ASSERT_NE(focusHub, nullptr);
665 
666     focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
667     focusHub->focusCallbackEvents_->tabIndex_ = 1;
668 
669     auto res = focusHub->IsFocusableScopeByTab();
670     ASSERT_FALSE(res);
671 }
672 
673 /**
674  * @tc.name: FocusHubTestNg072
675  * @tc.desc: Test the function AcceptFocusOfSpecifyChild.
676  * @tc.type: FUNC
677  */
678 HWTEST_F(FocusHubTestNg, FocusHubTestNg0072, TestSize.Level1)
679 {
680     /**
681      * @tc.steps1: create focusHub and construct allNodes.
682      */
683     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
684         AceType::MakeRefPtr<ButtonPattern>());
685     frameNode->GetOrCreateFocusHub();
686     auto focusHub = frameNode->GetFocusHub();
687     ASSERT_NE(focusHub, nullptr);
688 
689     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
690         AceType::MakeRefPtr<ButtonPattern>());
691     frameNode1->GetOrCreateFocusHub();
692     auto focusHub1 = frameNode1->GetFocusHub();
693 
694     auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
695         AceType::MakeRefPtr<ButtonPattern>());
696     frameNode2->GetOrCreateFocusHub();
697     auto focusHub2 = frameNode2->GetFocusHub();
698 
699     focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
700     focusHub2->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
701 
702     focusHub->focusType_ = FocusType::SCOPE;
703     focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
704     frameNode->children_.push_back(frameNode1);
705     frameNode->children_.push_back(frameNode2);
706     focusHub1->focusable_ = false;
707     auto res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
708     ASSERT_TRUE(res);
709     res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB);
710     ASSERT_TRUE(res);
711     res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::DOWN);
712     ASSERT_FALSE(res);
713     focusHub2->focusable_ = false;
714     res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB);
715     ASSERT_FALSE(res);
716     res = focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
717     ASSERT_FALSE(res);
718 }
719 
720 /**
721  * @tc.name: FocusHubTestNg073
722  * @tc.desc: Test the function ClearAllFocusState.
723  * @tc.type: FUNC
724  */
725 HWTEST_F(FocusHubTestNg, FocusHubTestNg0073, TestSize.Level1)
726 {
727     /**
728      * @tc.steps1: create focusHub and construct allNodes.
729      */
730     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
731         AceType::MakeRefPtr<ButtonPattern>());
732     frameNode->GetOrCreateFocusHub();
733     auto focusHub = frameNode->GetFocusHub();
734     ASSERT_NE(focusHub, nullptr);
735 
736     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
737         AceType::MakeRefPtr<ButtonPattern>());
738     frameNode1->GetOrCreateFocusHub();
739     auto focusHub1 = frameNode1->GetFocusHub();
740 
741     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
742     focusHub->ClearAllFocusState();
743     ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
744 
745     /**
746      * @tc.steps: step1. Create frameNode.
747      */
748     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
749     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
750     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
751 }
752 
753 /**
754  * @tc.name: FocusHubTestNg074
755  * @tc.desc: Test the function PaintAllFocusState.
756  * @tc.type: FUNC
757  */
758 HWTEST_F(FocusHubTestNg, FocusHubTestNg0074, TestSize.Level1)
759 {
760     /**
761      * @tc.steps1: create focusHub and construct allNodes.
762      */
763     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
764     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
765     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
766     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
767         AceType::MakeRefPtr<ButtonPattern>());
768     frameNode->GetOrCreateFocusHub();
769     auto focusHub = frameNode->GetFocusHub();
770     ASSERT_NE(focusHub, nullptr);
771     auto context = PipelineContext::GetCurrentContext();
772     context->isFocusActive_ = true;
773 
774     focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
775     auto res = focusHub->PaintAllFocusState();
776     ASSERT_TRUE(res);
777 }
778 
779 /**
780  * @tc.name: FocusHubTestNg075
781  * @tc.desc: Test the function PaintFocusState.
782  * @tc.type: FUNC
783  */
784 HWTEST_F(FocusHubTestNg, FocusHubTestNg0075, TestSize.Level1)
785 {
786     /**
787      * @tc.steps1: create focusHub and construct allNodes.
788      */
789     auto themeManager = AceType::MakeRefPtr<MockThemeManager>();
790     MockPipelineContext::GetCurrent()->SetThemeManager(themeManager);
791     EXPECT_CALL(*themeManager, GetTheme(_)).WillRepeatedly(Return(AceType::MakeRefPtr<AppTheme>()));
792     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
793         AceType::MakeRefPtr<ButtonPattern>());
794     frameNode->GetOrCreateFocusHub();
795     auto focusHub = frameNode->GetFocusHub();
796     ASSERT_NE(focusHub, nullptr);
797     auto context = PipelineContext::GetCurrentContext();
798     context->isFocusActive_ = true;
799 
__anon70c353110402(RoundRect& rect) 800     auto func = [](RoundRect& rect) { rect.rect_ = RectF(); };
801     focusHub->getInnerFocusRectFunc_ = func;
802     focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
803     auto res = focusHub->PaintFocusState();
804     ASSERT_TRUE(res);
805 }
806 
807 /**
808  * @tc.name: FocusHubTestNg076
809  * @tc.desc: Test the function OnFocusScope.
810  * @tc.type: FUNC
811  */
812 HWTEST_F(FocusHubTestNg, FocusHubTestNg0076, TestSize.Level1)
813 {
814     /**
815      * @tc.steps1: create focusHub and construct allNodes.
816      */
817     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
818         AceType::MakeRefPtr<ButtonPattern>());
819     frameNode->GetOrCreateFocusHub();
820     auto focusHub = frameNode->GetFocusHub();
821     ASSERT_NE(focusHub, nullptr);
822 
823     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
824         AceType::MakeRefPtr<ButtonPattern>());
825     frameNode1->GetOrCreateFocusHub();
826     auto focusHub1 = frameNode1->GetFocusHub();
827 
828     focusHub1->focusable_ =false;
829     focusHub->focusType_ = FocusType::SCOPE;
830     frameNode->children_.push_back(frameNode1);
831     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
832     focusHub->OnFocusScope();
833     ASSERT_FALSE(focusHub1->focusable_);
834 }
835 
836 /**
837  * @tc.name: FocusHubTestNg077
838  * @tc.desc: Test the function OnFocus.
839  * @tc.type: FUNC
840  */
841 HWTEST_F(FocusHubTestNg, FocusHubTestNg0077, TestSize.Level1)
842 {
843     /**
844      * @tc.steps1: create focusHub and construct allNodes.
845      */
846     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
847         AceType::MakeRefPtr<ButtonPattern>());
848     frameNode->GetOrCreateFocusHub();
849     auto focusHub = frameNode->GetFocusHub();
850     ASSERT_NE(focusHub, nullptr);
851 
852     focusHub->focusType_ = FocusType::DISABLE;
853     focusHub->OnFocus();
854     ASSERT_EQ(focusHub->focusType_, FocusType::DISABLE);
855 }
856 
857 /**
858  * @tc.name: FocusHubTestNg081
859  * @tc.desc: Test the function SwitchFocus.
860  * @tc.type: FUNC
861  */
862 HWTEST_F(FocusHubTestNg, FocusHubTestNg0081, TestSize.Level1)
863 {
864     /**
865      * @tc.steps1: create focusHub and construct allNodes.
866      */
867     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
868         AceType::MakeRefPtr<ButtonPattern>());
869     frameNode->GetOrCreateFocusHub();
870     auto focusHub = frameNode->GetFocusHub();
871     ASSERT_NE(focusHub, nullptr);
872 
873     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
874         AceType::MakeRefPtr<ButtonPattern>());
875     frameNode1->GetOrCreateFocusHub();
876     auto focusHub1 = frameNode1->GetFocusHub();
877 
878     auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
879         AceType::MakeRefPtr<ButtonPattern>());
880     frameNode2->GetOrCreateFocusHub();
881     auto focusHub2 = frameNode2->GetFocusHub();
882 
883     focusHub->currentFocus_ = true;
884     focusHub->focusType_ = FocusType::SCOPE;
885     frameNode->children_.push_back(frameNode1);
886     frameNode->children_.push_back(frameNode2);
887     focusHub->lastWeakFocusNode_ = AceType::WeakClaim<FocusHub>(nullptr);
888     focusHub->SwitchFocus(focusHub2);
889     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
890     focusHub1->currentFocus_ = true;
891     focusHub->SwitchFocus(focusHub2);
892     ASSERT_FALSE(focusHub1->currentFocus_);
893 }
894 
895 /**
896  * @tc.name: FocusHubTestNg083
897  * @tc.desc: Test the function FocusToHeadOrTailChild.
898  * @tc.type: FUNC
899  */
900 HWTEST_F(FocusHubTestNg, FocusHubTestNg0083, TestSize.Level1)
901 {
902     /**
903      * @tc.steps1: create focusHub and construct allNodes.
904      */
905     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
906         AceType::MakeRefPtr<ButtonPattern>());
907     frameNode->GetOrCreateFocusHub();
908     auto focusHub = frameNode->GetFocusHub();
909     ASSERT_NE(focusHub, nullptr);
910 
911     auto res = focusHub->FocusToHeadOrTailChild(true);
912     ASSERT_TRUE(res);
913 }
914 
915 /**
916  * @tc.name: FocusHubTestNg0089
917  * @tc.desc: Test the function IsOnRootTree.
918  * @tc.type: FUNC
919  */
920 HWTEST_F(FocusHubTestNg, FocusHubTestNg0089, TestSize.Level1)
921 {
922     /**
923      * @tc.steps1: create focusHub and parentName != V2::ROOT_ETS_TAG.
924      */
925     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
926         AceType::MakeRefPtr<ButtonPattern>());
927     frameNode->GetOrCreateFocusHub();
928     auto focusHub = frameNode->GetFocusHub();
929     ASSERT_NE(focusHub, nullptr);
930     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
931         AceType::MakeRefPtr<ButtonPattern>());
932     frameNode1->GetOrCreateFocusHub();
933     auto focusHub1 = frameNode1->GetFocusHub();
934     focusHub->focusType_ = FocusType::SCOPE;
935     frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
936     frameNode->children_.push_back(frameNode1);
937     ASSERT_TRUE(focusHub->IsFocusableNode());
938     ASSERT_TRUE(focusHub->IsFocusableScope());
939     auto res = focusHub1->IsOnRootTree();
940     ASSERT_FALSE(res);
941 }
942 
943 /**
944  * @tc.name: FocusHubTestNg0091
945  * @tc.desc: Test the function FocusToHeadOrTailChild.
946  * @tc.type: FUNC
947  */
948 HWTEST_F(FocusHubTestNg, FocusHubTestNg0091, TestSize.Level1)
949 {
950     /**
951      * @tc.steps: step1. Create frameNode.
952      */
953     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
954         AceType::MakeRefPtr<ButtonPattern>());
955     frameNode->GetOrCreateFocusHub();
956     auto eventHub = AceType::MakeRefPtr<EventHub>();
957     eventHub->AttachHost(frameNode);
958     auto focusHub = frameNode->GetFocusHub();
959     ASSERT_NE(focusHub, nullptr);
960     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
961         AceType::MakeRefPtr<ButtonPattern>());
962     frameNode1->GetOrCreateFocusHub();
963     auto focusHub1 = frameNode1->GetFocusHub();
964     focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
965     focusHub->focusType_ = FocusType::SCOPE;
966     frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
967     frameNode->children_.push_back(frameNode1);
968     ASSERT_TRUE(focusHub->IsFocusableNode());
969     ASSERT_TRUE(focusHub->IsFocusableScope());
970     focusHub->focusDepend_ = FocusDependence::AUTO;
971     EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(true));
972     focusHub->focusDepend_ = FocusDependence::SELF;
973     EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(false));
974     focusHub->focusDepend_ = FocusDependence::CHILD;
975     EXPECT_TRUE(focusHub->FocusToHeadOrTailChild(false));
976 }
977 
978 /**
979  * @tc.name: FocusHubTestNg0092
980  * @tc.desc: Test the function IsOnRootTree.
981  * @tc.type: FUNC
982  */
983 HWTEST_F(FocusHubTestNg, FocusHubTestNg0092, TestSize.Level1)
984 {
985     /**
986      * @tc.steps1: create focusHub and parentName = V2::ROOT_ETS_TAG.
987      */
988     auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, 101,
989         AceType::MakeRefPtr<ButtonPattern>());
990     frameNode->GetOrCreateFocusHub();
991     auto focusHub = frameNode->GetFocusHub();
992     ASSERT_NE(focusHub, nullptr);
993     auto frameNode1 = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, 101,
994         AceType::MakeRefPtr<ButtonPattern>());
995     frameNode1->GetOrCreateFocusHub();
996     auto focusHub1 = frameNode1->GetFocusHub();
997     focusHub->focusType_ = FocusType::SCOPE;
998     frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
999     frameNode->children_.push_back(frameNode1);
1000     ASSERT_TRUE(focusHub->IsFocusableNode());
1001     ASSERT_TRUE(focusHub->IsFocusableScope());
1002     auto res = focusHub1->IsOnRootTree();
1003     ASSERT_TRUE(res);
1004 }
1005 
1006 /**
1007  * @tc.name: FocusHubTestNg0093
1008  * @tc.desc: Test the function IsNeedPaintFocusState.
1009  * @tc.type: FUNC
1010  */
1011 HWTEST_F(FocusHubTestNg, FocusHubTestNg0093, TestSize.Level1)
1012 {
1013     /**
1014      * @tc.steps: step1. Create frameNode.
1015      */
1016     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1017         AceType::MakeRefPtr<ButtonPattern>());
1018     frameNode->GetOrCreateFocusHub();
1019     auto focusHub = frameNode->GetFocusHub();
1020     ASSERT_NE(focusHub, nullptr);
1021     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1022         AceType::MakeRefPtr<ButtonPattern>());
1023     frameNode1->GetOrCreateFocusHub();
1024     auto focusHub1 = frameNode1->GetFocusHub();
1025     focusHub->focusType_ = FocusType::SCOPE;
1026     frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1027     frameNode->children_.push_back(frameNode1);
1028     ASSERT_TRUE(focusHub->IsFocusableNode());
1029     focusHub->currentFocus_ = true;
1030     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
1031     ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
1032     EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
1033     focusHub->focusDepend_ = FocusDependence::SELF;
1034     EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
1035     focusHub->focusType_ = FocusType::NODE;
1036     EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
1037 }
1038 
1039 /**
1040  * @tc.name: FocusHubTestNg0094
1041  * @tc.desc: Test the function HandleFocusByTabIndex.
1042  * @tc.type: FUNC
1043  */
1044 HWTEST_F(FocusHubTestNg, FocusHubTestNg0094, TestSize.Level1)
1045 {
1046     /**
1047      * @tc.steps1: initialize parameters.
1048      */
1049     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1050         AceType::MakeRefPtr<ButtonPattern>());
1051     frameNode->GetOrCreateFocusHub();
1052     auto focusHub = frameNode->GetFocusHub();
1053     ASSERT_NE(focusHub, nullptr);
1054     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1055         AceType::MakeRefPtr<ButtonPattern>());
1056     frameNode1->GetOrCreateFocusHub();
1057     auto focusHub1 = frameNode1->GetFocusHub();
1058     frameNode->children_.push_back(frameNode1);
1059     focusHub->focusable_ = true;
1060     focusHub->parentFocusable_ = true;
1061     focusHub->focusType_ = FocusType::SCOPE;
1062     focusHub->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
1063     focusHub1->focusCallbackEvents_ = AceType::MakeRefPtr<FocusCallbackEvents>();
1064     focusHub1->focusable_ = true;
1065     focusHub1->parentFocusable_ = true;
1066     focusHub1->focusType_ = FocusType::NODE;
1067     focusHub1->focusCallbackEvents_->tabIndex_ = 1;
1068     KeyEvent keyEvent;
1069     TabIndexNodeList tabIndexNodes;
1070     keyEvent.action = KeyAction::DOWN;
1071     keyEvent.code = KeyCode::KEY_TAB;
1072     auto pipeline = PipelineContext::GetCurrentContext();
1073     pipeline->isTabJustTriggerOnKeyEvent_ = false;
1074     EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
1075 }
1076 
1077 /**
1078  * @tc.name: FocusHubTestNg0096
1079  * @tc.desc: Test the function OnFocusScope.
1080  * @tc.type: FUNC
1081  */
1082 HWTEST_F(FocusHubTestNg, FocusHubTestNg0096, TestSize.Level1)
1083 {
1084     /**
1085      * @tc.steps: step1. Create frameNode.
1086      */
1087     auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1088         AceType::MakeRefPtr<Pattern>());
1089     auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1090         AceType::MakeRefPtr<ButtonPattern>());
1091     auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1092         AceType::MakeRefPtr<ButtonPattern>());
1093     child->GetOrCreateFocusHub();
1094     child2->GetOrCreateFocusHub();
1095     frameNode->AddChild(child);
1096     frameNode->AddChild(child2);
1097     auto eventHub = AceType::MakeRefPtr<EventHub>();
1098     auto eventHub2 = AceType::MakeRefPtr<EventHub>();
1099     eventHub->AttachHost(frameNode);
1100     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1101     focusHub->currentFocus_ = true;
1102     std::list<RefPtr<FocusHub>> focusNodes;
1103     auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1104     EXPECT_EQ(itNewFocusNode, focusNodes.end());
1105     focusHub->OnFocusScope(true);
1106     frameNode->Clean(false, false);
1107     focusNodes.clear();
1108     EXPECT_TRUE(focusNodes.empty());
1109     focusHub->focusDepend_ = FocusDependence::AUTO;
1110     focusHub->OnFocusScope(true);
1111     focusHub->focusDepend_ = FocusDependence::SELF;
1112     focusHub->OnFocusScope(true);
1113     EXPECT_TRUE(focusHub->currentFocus_);
1114 }
1115 
1116 /**
1117  * @tc.name: FocusHubTestNg0097
1118  * @tc.desc: Test the function RequestFocusImmediatelyById.
1119  * @tc.type: FUNC
1120  */
1121 HWTEST_F(FocusHubTestNg, FocusHubTestNg0097, TestSize.Level1)
1122 {
1123     /**
1124      * @tc.steps1: create focusHub and construct allNodes.
1125      */
1126     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1127         AceType::MakeRefPtr<ButtonPattern>());
1128     frameNode->GetOrCreateFocusHub();
1129     auto focusHub = frameNode->GetFocusHub();
1130     ASSERT_NE(focusHub, nullptr);
1131     auto frameNode1 = FrameNodeOnTree::CreateFrameNode("123", 123,
1132         AceType::MakeRefPtr<ButtonPattern>());
1133     frameNode1->GetOrCreateFocusHub();
1134     auto focusHub1 = frameNode1->GetFocusHub();
1135     frameNode1->propInspectorId_ = "123";
1136     auto frameNode2 = FrameNodeOnTree::CreateFrameNode("frameNode", 102,
1137         AceType::MakeRefPtr<ButtonPattern>());
1138     frameNode2->GetOrCreateFocusHub();
1139     auto focusHub2 = frameNode2->GetFocusHub();
1140     frameNode->children_.push_back(frameNode2);
1141     frameNode->children_.push_back(frameNode1);
1142     focusHub->focusType_ = FocusType::SCOPE;
1143     focusHub1->parentFocusable_ = false;
1144     auto res = focusHub->RequestFocusImmediatelyById("123");
1145     ASSERT_FALSE(res);
1146 }
1147 
1148 /**
1149  * @tc.name: FocusHubTestNg0098
1150  * @tc.desc: Test functions OnBlurScope.
1151  * @tc.type: FUNC
1152  */
1153 HWTEST_F(FocusHubTestNg, FocusHubTestNg0098, TestSize.Level1)
1154 {
1155     /**
1156      * @tc.steps1: initialize parameters.
1157      */
1158     auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, 101,
1159         AceType::MakeRefPtr<ButtonPattern>());
1160     frameNode->GetOrCreateFocusHub();
1161     auto focusHub = frameNode->GetFocusHub();
1162     ASSERT_NE(focusHub, nullptr);
1163     auto frameNode1 = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, 101,
1164         AceType::MakeRefPtr<ButtonPattern>());
1165     frameNode1->GetOrCreateFocusHub();
1166     auto focusHub1 = frameNode1->GetFocusHub();
1167     focusHub->focusType_ = FocusType::SCOPE;
1168     frameNode1->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1169     frameNode->children_.push_back(frameNode1);
1170     focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHub1));
1171     focusHub->OnBlurScope();
1172     ASSERT_NE(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
1173 }
1174 
1175 /**
1176  * @tc.name: FocusHubTestNg0100
1177  * @tc.desc: Test the function IsImplicitFocusableScope.
1178  * @tc.type: FUNC
1179  */
1180 HWTEST_F(FocusHubTestNg, FocusHubTestNg0100, TestSize.Level1)
1181 {
1182     /**
1183      * @tc.steps1: initialize parameters.
1184      */
1185     auto eventHub = AceType::MakeRefPtr<EventHub>();
1186     eventHub->SetEnabled(true);
1187     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1188 
1189     /**
1190      * @tc.steps2: Set focusHub to scope type.
1191      * @tc.expected: The default value of focusable_ is false.
1192      */
1193     focusHub->focusType_ = FocusType::SCOPE;
1194     EXPECT_FALSE(focusHub->IsImplicitFocusableScope());
1195 
1196     /**
1197      * @tc.steps3: Set focusable_ to true implicitly.
1198      * @tc.expected: The value of focusable_ is true.
1199      */
1200     focusHub->SetFocusable(true, false);
1201     EXPECT_TRUE(focusHub->IsImplicitFocusableScope());
1202 }
1203 
1204 /**
1205  * @tc.name: LostFocusToViewRoot001
1206  * @tc.desc: Test the function LostFocusToViewRoot.
1207  * @tc.type: FUNC
1208  */
1209 HWTEST_F(FocusHubTestNg, LostFocusToViewRoot001, TestSize.Level1)
1210 {
1211     /**
1212      * @tc.steps1: create focusHub and construct allNodes.
1213      */
1214     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1215         AceType::MakeRefPtr<ButtonPattern>());
1216     frameNode->GetOrCreateFocusHub();
1217     auto focusHub = frameNode->GetFocusHub();
1218      /**
1219      * @tc.Calling LostFocusToViewRoot to increase coverage
1220      */
1221     focusHub->LostFocusToViewRoot();
1222     ASSERT_TRUE(focusHub->currentFocus_ == false);
1223 }
1224 
1225 /*
1226  * @tc.name: SetEnabled01
1227  * @tc.desc: Test the function SetEnabled.
1228  * @tc.type: FUNC
1229  */
1230 HWTEST_F(FocusHubTestNg, SetEnabled001, TestSize.Level1)
1231 {
1232     /**
1233      * @tc.steps1: create focusHub and construct allNodes.
1234      */
1235     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1236         AceType::MakeRefPtr<ButtonPattern>());
1237     frameNode->GetOrCreateFocusHub();
1238     auto focusHub = frameNode->GetFocusHub();
1239     ASSERT_NE(focusHub, nullptr);
1240 
1241     focusHub->currentFocus_ = true;
1242 
1243     focusHub->SetEnabled(false);
1244     ASSERT_FALSE(focusHub->currentFocus_);
1245 }
1246 
1247 /**
1248  * @tc.name: FocusHubTestNg0101
1249  * @tc.desc: Test the function IsSyncRequestFocusable.
1250  * @tc.type: FUNC
1251  */
1252 HWTEST_F(FocusHubTestNg, FocusHubTestNg0101, TestSize.Level1)
1253 {
1254     /**
1255      * @tc.steps1: initialize parameters.
1256      */
1257     auto eventHub = AceType::MakeRefPtr<EventHub>();
1258     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1259     eventHub->SetEnabled(false);
1260 
1261     /**
1262      * @tc.steps2: call the function IsSyncRequestFocusable with FocusType::NODE
1263      * @tc.expected: The return value of IsSyncRequestFocusable is false.
1264      */
1265     focusHub->SetFocusType(FocusType::NODE);
1266     EXPECT_FALSE(focusHub->IsSyncRequestFocusable());
1267 
1268     /**
1269      * @tc.steps3: call the function IsSyncRequestFocusable with FocusType::SCOPE
1270      * @tc.expected: The return value of IsSyncRequestFocusable is false.
1271      */
1272     focusHub->SetFocusType(FocusType::SCOPE);
1273     EXPECT_FALSE(focusHub->IsSyncRequestFocusable());
1274 
1275     /**
1276      * @tc.steps4: call the function IsSyncRequestFocusable with FocusType::DISABLE
1277      * @tc.expected: The return value of IsSyncRequestFocusable is false.
1278      */
1279     focusHub->SetFocusType(FocusType::DISABLE);
1280     EXPECT_FALSE(focusHub->IsSyncRequestFocusable());
1281 }
1282 
1283 /**
1284  * @tc.name: FocusHubTestNg0102
1285  * @tc.desc: Test the function ScrollByOffsetToParent.
1286  * @tc.type: FUNC
1287  */
1288 HWTEST_F(FocusHubTestNg, FocusHubTestNg0102, TestSize.Level1)
1289 {
1290     /**
1291      * @tc.steps1: create focusHub and construct allNodes.
1292      */
1293     auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 102,
1294         AceType::MakeRefPtr<ButtonPattern>());
1295     frameNode->GetOrCreateFocusHub();
1296     auto focusHub = frameNode->GetFocusHub();
1297     ASSERT_NE(focusHub, nullptr);
1298 
1299     auto textFieldNode = FrameNodeOnTree::CreateFrameNode("frameNode", 103,
1300         AceType::MakeRefPtr<TextFieldPattern>());
1301     textFieldNode->GetOrCreateFocusHub();
1302     auto textFieldFocusHub = textFieldNode->GetFocusHub();
1303     ASSERT_NE(textFieldNode, nullptr);
1304     ASSERT_FALSE(focusHub->ScrollByOffsetToParent(textFieldNode));
1305 
1306     auto listNode = FrameNodeOnTree::CreateFrameNode("frameNode", 104,
1307         AceType::MakeRefPtr<ListPattern>());
1308     listNode->GetOrCreateFocusHub();
1309     auto listFocusHub = listNode->GetFocusHub();
1310     ASSERT_NE(listFocusHub, nullptr);
1311     ASSERT_FALSE(focusHub->ScrollByOffsetToParent(listNode));
1312 }
1313 
1314 
1315 /**
1316  * @tc.name: FocusHubTestNg0103
1317  * @tc.desc: Test the function AcceptFocusOfPriorityChild.
1318  * @tc.type: FUNC
1319  */
1320 HWTEST_F(FocusHubTestNg, FocusHubTestNg0103, TestSize.Level1)
1321 {
1322     /**
1323      * @tc.steps: step1. Create frameNode.
1324      */
1325     auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 105,
1326         AceType::MakeRefPtr<LinearLayoutPattern>(true));
1327     auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110502() 1328         106, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1329     auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110602() 1330         107, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1331     child->MountToParent(frameNode);
1332     child2->MountToParent(frameNode);
1333 
1334     auto parentFocusHub = frameNode->GetOrCreateFocusHub();
1335     ASSERT_NE(parentFocusHub, nullptr);
1336     parentFocusHub->SetFocusScopeId("scope1", false);
1337 
1338     auto child2FocusHub = child2->GetOrCreateFocusHub();
1339     ASSERT_NE(child2FocusHub, nullptr);
1340     child2FocusHub->SetFocusScopePriority("scope1", 2000);
1341     EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild());
1342     EXPECT_EQ(parentFocusHub->lastWeakFocusNode_.Upgrade(), child2FocusHub);
1343 }
1344 
1345 /**
1346  * @tc.name: FocusHubTestNg0104
1347  * @tc.desc: Test the function AcceptFocusOfPriorityChild.
1348  * @tc.type: FUNC
1349  */
1350 HWTEST_F(FocusHubTestNg, FocusHubTestNg0104, TestSize.Level1)
1351 {
1352     /**
1353      * @tc.steps: step1. Create frameNode.
1354      */
1355     auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 108,
1356         AceType::MakeRefPtr<LinearLayoutPattern>(true));
1357     auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110702() 1358         109, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1359     auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110802() 1360         110, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1361     child->MountToParent(frameNode);
1362     child2->MountToParent(frameNode);
1363 
1364     auto parentFocusHub = frameNode->GetOrCreateFocusHub();
1365     ASSERT_NE(parentFocusHub, nullptr);
1366     parentFocusHub->SetFocusScopeId("scope2", true);
1367 
1368     auto child2FocusHub = child2->GetOrCreateFocusHub();
1369     ASSERT_NE(child2FocusHub, nullptr);
1370     child2FocusHub->SetFocusScopePriority("scope2", 2000);
1371     EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild());
1372     EXPECT_EQ(parentFocusHub->lastWeakFocusNode_.Upgrade(), child2FocusHub);
1373 
1374     auto childFocusHub = child->GetOrCreateFocusHub();
1375     ASSERT_NE(childFocusHub, nullptr);
1376     childFocusHub->SetFocusScopePriority("scope2", 3000);
1377     EXPECT_TRUE(parentFocusHub->AcceptFocusOfPriorityChild());
1378     EXPECT_EQ(parentFocusHub->lastWeakFocusNode_.Upgrade(), childFocusHub);
1379 }
1380 
1381 /**
1382  * @tc.name: FocusHubTestNg0105
1383  * @tc.desc: Test the function RequestFocusByPriorityInScope.
1384  * @tc.type: FUNC
1385  */
1386 HWTEST_F(FocusHubTestNg, FocusHubTestNg0105, TestSize.Level1)
1387 {
1388     /**
1389      * @tc.steps: step1. Create frameNode.
1390      */
1391     auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 111,
1392         AceType::MakeRefPtr<LinearLayoutPattern>(true));
1393     auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110902() 1394         112, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1395     auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110a02() 1396         113, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1397     child->MountToParent(frameNode);
1398     child2->MountToParent(frameNode);
1399 
1400     auto parentFocusHub = frameNode->GetOrCreateFocusHub();
1401     ASSERT_NE(parentFocusHub, nullptr);
1402     parentFocusHub->SetFocusScopeId("scope3", false);
1403 
1404     auto child2FocusHub = child2->GetOrCreateFocusHub();
1405     ASSERT_NE(child2FocusHub, nullptr);
1406     child2FocusHub->SetFocusScopePriority("scope3", 2000);
1407     EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope());
1408     EXPECT_TRUE(child2FocusHub->IsCurrentFocus());
1409 }
1410 
1411 /**
1412  * @tc.name: FocusHubTestNg0106
1413  * @tc.desc: Test the function RequestFocusByPriorityInScope.
1414  * @tc.type: FUNC
1415  */
1416 HWTEST_F(FocusHubTestNg, FocusHubTestNg0106, TestSize.Level1)
1417 {
1418     /**
1419      * @tc.steps: step1. Create frameNode.
1420      */
1421     auto frameNode = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 114,
1422         AceType::MakeRefPtr<LinearLayoutPattern>(true));
1423     auto child = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110b02() 1424         115, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1425     auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(V2::BUTTON_ETS_TAG,
__anon70c353110c02() 1426         116, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1427     child->MountToParent(frameNode);
1428     child2->MountToParent(frameNode);
1429 
1430     auto parentFocusHub = frameNode->GetOrCreateFocusHub();
1431     ASSERT_NE(parentFocusHub, nullptr);
1432     parentFocusHub->SetFocusScopeId("scope4", true);
1433 
1434     auto child2FocusHub = child2->GetOrCreateFocusHub();
1435     ASSERT_NE(child2FocusHub, nullptr);
1436     child2FocusHub->SetFocusScopePriority("scope4", 2000);
1437     EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope());
1438     EXPECT_TRUE(child2FocusHub->IsCurrentFocus());
1439 
1440     auto childFocusHub = child->GetOrCreateFocusHub();
1441     ASSERT_NE(childFocusHub, nullptr);
1442     childFocusHub->SetFocusScopePriority("scope4", 3000);
1443     EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope());
1444     EXPECT_TRUE(childFocusHub->IsCurrentFocus());
1445 }
1446 
1447 /**
1448  * @tc.name: FocusHubTestNg0107
1449  * @tc.desc: Test the function IsInFocusGroup.
1450  * @tc.type: FUNC
1451  */
1452 HWTEST_F(FocusHubTestNg, FocusHubTestNg0107, TestSize.Level1)
1453 {
1454     /**
1455      * @tc.steps: step1. Create frameNode.
1456      */
1457     auto frameNode =
1458         FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, 117, AceType::MakeRefPtr<LinearLayoutPattern>(true));
1459     auto child = FrameNodeOnTree::GetOrCreateFrameNode(
__anon70c353110d02() 1460         V2::BUTTON_ETS_TAG, 118, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1461     auto child2 = FrameNodeOnTree::GetOrCreateFrameNode(
__anon70c353110e02() 1462         V2::BUTTON_ETS_TAG, 119, []() { return AceType::MakeRefPtr<ButtonPattern>(); });
1463     child->MountToParent(frameNode);
1464     child2->MountToParent(frameNode);
1465 
1466     auto parentFocusHub = frameNode->GetOrCreateFocusHub();
1467     ASSERT_NE(parentFocusHub, nullptr);
1468     parentFocusHub->SetFocusScopeId("scope5", true);
1469 
1470     auto child2FocusHub = child2->GetOrCreateFocusHub();
1471     ASSERT_NE(child2FocusHub, nullptr);
1472     child2FocusHub->SetFocusScopePriority("scope5", 2000);
1473     parentFocusHub->isFocusScope_ = true;
1474     EXPECT_TRUE(parentFocusHub->RequestFocusByPriorityInScope());
1475     parentFocusHub->isFocusScope_ = false;
1476     EXPECT_FALSE(parentFocusHub->RequestFocusByPriorityInScope());
1477     EXPECT_TRUE(child2FocusHub->IsCurrentFocus());
1478 
1479     auto pipeline = PipelineContext::GetCurrentContext();
1480     pipeline->isFocusActive_ = true;
1481     pipeline->isTabJustTriggerOnKeyEvent_ = true;
1482     KeyEvent keyEvent;
1483     keyEvent.action = KeyAction::DOWN;
1484     keyEvent.code = KeyCode::KEY_TAB;
1485     keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB);
1486     EXPECT_FALSE(parentFocusHub->OnKeyEventScope(keyEvent));
1487 }
1488 
1489 /**
1490  * @tc.name: FocusHubTestNg0108
1491  * @tc.desc: Test the function HasFocusedChild.
1492  * @tc.type: FUNC
1493  */
1494 HWTEST_F(FocusHubTestNg, FocusHubTestNg0108, TestSize.Level1)
1495 {
1496     /**
1497      * @tc.steps1: initialize parameters.
1498      */
1499     auto eventHub = AceType::MakeRefPtr<EventHub>();
1500     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1501     ASSERT_NE(focusHub, nullptr);
1502 
1503     /**
1504      * @tc.steps2: call the function HasFocusedChild with true and FocusType::SCOPE
1505      */
1506     focusHub->currentFocus_ = true;
1507     focusHub->focusType_ = FocusType::SCOPE;
1508     focusHub->HasFocusedChild();
1509 
1510 
1511     /**
1512      * @tc.steps3: call the function HasFocusedChild with true and FocusType::DISABLE
1513      * @tc.expected: The return value of HasFocusedChild is false.
1514      */
1515     focusHub->focusType_ = FocusType::DISABLE;
1516     ASSERT_FALSE(focusHub->HasFocusedChild());
1517 
1518     /**
1519      * @tc.steps4: call the function HasFocusedChild with false and FocusType::DISABLE
1520      * @tc.expected: The return value of HasFocusedChild is false.
1521      */
1522     focusHub->currentFocus_ = false;
1523     focusHub->focusType_ = FocusType::DISABLE;
1524     ASSERT_FALSE(focusHub->HasFocusedChild());
1525 
1526 
1527     /**
1528      * @tc.steps5: call the function HasFocusedChild with false and FocusType::SCOPE
1529      * @tc.expected: The return value of HasFocusedChild is false.
1530      */
1531     focusHub->focusType_ = FocusType::SCOPE;
1532     ASSERT_FALSE(focusHub->HasFocusedChild());
1533 }
1534 
1535 /**
1536  * @tc.name: GetRootFocusHub001
1537  * @tc.desc: Test the function GetRootFocusHub.
1538  * @tc.type: FUNC
1539  */
1540 HWTEST_F(FocusHubTestNg, GetRootFocusHub001, TestSize.Level1)
1541 {
1542     auto eventHub = AceType::MakeRefPtr<EventHub>();
1543     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1544     ASSERT_NE(focusHub, nullptr);
1545     ASSERT_NE(focusHub->GetRootFocusHub(), nullptr);
1546 }
1547 
1548 /**
1549  * @tc.name: SetFocusable001
1550  * @tc.desc: Test the function SetFocusable.
1551  * @tc.type: FUNC
1552  */
1553 HWTEST_F(FocusHubTestNg, SetFocusable001, TestSize.Level1)
1554 {
1555     auto eventHub = AceType::MakeRefPtr<EventHub>();
1556     auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1557     ASSERT_NE(focusHub, nullptr);
1558     focusHub->focusType_ = FocusType::SCOPE;
1559     focusHub->focusable_ = true;
1560     focusHub->implicitFocusable_ = true;
1561     focusHub->focusDepend_ = FocusDependence::AUTO;
1562     focusHub->SetFocusable(true, true);
1563     focusHub->focusDepend_ = FocusDependence::CHILD;
1564     focusHub->SetFocusable(true, true);
1565     ASSERT_NE(focusHub->focusDepend_, FocusDependence::CHILD);
1566 }
1567 } // namespace OHOS::Ace::NG