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 
16 #include <optional>
17 
18 #include "gtest/gtest.h"
19 #define private public
20 #include "base/log/dump_log.h"
21 #include "test/mock/core/common/mock_container.h"
22 #include "test/mock/core/pipeline/mock_pipeline_context.h"
23 
24 #include "core/components_ng/manager/focus/focus_manager.h"
25 #include "core/components_ng/pattern/root/root_pattern.h"
26 #include "core/components_ng/pattern/stage/page_pattern.h"
27 
28 using namespace testing;
29 using namespace testing::ext;
30 namespace OHOS::Ace::NG {
31 namespace {
32 constexpr int32_t SIZE_1 = 1;
33 } // namespace
34 
35 class FocusManagerTestNg : public testing::Test {
36 public:
37     static void SetUpTestCase();
38     static void TearDownTestCase();
39 };
40 
SetUpTestCase()41 void FocusManagerTestNg::SetUpTestCase()
42 {
43     MockPipelineContext::SetUp();
44     MockContainer::SetUp();
45 }
46 
TearDownTestCase()47 void FocusManagerTestNg::TearDownTestCase()
48 {
49     MockPipelineContext::TearDown();
50     MockContainer::TearDown();
51 }
52 
53 /**
54  * @tc.name: FocusManagerTest001
55  * @tc.desc: Create FocusManager
56  * @tc.type: FUNC
57  * @tc.author: catpoison
58  */
59 HWTEST_F(FocusManagerTestNg, FocusManagerTest001, TestSize.Level1)
60 {
61     /**
62      * @tc.steps: step1. construct a FocusManager
63      */
64     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
65     EXPECT_TRUE(focusManager->focusViewStack_.empty());
66 
67     /**
68      * @tc.steps: step2. lastFocusView_ is nullptr. GetWeakFocusViewList() is empty.
69      */
70     EXPECT_FALSE(focusManager->lastFocusView_.Upgrade());
71     EXPECT_TRUE(focusManager->GetWeakFocusViewList().empty());
72 }
73 
74 /**
75  * @tc.name: FocusManagerTest002
76  * @tc.desc: FocusViewShow / FocusViewHide / FocusViewClose
77  * @tc.type: FUNC
78  * @tc.author: catpoison
79  */
80 HWTEST_F(FocusManagerTestNg, FocusManagerTest002, TestSize.Level1)
81 {
82     /**
83      * @tc.steps: step1. construct a FocusManager and a FocusView
84      */
85     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
86 
87     auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, -1, AceType::MakeRefPtr<RootPattern>());
88     auto rootFocusHub = rootNode->GetOrCreateFocusHub();
89 
90     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
91     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
92     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
93     rootNode->AddChild(pageNode);
94 
95     /**
96      * @tc.steps: step2. Do FocusViewShow. lastFocusView is focusView. GetWeakFocusViewList().size == 1
97      */
98     focusManager->FocusViewShow(pagePattern);
99     EXPECT_EQ(focusManager->lastFocusView_.Upgrade(), pagePattern);
100     EXPECT_EQ(focusManager->GetWeakFocusViewList().size(), SIZE_1);
101 
102     /**
103      * @tc.steps: step3. Do FocusViewHide. lastFocusView is nullptr. GetWeakFocusViewList().size == 1
104      */
105     focusManager->FocusViewHide(pagePattern);
106     EXPECT_EQ(focusManager->lastFocusView_.Upgrade(), nullptr);
107     EXPECT_EQ(focusManager->GetWeakFocusViewList().size(), SIZE_1);
108 
109     /**
110      * @tc.steps: step4. Do FocusViewClose. lastFocusView is nullptr. GetWeakFocusViewList().size == 0
111      */
112     focusManager->FocusViewShow(pagePattern);
113     focusManager->FocusViewClose(pagePattern);
114     EXPECT_EQ(focusManager->lastFocusView_.Upgrade(), nullptr);
115     EXPECT_TRUE(focusManager->GetWeakFocusViewList().empty());
116 }
117 
118 /**
119  * @tc.name: FocusManagerTest003
120  * @tc.desc: SetRequestFocusCallback / TriggerRequestFocusCallback
121  * @tc.type: FUNC
122  */
123 HWTEST_F(FocusManagerTestNg, FocusManagerTest003, TestSize.Level1)
124 {
125     /**
126      * @tc.steps: step1. construct a FocusManager.
127      */
128     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
129 
130     /**
131      * @tc.steps: step2. call SetRequestFocusCallback and TriggerRequestFocusCallback.
132      */
133     bool flag = false;
__anona274acdd0202(NG::RequestFocusResult result) 134     RequestFocusCallback requestFocusCallback = [&flag](NG::RequestFocusResult result) { flag = !flag; };
135     focusManager->SetRequestFocusCallback(requestFocusCallback);
136     focusManager->TriggerRequestFocusCallback(NG::RequestFocusResult::DEFAULT);
137     EXPECT_TRUE(flag);
138 
139     /**
140      * @tc.steps: step3. TriggerRequestFocusCallback again.
141      */
142     focusManager->TriggerRequestFocusCallback(NG::RequestFocusResult::DEFAULT);
143     EXPECT_TRUE(flag);
144 }
145 
146 /**
147  * @tc.name: FocusManagerTest004
148  * @tc.desc: FlushFocusView
149  * @tc.type: FUNC
150  */
151 HWTEST_F(FocusManagerTestNg, FocusManagerTest004, TestSize.Level1)
152 {
153     /**
154      * @tc.steps: step1. construct a FocusManager.
155      */
156     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
157 
158     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
159     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
160     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
161     pageFocusHub->currentFocus_ = false;
162 
163     auto pagePattern2 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
164     auto pageFouceView = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern));
165     auto pageFouceView2 = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern2));
166 
167     focusManager->lastFocusView_ = pageFouceView;
168     focusManager->focusViewStack_.push_back(pageFouceView);
169     focusManager->focusViewStack_.push_back(pageFouceView2);
170 
171     focusManager->FlushFocusView();
172     ASSERT_TRUE(focusManager->lastFocusView_.Invalid());
173 
174     pageFocusHub->currentFocus_ = true;
175     focusManager->FlushFocusView();
176     ASSERT_FALSE(focusManager->lastFocusView_.Invalid());
177 }
178 
179 /**
180  * @tc.name: FocusManagerTest005
181  * @tc.desc: GetFocusViewMap
182  * @tc.type: FUNC
183  */
184 HWTEST_F(FocusManagerTestNg, FocusManagerTest005, TestSize.Level1)
185 {
186     /**
187      * @tc.steps: step1. construct a FocusManager.
188      */
189     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
190 
191     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
192     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
193     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
194     pageFocusHub->currentFocus_ = false;
195 
196     auto pagePattern2 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
197     auto pageFouceView = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern));
198     auto pageFouceView2 = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern2));
199 
200     focusManager->lastFocusView_ = pageFouceView;
201     focusManager->focusViewStack_.push_back(pageFouceView);
202     focusManager->focusViewStack_.push_back(pageFouceView2);
203     focusManager->focusViewStack_.push_back(nullptr);
204 
205     std::unordered_map<int32_t, std::pair<WeakPtr<FocusView>, std::list<WeakPtr<FocusView>>>> focusViewMap;
206     focusViewMap[1] = std::make_pair(pageFouceView, focusManager->focusViewStack_);
207 
208     focusManager->GetFocusViewMap(focusViewMap);
209     ASSERT_FALSE(focusViewMap[1].second.empty());
210 }
211 
212 
213 /**
214  * @tc.name: setFocusManagerViewStack
215  * @tc.desc: setFocusManagerViewStack
216  * @tc.type: FUNC
217  */
setFocusManagerViewStack(RefPtr<FocusManager> focusManager)218 void setFocusManagerViewStack(RefPtr<FocusManager> focusManager)
219 {
220     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
221     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
222     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
223     pageFocusHub->currentFocus_ = false;
224 
225     auto pagePattern2 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
226     auto pageFouceView = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern));
227     auto pageFouceView2 = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern2));
228 
229     focusManager->lastFocusView_ = pageFouceView;
230     focusManager->focusViewStack_.push_back(pageFouceView);
231     focusManager->focusViewStack_.push_back(pageFouceView2);
232     focusManager->focusViewStack_.push_back(nullptr);
233 }
234 
235 /**
236  * @tc.name: FocusManagerTest006
237  * @tc.desc: DumpFocusManager
238  * @tc.type: FUNC
239  */
240 HWTEST_F(FocusManagerTestNg, FocusManagerTest006, TestSize.Level1)
241 {
242     /**
243      * @tc.steps: step1. construct a FocusManager
244      */
245     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
246 
247     focusManager->DumpFocusManager();
248 
249     auto ss = std::make_unique<std::ostringstream>();
250     DumpLog::GetInstance().SetDumpFile(std::move(ss));
251     focusManager->DumpFocusManager();
252     ASSERT_TRUE(DumpLog::GetInstance().GetDumpFile());
253 
254     setFocusManagerViewStack(focusManager);
255     focusManager->DumpFocusManager();
256     ASSERT_TRUE(DumpLog::GetInstance().GetDumpFile());
257 }
258 
259 /**
260  * @tc.name: FocusManagerTest007
261  * @tc.desc: RemoveFocusScope
262  * @tc.type: FUNC
263  */
264 HWTEST_F(FocusManagerTestNg, FocusManagerTest007, TestSize.Level1)
265 {
266     /**
267      * @tc.steps: step1. construct a FocusManager
268      */
269     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
270 
271     focusManager->RemoveFocusScope("scop1");
272     ASSERT_TRUE(focusManager->focusHubScopeMap_.empty());
273 
274     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
275     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 1, pagePattern);
276     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
277     pageFocusHub->currentFocus_ = false;
278 
279     std::unordered_map<std::string, std::pair<WeakPtr<FocusHub>, std::list<WeakPtr<FocusHub>>>> focusHubScopeMap;
280     std::list<WeakPtr<FocusHub>> focusHubScopeList;
281     focusHubScopeList.push_back(pageFocusHub);
282     focusHubScopeMap["scop1"] = std::make_pair(pageFocusHub, focusHubScopeList);
283     std::list<WeakPtr<FocusHub>> focusHubScopeEmptyList;
284     focusHubScopeMap["scop2"] = std::make_pair(pageFocusHub, focusHubScopeEmptyList);
285     focusManager->focusHubScopeMap_ = focusHubScopeMap;
286 
287     focusManager->RemoveFocusScope("scop1");
288     focusManager->RemoveFocusScope("scop2");
289     ASSERT_TRUE(focusManager->focusHubScopeMap_.find("scop2") == focusManager->focusHubScopeMap_.end());
290 }
291 
292 /**
293  * @tc.name: FocusManagerTest008
294  * @tc.desc: GetFocusScopePriorityList
295  * @tc.type: FUNC
296  */
297 HWTEST_F(FocusManagerTestNg, FocusManagerTest008, TestSize.Level1)
298 {
299     /**
300      * @tc.steps: step1. construct a FocusManager
301      */
302     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
303 
304     ASSERT_EQ(focusManager->GetFocusScopePriorityList("scop1"), std::nullopt);
305 
306     std::list<WeakPtr<FocusHub>> focusHubScopeEmptyList;
307     focusManager->focusHubScopeMap_["scop2"] = std::make_pair(nullptr, focusHubScopeEmptyList);
308     ASSERT_EQ(focusManager->GetFocusScopePriorityList("scop2"), std::nullopt);
309 
310     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
311     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
312     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
313     auto pageFocusHubWeakPtr = AceType::WeakClaim<FocusHub>(AceType::RawPtr<FocusHub>(pageFocusHub));
314     focusHubScopeEmptyList.push_back(pageFocusHubWeakPtr);
315     focusManager->focusHubScopeMap_["scop2"] = std::make_pair(pageFocusHub, focusHubScopeEmptyList);
316     ASSERT_TRUE(focusManager->GetFocusScopePriorityList("scop2").has_value());
317 }
318 
319 /**
320  * @tc.name: FocusManagerTest009
321  * @tc.desc: WindowFocusMoveEnd
322  * @tc.type: FUNC
323  */
324 HWTEST_F(FocusManagerTestNg, FocusManagerTest009, TestSize.Level1)
325 {
326     /**
327      * @tc.steps: step1. construct a FocusManager
328      */
329     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
330     focusManager->isSwitchingWindow_ = true;
331 
332     focusManager->isSwitchingFocus_ = std::nullopt;
333     focusManager->WindowFocusMoveEnd();
334     ASSERT_FALSE(focusManager->isSwitchingWindow_);
335 }
336 
337 /**
338  * @tc.name: FocusManagerTest010
339  * @tc.desc: FocusSwitchingEnd
340  * @tc.type: FUNC
341  */
342 HWTEST_F(FocusManagerTestNg, FocusManagerTest010, TestSize.Level1)
343 {
344     /**
345      * @tc.steps: step1. construct a FocusManager
346      */
347     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
348     focusManager->isSwitchingWindow_ = true;
349 
350     focusManager->isSwitchingFocus_ = false;
351     focusManager->FocusSwitchingEnd();
352     ASSERT_TRUE(focusManager->isSwitchingFocus_);
353 }
354 
355 /**
356  * @tc.name: FocusManagerTest011
357  * @tc.desc: GetFocusViewMap
358  * @tc.type: FUNC
359  */
360 HWTEST_F(FocusManagerTestNg, FocusManagerTest011, TestSize.Level1)
361 {
362     /**
363      * @tc.steps: step1. construct a FocusManager.
364      */
365     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
366 
367     setFocusManagerViewStack(focusManager);
368 
369     std::unordered_map<int32_t, std::pair<WeakPtr<FocusView>, std::list<WeakPtr<FocusView>>>> focusViewMap;
370     focusViewMap[1] = std::make_pair(focusManager->lastFocusView_, focusManager->focusViewStack_);
371 
372     focusManager->GetFocusViewMap(focusViewMap);
373     ASSERT_FALSE(focusViewMap[1].second.empty());
374 }
375 
376 /**
377  * @tc.name: setFocusManagerHubScopeMap
378  * @tc.desc: setFocusManagerHubScopeMap
379  * @tc.type: FUNC
380  */
setFocusManagerHubScopeMap(RefPtr<FocusManager> focusManager)381 void setFocusManagerHubScopeMap(RefPtr<FocusManager> focusManager)
382 {
383     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
384     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
385     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
386 
387     std::unordered_map<std::string, std::pair<WeakPtr<FocusHub>, std::list<WeakPtr<FocusHub>>>> focusHubScopeMap;
388     std::list<WeakPtr<FocusHub>> focusHubScopeList;
389     focusHubScopeList.push_back(pageFocusHub);
390     focusHubScopeMap["scop1"] = std::make_pair(pageFocusHub, focusHubScopeList);
391     std::list<WeakPtr<FocusHub>> focusHubScopeEmptyList;
392     focusHubScopeMap["scop2"] = std::make_pair(nullptr, focusHubScopeEmptyList);
393     focusManager->focusHubScopeMap_ = focusHubScopeMap;
394 }
395 
396 /**
397  * @tc.name: FocusManagerTest012
398  * @tc.desc: AddFocusScope
399  * @tc.type: FUNC
400  */
401 HWTEST_F(FocusManagerTestNg, FocusManagerTest012, TestSize.Level1)
402 {
403     /**
404      * @tc.steps: step1. construct a FocusManager
405      */
406     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
407 
408     setFocusManagerHubScopeMap(focusManager);
409     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
410     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
411     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
412 
413     ASSERT_TRUE(focusManager->AddFocusScope("scop1", pageFocusHub));
414     ASSERT_TRUE(focusManager->AddFocusScope("scop2", pageFocusHub));
415     focusManager->AddFocusScope("scop3", pageFocusHub);
416     ASSERT_TRUE(focusManager->focusHubScopeMap_["scop3"].second.empty());
417 }
418 
419 /**
420  * @tc.name: FocusManagerTest013
421  * @tc.desc: AddScopePriorityNode
422  * @tc.type: FUNC
423  */
424 HWTEST_F(FocusManagerTestNg, FocusManagerTest013, TestSize.Level1)
425 {
426     /**
427      * @tc.steps: step1. construct a FocusManager
428      */
429     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
430     setFocusManagerHubScopeMap(focusManager);
431     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
432     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
433     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
434 
435     focusManager->AddScopePriorityNode("scop1", pageFocusHub, true);
436     ASSERT_FALSE(focusManager->focusHubScopeMap_["scop1"].second.empty());
437 
438     focusManager->AddScopePriorityNode("scop3", pageFocusHub, true);
439     ASSERT_FALSE(focusManager->focusHubScopeMap_["scop3"].second.empty());
440 }
441 
442 /**
443  * @tc.name: FocusManagerTest014
444  * @tc.desc: RemoveScopePriorityNode
445  * @tc.type: FUNC
446  */
447 HWTEST_F(FocusManagerTestNg, FocusManagerTest014, TestSize.Level1)
448 {
449     /**
450      * @tc.steps: step1. construct a FocusManager
451      */
452     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
453     setFocusManagerHubScopeMap(focusManager);
454     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
455     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
456     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
457 
458     focusManager->RemoveScopePriorityNode("scop1", pageFocusHub);
459     focusManager->RemoveScopePriorityNode("scop2", pageFocusHub);
460     ASSERT_TRUE(focusManager->focusHubScopeMap_["scop2"].second.empty());
461 
462     focusManager->RemoveScopePriorityNode("scop3", pageFocusHub);
463     ASSERT_TRUE(focusManager->focusHubScopeMap_.find("scop3") == focusManager->focusHubScopeMap_.end());
464 
465     std::list<WeakPtr<FocusHub>> focusHubScopeEmptyList;
466     focusManager->focusHubScopeMap_["scop4"] = std::make_pair(pageFocusHub, focusHubScopeEmptyList);
467     focusManager->RemoveScopePriorityNode("scop4", pageFocusHub);
468 
469     auto pagePattern2 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
470     auto pageNode2 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern2);
471     auto pageFocusHub2 = pageNode2->GetOrCreateFocusHub();
472     focusHubScopeEmptyList.push_back(pageFocusHub2);
473     focusManager->focusHubScopeMap_["scop5"] = std::make_pair(nullptr, focusHubScopeEmptyList);
474     focusManager->RemoveScopePriorityNode("scop5", pageFocusHub);
475 }
476 
477 /**
478  * @tc.name: FocusManagerTest015
479  * @tc.desc: FlushFocusView
480  * @tc.type: FUNC
481  */
482 HWTEST_F(FocusManagerTestNg, FocusManagerTest015, TestSize.Level1)
483 {
484     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
485     auto rootNode = FrameNode::CreateFrameNode(V2::ROOT_ETS_TAG, -1, AceType::MakeRefPtr<RootPattern>());
486     auto rootFocusHub = rootNode->GetOrCreateFocusHub();
487     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
488     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
489     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
490     rootFocusHub->currentFocus_ = true;
491     pageFocusHub->currentFocus_ = true;
492     auto pagePattern2 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
493     auto pageNode2 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern2);
494     auto pageFocusHub2 = pageNode2->GetOrCreateFocusHub();
495     pageFocusHub2->currentFocus_ = true;
496     rootNode->AddChild(pageNode2);
497     pageNode2->AddChild(pageNode);
498 
499     auto pagePattern3 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
500     auto pageNode3 = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern3);
501     auto pageFocusHub3 = pageNode3->GetOrCreateFocusHub();
502     pageFocusHub3->currentFocus_ = false;
503     pageNode2->AddChild(pageNode3);
504 
505     auto pageFouceView = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern));
506     auto pageFouceView2 = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern2));
507     auto pageFouceView3 = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern3));
508 
509     focusManager->lastFocusView_ = pageFouceView3;
510     focusManager->focusViewStack_.push_back(pageFouceView);
511     focusManager->focusViewStack_.push_back(pageFouceView2);
512     focusManager->focusViewStack_.push_back(pageFouceView3);
513 
514     focusManager->FlushFocusView();
515     EXPECT_FALSE(focusManager->lastFocusView_.Invalid());
516 }
517 
518 /**
519  * @tc.name: FocusManagerTest016
520  * @tc.desc: GetFocusViewMap
521  * @tc.type: FUNC
522  */
523 HWTEST_F(FocusManagerTestNg, FocusManagerTest016, TestSize.Level1)
524 {
525     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
526     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
527     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
528     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
529     pageFocusHub->currentFocus_ = false;
530 
531     auto pagePattern2 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
532     auto pageFouceView = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern));
533     auto pageFouceView2 = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern2));
534 
535     focusManager->lastFocusView_ = pageFouceView;
536     focusManager->focusViewStack_.push_back(pageFouceView);
537     focusManager->focusViewStack_.push_back(pageFouceView2);
538 
539     std::unordered_map<int32_t, std::pair<WeakPtr<FocusView>, std::list<WeakPtr<FocusView>>>> focusViewMap;
540     focusViewMap[1] = std::make_pair(pageFouceView, focusManager->focusViewStack_);
541 
542     focusManager->GetFocusViewMap(focusViewMap);
543     EXPECT_FALSE(focusViewMap[1].second.empty());
544 }
545 
546 /**
547  * @tc.name: FocusManagerTest017
548  * @tc.desc: DumpFocusManager
549  * @tc.type: FUNC
550  */
551 HWTEST_F(FocusManagerTestNg, FocusManagerTest017, TestSize.Level1)
552 {
553     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
554     auto ss = std::make_unique<std::ostringstream>();
555     DumpLog::GetInstance().SetDumpFile(std::move(ss));
556     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
557     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, 2, pagePattern);
558     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
559     pageFocusHub->currentFocus_ = false;
560 
561     auto pagePattern2 = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
562     auto pageFouceView = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern));
563     auto pageFouceView2 = AceType::WeakClaim<PagePattern>(AceType::RawPtr<PagePattern>(pagePattern2));
564 
565     focusManager->lastFocusView_ = pageFouceView;
566     focusManager->focusViewStack_.push_back(pageFouceView);
567     std::unordered_map<int32_t, std::pair<WeakPtr<FocusView>, std::list<WeakPtr<FocusView>>>> focusViewMap;
568     focusViewMap[1] = std::make_pair(pageFouceView, focusManager->focusViewStack_);
569     focusManager->DumpFocusManager();
570     setFocusManagerViewStack(focusManager);
571     focusManager->DumpFocusManager();
572     EXPECT_TRUE(DumpLog::GetInstance().GetDumpFile());
573 }
574 
575 /**
576  * @tc.name: FocusManagerTest018
577  * @tc.desc: AddFocusScope
578  * @tc.type: FUNC
579  */
580 HWTEST_F(FocusManagerTestNg, FocusManagerTest018, TestSize.Level1)
581 {
582     auto focusManager = AceType::MakeRefPtr<FocusManager>(nullptr);
583     auto pagePattern = AceType::MakeRefPtr<PagePattern>(AceType::MakeRefPtr<PageInfo>());
584     auto pageNode = FrameNode::CreateFrameNode(V2::PAGE_ETS_TAG, -1, pagePattern);
585     auto pageFocusHub = pageNode->GetOrCreateFocusHub();
586 
587     std::unordered_map<std::string, std::pair<WeakPtr<FocusHub>, std::list<WeakPtr<FocusHub>>>> focusHubScopeMap;
588     std::list<WeakPtr<FocusHub>> focusHubScopeList;
589     focusHubScopeList.push_back(pageFocusHub);
590     focusHubScopeMap["scop1"] = std::make_pair(pageFocusHub, focusHubScopeList);
591     std::list<WeakPtr<FocusHub>> focusHubScopeEmptyList;
592     focusHubScopeMap["scop2"] = std::make_pair(nullptr, focusHubScopeEmptyList);
593     focusManager->focusHubScopeMap_ = focusHubScopeMap;
594 
595     focusManager->AddFocusScope("scop1", pageFocusHub);
596     focusManager->AddFocusScope("scop3", pageFocusHub);
597     EXPECT_TRUE(focusManager->focusHubScopeMap_["scop3"].second.empty());
598 }
599 } // namespace OHOS::Ace::NG
600