1 /*
2 * SPDX-License-Identifier: Apache-2.0
3 * Copyright (c) 2025 Huawei Device Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 #include "gtest/gtest.h"
17
18 #define private public
19 #define protected public
20 #include "interfaces/inner_api/ace_kit/src/view/ui_context_impl.h"
21 #include "test/mock/core/common/mock_resource_adapter.h"
22 #include "test/mock/core/common/mock_theme_manager.h"
23 #include "test/mock/core/pipeline/mock_pipeline_context.h"
24 #include "test/mock/core/render/mock_render_context.h"
25 #include "test/unittest/core/event/focus_core/focus_request_test.h"
26 #include "test/unittest/core/event/focus_core/hierarchical_switching_test.h"
27 #include "test/unittest/core/pattern/test_ng.h"
28
29 using namespace testing;
30 using namespace testing::ext;
31 namespace OHOS::Ace::NG {
32
33 struct FocusHierarchicalPageTestCase {
34 bool isDefaultFocus;
35 bool isDefaultFocusAble;
36 bool isCFirstFocus;
37 bool isCAlreadyFocus;
38 FocusHierarchicalCase nodeId;
39 bool isDependenceC;
FocusHierarchicalPageTestCaseOHOS::Ace::NG::FocusHierarchicalPageTestCase40 FocusHierarchicalPageTestCase(bool isDefaultFocus, bool isDefaultFocusAble, bool isCFirstFocus,
41 bool isCAlreadyFocus, FocusHierarchicalCase nodeId, bool isDependenceC)
42 : isDefaultFocus(isDefaultFocus), isDefaultFocusAble(isDefaultFocusAble), isCFirstFocus(isCFirstFocus),
43 isCAlreadyFocus(isCAlreadyFocus), nodeId(nodeId), isDependenceC(isDependenceC)
44 {}
45 };
46
47 const std::vector<FocusHierarchicalPageTestCase> FOCUS_HIERARCHICAL_PAGE_CASES = {
48 // case1
49 FocusHierarchicalPageTestCase(true, true, true, false, FocusHierarchicalCase::NONE, true),
50 // case2
51 FocusHierarchicalPageTestCase(true, true, true, false, FocusHierarchicalCase::NONE, false),
52 // case3
53 FocusHierarchicalPageTestCase(true, true, false, true, FocusHierarchicalCase::NODEC, true),
54 // case4
55 FocusHierarchicalPageTestCase(true, true, false, true, FocusHierarchicalCase::NODEC, false),
56 // case5
57 FocusHierarchicalPageTestCase(true, true, false, true, FocusHierarchicalCase::NODEE, true),
58 // case6
59 FocusHierarchicalPageTestCase(true, true, false, true, FocusHierarchicalCase::NODEE, false),
60
61 };
62
SetUpTestSuite()63 void FocusHierarchicalPageTestNG::SetUpTestSuite()
64 {
65 MockPipelineContext::SetUp();
66 GTEST_LOG_(INFO) << "FocusHierarchicalPageTestNG SetUpTestCase";
67 }
68
TearDownTestSuite()69 void FocusHierarchicalPageTestNG::TearDownTestSuite()
70 {
71 MockPipelineContext::TearDown();
72 GTEST_LOG_(INFO) << "FocusHierarchicalPageTestNG TearDownTestCase";
73 }
SetDefaultFocus(bool isDefaultFocus,bool isDefaultFocusAble,RefPtr<FocusHub> & focusHub)74 void SetDefaultFocus(bool isDefaultFocus, bool isDefaultFocusAble, RefPtr<FocusHub>& focusHub)
75 {
76 if (isDefaultFocus && isDefaultFocusAble) {
77 focusHub->SetIsDefaultFocus(true);
78 EXPECT_TRUE(focusHub->IsDefaultFocus());
79 }
80 }
IsCAlreadyFocus(bool isCAlreadyFocus,const RefPtr<FocusHub> & focusHub)81 void IsCAlreadyFocus(bool isCAlreadyFocus, const RefPtr<FocusHub>& focusHub)
82 {
83 if (!isCAlreadyFocus) {
84 focusHub->SetCurrentFocus(true);
85 EXPECT_TRUE(focusHub->IsCurrentFocus());
86 }
87 }
IsCFirstFocus(bool isCFirstFocus,const RefPtr<FocusHub> & focusHub)88 void IsCFirstFocus(bool isCFirstFocus, const RefPtr<FocusHub>& focusHub)
89 {
90 if (isCFirstFocus) {
91 focusHub->SetCurrentFocus(true);
92 EXPECT_TRUE(focusHub->IsCurrentFocus());
93 }
94 }
IsDependence(bool isDependence,const RefPtr<FocusHub> & focusHub)95 void IsDependence(bool isDependence, const RefPtr<FocusHub>& focusHub)
96 {
97 focusHub->SetFocusDependence(isDependence ? FocusDependence::SELF : FocusDependence::AUTO);
98 }
99
100 /**
101 * @tc.name: JudgMentDefaultFocus
102 * @tc.desc: judg Dependence RequestDefaultFocus.
103 * @tc.type: FUNC
104 */
JudgMentDefaultFocus(bool isDependenceC,RefPtr<FocusHub> & focusHub1,RefPtr<FocusHub> & focusHub2,RefPtr<FocusView> & focusView)105 void JudgMentDefaultFocus(
106 bool isDependenceC, RefPtr<FocusHub>& focusHub1, RefPtr<FocusHub>& focusHub2, RefPtr<FocusView>& focusView)
107 {
108 if (isDependenceC) {
109 focusView->RequestDefaultFocus();
110 EXPECT_TRUE(focusHub1->IsCurrentFocus());
111 }
112 focusView->RequestDefaultFocus();
113 EXPECT_TRUE(focusHub2->IsCurrentFocus());
114 }
115 HWTEST_F(FocusHierarchicalPageTestNG, FocusHierarchicalPageTestNG001, TestSize.Level1)
116 {
117 bool initResult = InitFocusTestBaseNG();
118 EXPECT_TRUE(initResult);
119 for (const auto& testCase : FOCUS_HIERARCHICAL_PAGE_CASES) {
120 /**
121 * @tc.steps: step2. Create scope root and focusHub.
122 * @tc.expected: root and focusHub not null.
123 */
124 auto rootNode = CreateRootNode();
125 EXPECT_NE(rootNode, nullptr);
126 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
127 EXPECT_NE(rootNodeFocusHub, nullptr);
128
129 /**
130 * @tc.steps: step2. Create scope page and focusHub and focusview.
131 * @tc.expected: page and focusHub and focusview not null.
132 */
133 std::list<int32_t> emptyList;
134 auto pageNodeC = CreateFocusViewWithFocusPattern("pageNodeC", emptyList, FocusType::SCOPE, true);
135 EXPECT_NE(pageNodeC, nullptr);
136 pageNodeC->UpdateInspectorId("PAGENODEC");
137 auto pageFocusHubC = pageNodeC->GetOrCreateFocusHub();
138 EXPECT_NE(pageFocusHubC, nullptr);
139 auto focusView = pageNodeC->GetPattern<FocusView>();
140 EXPECT_NE(focusView, nullptr);
141
142 /**
143 * @tc.steps: step2. Create scope columnnode and focusHub.
144 * @tc.expected: columnnode and focusHub not null.
145 */
146 auto columnPatternC = AceType::MakeRefPtr<LinearLayoutPattern>(true);
147 EXPECT_NE(columnPatternC, nullptr);
148 auto columnNodeC = FrameNodeOnTree::CreateFrameNode(V2::COLUMN_ETS_TAG, -1, columnPatternC);
149 EXPECT_NE(columnNodeC, nullptr);
150 auto columnFocusHubC = columnNodeC->GetOrCreateFocusHub();
151 EXPECT_NE(columnFocusHubC, nullptr);
152
153 /**
154 * @tc.steps: step2. Create scope buttonnode and focusHub.
155 * @tc.expected: buttonnode and focusHub not null.
156 */
157 auto buttonNodeE = CreateNodeWithFocusPattern("buttonNodeE", FocusType::NODE, true);
158 EXPECT_NE(buttonNodeE, nullptr);
159 buttonNodeE->UpdateInspectorId("BUTTONNODEE");
160 auto buttonFocusHubE = buttonNodeE->GetOrCreateFocusHub();
161 EXPECT_NE(buttonFocusHubE, nullptr);
162
163 rootNode->AddChild(pageNodeC);
164 pageNodeC->AddChild(columnNodeC);
165 columnNodeC->AddChild(buttonNodeE);
166
167 /**
168 * @tc.steps: step2. set isdefaultfocus.
169 */
170 SetDefaultFocus(testCase.isDefaultFocus, testCase.isDefaultFocusAble, buttonFocusHubE);
171 /**
172 * @tc.steps: step2. judge pagenode is firstfocus.
173 */
174 IsCFirstFocus(testCase.isCFirstFocus, pageFocusHubC);
175 /**
176 * @tc.steps: step2. judge pagenode is alreadyfocus.
177 */
178 IsCAlreadyFocus(testCase.isCAlreadyFocus, pageFocusHubC);
179 /**
180 * @tc.steps: step2. set pagenode dependence.
181 */
182 IsDependence(testCase.isDependenceC, pageFocusHubC);
183 /**
184 * @tc.steps: step2. create pipeline and focusManager.
185 * @tc.expected: pipeline and focusManager not null.
186 */
187 auto pipeline = pageNodeC->GetContextRefPtr();
188 EXPECT_NE(pipeline, nullptr);
189 auto focusManager = pipeline->GetFocusManager();
190 EXPECT_NE(focusManager, nullptr);
191 /**
192 * @tc.steps: step2. show focusview.
193 */
194 focusManager->FocusViewShow(focusView);
195 if (testCase.isDefaultFocusAble) {
196 if (!testCase.isCFirstFocus && testCase.nodeId == FocusHierarchicalCase::NODEE) {
197 pageFocusHubC->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(columnFocusHubC));
198 columnFocusHubC->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(buttonFocusHubE));
199 JudgMentDefaultFocus(testCase.isDependenceC, pageFocusHubC, buttonFocusHubE, focusView);
200 }
201 if (!testCase.isCFirstFocus && testCase.nodeId == FocusHierarchicalCase::NODEC) {
202 pageFocusHubC->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(columnFocusHubC));
203 JudgMentDefaultFocus(testCase.isDependenceC, pageFocusHubC, buttonFocusHubE, focusView);
204 }
205 if (testCase.isCFirstFocus && testCase.nodeId == FocusHierarchicalCase::NONE) {
206 JudgMentDefaultFocus(testCase.isDependenceC, pageFocusHubC, buttonFocusHubE, focusView);
207 }
208 }
209 focusManager->FocusViewShow(focusView);
210 focusView->RequestDefaultFocus();
211 EXPECT_TRUE(pageFocusHubC->IsCurrentFocus());
212 }
213 }
214 HWTEST_F(FocusHierarchicalPageTestNG, FocusSwiperTest001, TestSize.Level1)
215 {
216 /**
217 * @tc.steps: step2. Create scope root and focusHub.
218 * @tc.expected: root and focusHub not null.
219 */
220 auto rootNode = CreateRootNode();
221 EXPECT_NE(rootNode, nullptr);
222 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
223 EXPECT_NE(rootNodeFocusHub, nullptr);
224
225 /**
226 * @tc.steps: step2. Create scope swiperNode and focusHub.
227 * @tc.expected: swiperNode and focusHub not null.
228 */
229 auto swiperPattern = AceType::MakeRefPtr<SwiperPattern>();
230 auto swiperNode = FrameNodeOnTree::CreateFrameNode(V2::SWIPER_ETS_TAG, -1, swiperPattern);
231 EXPECT_NE(swiperNode, nullptr);
232 auto swiperFocusHub = swiperNode->GetOrCreateFocusHub();
233 EXPECT_NE(swiperFocusHub, nullptr);
234
235 /**
236 * @tc.steps: step2. Create scope navigationNode and focusHub.
237 * @tc.expected: navigationNode and focusHub not null.
238 */
239 auto navigationPattern = AceType::MakeRefPtr<NavigationPattern>();
240 auto navigationNode = FrameNodeOnTree::CreateFrameNode(V2::NAVIGATION_VIEW_ETS_TAG, -1, navigationPattern);
241 EXPECT_NE(navigationNode, nullptr);
242 auto navigationFocusHub = navigationNode->GetOrCreateFocusHub();
243 EXPECT_NE(navigationFocusHub, nullptr);
244
245 /**
246 * @tc.steps: step2. Create scope menuNode and focusHub.
247 * @tc.expected: menuNode and focusHub not null.
248 */
249 auto menuPattern = AceType::MakeRefPtr<MenuPattern>(-1, "Menu", MenuType::MENU);
250 auto menuNode = FrameNodeOnTree::CreateFrameNode(V2::MENU_ETS_TAG, -1, menuPattern);
251 EXPECT_NE(menuNode, nullptr);
252 auto menuFocusHub = menuNode->GetOrCreateFocusHub();
253 EXPECT_NE(menuFocusHub, nullptr);
254 rootNode->AddChild(swiperNode);
255 swiperNode->AddChild(navigationNode);
256 navigationNode->AddChild(menuNode);
257
258 /**
259 * @tc.steps: step2. set Focus Chain.
260 */
261 swiperFocusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(navigationFocusHub));
262 navigationFocusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(menuFocusHub));
263
264 /**
265 * @tc.steps: step2. create pipeline and focusManager.
266 * @tc.expected: pipeline and focusManager not null.
267 */
268 auto pipeline = swiperNode->GetContextRefPtr();
269 EXPECT_NE(pipeline, nullptr);
270 auto focusManager = pipeline->GetFocusManager();
271 EXPECT_NE(focusManager, nullptr);
272 auto focusView = menuNode->GetPattern<FocusView>();
273 EXPECT_NE(focusView, nullptr);
274 focusManager->FocusViewShow(focusView);
275 swiperFocusHub->SetParentFocusable(false);
276 EXPECT_FALSE(focusView->GetIsViewHasShow());
277 }
278 HWTEST_F(FocusHierarchicalPageTestNG, FocusViewWindowFocusTest001, TestSize.Level1)
279 {
280 /**
281 * @tc.steps: step2. Create scope root and focusHub.
282 * @tc.expected: root and focusHub not null.
283 */
284 auto rootNode = FrameNodeOnTree::CreateFrameNode(V2::ROOT_ETS_TAG, -1, AceType::MakeRefPtr<RootPattern>());
285 ASSERT_NE(rootNode, nullptr);
286 auto rootFocusHub = rootNode->GetOrCreateFocusHub();
287 ASSERT_NE(rootFocusHub, nullptr);
288 rootFocusHub->SetFocusType(FocusType::SCOPE);
289 rootNode->UpdateInspectorId("ROOTNODE");
290
291 /**
292 * @tc.steps: step2. Create page node and focusHub.
293 * @tc.expected: pageNode and focusHub not null.
294 */
295 auto pageNode = CreateNodeWithFocusPattern("nodeC", FocusType::SCOPE, true);
296 ASSERT_NE(pageNode, nullptr);
297 auto pageFocusHub = pageNode->GetOrCreateFocusHub();
298 ASSERT_NE(pageFocusHub, nullptr);
299 pageNode->UpdateInspectorId("PAGENODE");
300
301 /**
302 * @tc.steps: step2. Create focusViewNode and focusView and focusHub.
303 * @tc.expected: focusViewNode and focusView and focusHub not null.
304 */
305 std::list<int32_t> emptyList;
306 auto focusViewNode = CreateFocusViewWithFocusPattern("focusViewNode", emptyList, FocusType::NODE, true);
307 ASSERT_NE(focusViewNode, nullptr);
308 focusViewNode->UpdateInspectorId("FOCUSVIEW");
309 auto focusViewFocusHub = focusViewNode->GetOrCreateFocusHub();
310 ASSERT_NE(focusViewFocusHub, nullptr);
311 auto focusView = focusViewNode->GetPattern<FocusView>();
312 ASSERT_NE(focusView, nullptr);
313
314 rootNode->AddChild(pageNode);
315 pageNode->AddChild(focusViewNode);
316
317 /**
318 * @tc.steps: step2. Create pipeline and focusManager.
319 * @tc.expected: focusViewNode and focusView and focusHub not null.
320 */
321 auto pipeline = pageNode->GetContextRefPtr();
322 ASSERT_NE(pipeline, nullptr);
323 auto focusManager = pipeline->GetFocusManager();
324 ASSERT_NE(focusManager, nullptr);
325
326 /**
327 * @tc.expected: focusViewNode CurrentFocus
328 */
329 pageFocusHub->RequestFocusImmediately();
330 focusManager->FocusViewShow(focusView);
331 pipeline->WindowFocus(true);
332 EXPECT_TRUE(focusViewFocusHub->IsCurrentFocus());
333 }
334 HWTEST_F(FocusHierarchicalPageTestNG, FocusLostFocusToViewRootTest001, TestSize.Level1)
335 {
336 /**
337 * @tc.steps: step2. Create scope root and focusHub.
338 * @tc.expected: root and focusHub not null.
339 */
340 auto rootNode = CreateRootNode();
341 EXPECT_NE(rootNode, nullptr);
342 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
343 EXPECT_NE(rootNodeFocusHub, nullptr);
344
345 /**
346 * @tc.steps: step2. Create pageNode and focusview and focusHub.
347 * @tc.expected: pageNode and focusview and focusHub not null.
348 */
349 std::list<int32_t> emptyList;
350 auto pageNode = CreateFocusViewWithFocusPattern("pageNode", emptyList, FocusType::SCOPE, true);
351 EXPECT_NE(pageNode, nullptr);
352 pageNode->UpdateInspectorId("PAGENODE");
353 auto pageFocusHub = pageNode->GetOrCreateFocusHub();
354 EXPECT_NE(pageFocusHub, nullptr);
355 auto focusView = pageNode->GetPattern<FocusView>();
356 EXPECT_NE(focusView, nullptr);
357
358 /**
359 * @tc.steps: step2. Create columnNode1 and focusHub.
360 * @tc.expected: columnNode1 and focusHub not null.
361 */
362 auto columnNode1 = CreateNodeWithFocusPattern("buttonNode1", FocusType::NODE, true);
363 EXPECT_NE(columnNode1, nullptr);
364 columnNode1->UpdateInspectorId("BUTTONNODE1");
365 auto columnFocusHub1 = columnNode1->GetOrCreateFocusHub();
366 EXPECT_NE(columnFocusHub1, nullptr);
367
368 /**
369 * @tc.steps: step2. Create buttonNode1 and focusHub.
370 * @tc.expected: buttonNode1 and focusHub not null.
371 */
372 auto buttonNode1 = CreateNodeWithFocusPattern("buttonNode1", FocusType::NODE, true);
373 EXPECT_NE(buttonNode1, nullptr);
374 buttonNode1->UpdateInspectorId("BUTTONNODE1");
375 auto buttonFocusHub1 = buttonNode1->GetOrCreateFocusHub();
376 EXPECT_NE(buttonFocusHub1, nullptr);
377
378 /**
379 * @tc.steps: step2. add node tree.
380 */
381 rootNode->AddChild(pageNode);
382 pageNode->AddChild(columnNode1);
383 columnNode1->AddChild(buttonNode1);
384
385 /**
386 * @tc.steps: step2. add lastWeakFocusNode_.
387 * @tc.expected: root and focusHub not null.
388 */
389 pageFocusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(columnFocusHub1));
390 columnFocusHub1->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(buttonFocusHub1));
391
392 /**
393 * @tc.steps: step2. Create pipeline and focusManager.
394 * @tc.expected: root and focusHub not null.
395 */
396 auto pipeline = pageNode->GetContextRefPtr();
397 ASSERT_NE(pipeline, nullptr);
398 auto focusManager = pipeline->GetFocusManager();
399 ASSERT_NE(focusManager, nullptr);
400 focusManager->lastFocusView_ = AceType::WeakClaim(AceType::RawPtr(focusView));
401
402 /**
403 * @tc.steps: step2. lostfocus and anewfocus focus on root.
404 * @tc.expected: root and focusHub not null.
405 */
406 focusManager->FocusViewShow(focusView);
407 buttonFocusHub1->RequestFocusImmediately();
408 buttonFocusHub1->LostFocusToViewRoot();
409 focusManager->FocusViewHide(focusView);
410 focusManager->FocusViewShow(focusView);
411 pipeline->FlushFocusView();
412 EXPECT_TRUE(pageFocusHub->IsCurrentFocus());
413 }
414 HWTEST_F(FocusHierarchicalPageTestNG, FocusGetfocusleafTest001, TestSize.Level1)
415 {
416 /**
417 * @tc.steps: step2. Create scope root and focusHub.
418 * @tc.expected: root and focusHub not null.
419 */
420 auto rootNode = CreateRootNode();
421 EXPECT_NE(rootNode, nullptr);
422 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
423 EXPECT_NE(rootNodeFocusHub, nullptr);
424
425 /**
426 * @tc.steps: step2. Create pageNode and focusHub and focusview.
427 * @tc.expected: pageNode and focusHub and focusview not null.
428 */
429 std::list<int32_t> emptyList;
430 auto pageNode = CreateFocusViewWithFocusPattern("pageNode", emptyList, FocusType::SCOPE, true);
431 EXPECT_NE(pageNode, nullptr);
432 pageNode->UpdateInspectorId("PAGENODE");
433 auto pageFocusHub = pageNode->GetOrCreateFocusHub();
434 pageFocusHub->SetFocusDependence(FocusDependence::AUTO);
435 EXPECT_NE(pageFocusHub, nullptr);
436 auto focusView = pageNode->GetPattern<FocusView>();
437 EXPECT_NE(focusView, nullptr);
438
439 /**
440 * @tc.steps: step2. Create columnNode1 and focusHub.
441 * @tc.expected: columnNode1 and focusHub not null.
442 */
443 auto columnNode1 = CreateNodeWithFocusPattern("columnNode1", FocusType::SCOPE, true);
444 EXPECT_NE(columnNode1, nullptr);
445 columnNode1->UpdateInspectorId("columnNode1");
446 auto columnFocusHub1 = columnNode1->GetOrCreateFocusHub();
447 EXPECT_NE(columnFocusHub1, nullptr);
448 columnFocusHub1->SetFocusDependence(FocusDependence::AUTO);
449
450 /**
451 * @tc.steps: step2. Create columnNode2 and focusHub.
452 * @tc.expected: columnNode2 and focusHub not null.
453 */
454 auto columnNode2 = CreateNodeWithFocusPattern("columnNode2", FocusType::NODE, true);
455 EXPECT_NE(columnNode2, nullptr);
456 columnNode2->UpdateInspectorId("columnNode2");
457 auto columnFocusHub2 = columnNode2->GetOrCreateFocusHub();
458 EXPECT_NE(columnFocusHub2, nullptr);
459 columnFocusHub2->SetFocusDependence(FocusDependence::AUTO);
460
461 /**
462 * @tc.steps: step2. Create buttonNode1 and focusHub.
463 * @tc.expected: buttonNode1 and focusHub not null.
464 */
465 auto buttonNode1 = CreateNodeWithFocusPattern("buttonNode1", FocusType::NODE, true);
466 EXPECT_NE(buttonNode1, nullptr);
467 buttonNode1->UpdateInspectorId("BUTTONNODE1");
468 auto buttonFocusHub1 = buttonNode1->GetOrCreateFocusHub();
469 EXPECT_NE(buttonFocusHub1, nullptr);
470
471 /**
472 * @tc.steps: step2. Create buttonNode2 and focusHub.
473 * @tc.expected: buttonNode2 and focusHub not null.
474 */
475 auto buttonNode2 = CreateNodeWithFocusPattern("buttonNode2", FocusType::NODE, true);
476 EXPECT_NE(buttonNode2, nullptr);
477 buttonNode1->UpdateInspectorId("BUTTONNODE2");
478 auto buttonFocusHub2 = buttonNode2->GetOrCreateFocusHub();
479 EXPECT_NE(buttonFocusHub2, nullptr);
480
481 /**
482 * @tc.steps: step2. add node tree.
483 * @tc.expected: buttonNode2 and focusHub not null.
484 */
485 rootNode->AddChild(pageNode);
486 pageNode->AddChild(columnNode1);
487 columnNode1->AddChild(columnNode2);
488 columnNode2->AddChild(buttonNode1);
489 columnNode2->AddChild(buttonNode2);
490
491
492 pageFocusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(columnFocusHub1));
493 columnFocusHub1->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(columnFocusHub2));
494 columnFocusHub2->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(buttonFocusHub1));
495
496 /**
497 * @tc.steps: step2. Create pipeline and focusManager.
498 * @tc.expected: root and focusHub not null.
499 */
500 auto pipeline = pageNode->GetContextRefPtr();
501 ASSERT_NE(pipeline, nullptr);
502 auto focusManager = pipeline->GetFocusManager();
503 ASSERT_NE(focusManager, nullptr);
504
505 /**
506 * @tc.steps: step2. Follow the memory to find focus.
507 * @tc.expected: focusHub EQ buttonFocusHub1.
508 */
509 focusManager->FocusViewShow(focusView);
510 buttonFocusHub1->RequestFocusImmediately();
511 buttonFocusHub1->LostFocusToViewRoot();
512 focusManager->FocusViewHide(focusView);
513 focusManager->FocusViewShow(focusView);
514 auto focusHub = pageFocusHub->GetFocusLeaf();
515 EXPECT_EQ(focusHub->GetFrameId(), buttonFocusHub1->GetFrameId());
516 }
517 HWTEST_F(FocusHierarchicalPageTestNG, TabFocusTest001, TestSize.Level1)
518 {
519 /**
520 * @tc.steps: step2. Create scope root and focusHub.
521 * @tc.expected: root and focusHub not null.
522 */
523 auto rootNode = CreateRootNode();
524 EXPECT_NE(rootNode, nullptr);
525 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
526 EXPECT_NE(rootNodeFocusHub, nullptr);
527
528 /**
529 * @tc.steps: step2. Create pageNode and focusview and focusHub.
530 * @tc.expected: pageNode and focusview and focusHub not null.
531 */
532 std::list<int32_t> emptyList;
533 auto pageNode = CreateFocusViewWithFocusPattern("pageNode", emptyList, FocusType::SCOPE, true);
534 EXPECT_NE(pageNode, nullptr);
535 pageNode->UpdateInspectorId("PAGENODE");
536 auto pageFocusHub = pageNode->GetOrCreateFocusHub();
537 pageFocusHub->SetFocusDependence(FocusDependence::AUTO);
538 EXPECT_NE(pageFocusHub, nullptr);
539 auto focusView = pageNode->GetPattern<FocusView>();
540 EXPECT_NE(focusView, nullptr);
541
542 /**
543 * @tc.steps: step2. Create columnNode1 and focusHub.
544 * @tc.expected: columnNode1 and focusHub not null.
545 */
546 auto columnNode1 = CreateNodeWithFocusPattern("columnNode1", FocusType::SCOPE, true);
547 EXPECT_NE(columnNode1, nullptr);
548 columnNode1->UpdateInspectorId("columnNode1");
549 auto columnFocusHub1 = columnNode1->GetOrCreateFocusHub();
550 EXPECT_NE(columnFocusHub1, nullptr);
551 columnFocusHub1->SetFocusDependence(FocusDependence::AUTO);
552
553 /**
554 * @tc.steps: step2. Create columnNode2 and focusHub.
555 * @tc.expected: columnNode2 and focusHub not null.
556 */
557 auto columnNode2 = CreateNodeWithFocusPattern("columnNode2", FocusType::NODE, true);
558 EXPECT_NE(columnNode2, nullptr);
559 columnNode2->UpdateInspectorId("columnNode2");
560 auto columnFocusHub2 = columnNode2->GetOrCreateFocusHub();
561 EXPECT_NE(columnFocusHub2, nullptr);
562 columnFocusHub2->SetFocusDependence(FocusDependence::AUTO);
563
564 /**
565 * @tc.steps: step2. Create buttonNode1 and focusHub.
566 * @tc.expected: buttonNode1 and focusHub not null.
567 */
568 auto buttonNode1 = CreateNodeWithFocusPattern("buttonNode1", FocusType::NODE, true);
569 EXPECT_NE(buttonNode1, nullptr);
570 buttonNode1->UpdateInspectorId("BUTTONNODE1");
571 auto buttonFocusHub1 = buttonNode1->GetOrCreateFocusHub();
572 EXPECT_NE(buttonFocusHub1, nullptr);
573
574 /**
575 * @tc.steps: step2. Create buttonNode2 and focusHub.
576 * @tc.expected: buttonNode2 and focusHub not null.
577 */
578 auto buttonNode2 = CreateNodeWithFocusPattern("buttonNode2", FocusType::NODE, true);
579 EXPECT_NE(buttonNode2, nullptr);
580 buttonNode1->UpdateInspectorId("BUTTONNODE2");
581 auto buttonFocusHub2 = buttonNode2->GetOrCreateFocusHub();
582 EXPECT_NE(buttonFocusHub2, nullptr);
583
584 rootNode->AddChild(pageNode);
585 pageNode->AddChild(columnNode1);
586 columnNode1->AddChild(columnNode2);
587 columnNode2->AddChild(buttonNode1);
588 columnNode2->AddChild(buttonNode2);
589
590 pageFocusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(columnFocusHub1));
591 columnFocusHub1->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(columnFocusHub2));
592 columnFocusHub2->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(buttonFocusHub2));
593
594 /**
595 * @tc.steps: step2. Create pipeline and focusManager.
596 * @tc.expected: pipeline and focusManager not null.
597 */
598 auto pipeline = pageNode->GetContextRefPtr();
599 ASSERT_NE(pipeline, nullptr);
600 auto focusManager = pipeline->GetFocusManager();
601 ASSERT_NE(focusManager, nullptr);
602
603 /**
604 * @tc.steps: step2. Out of focus and then regain focus as TAB buttonFocusHub2.
605 * @tc.expected: Press tab focus is buttonFocusHub2.
606 */
607 focusManager->FocusViewShow(focusView);
608 buttonFocusHub2->RequestFocusImmediately();
609 buttonFocusHub2->LostFocusToViewRoot();
610 focusManager->FocusViewHide(focusView);
611 focusManager->FocusViewShow(focusView);
612 KeyEvent event;
613 event.code = KeyCode::KEY_TAB;
614 event.action = KeyAction::DOWN;
615 event.pressedCodes = {KeyCode::KEY_TAB};
616 focusManager->isFocusActive_ = true;
617 pipeline->eventManager_->isTabJustTriggerOnKeyEvent_ = false;
618 event.eventType = UIInputEventType::KEY;
619 focusManager->keyProcessingMode_ = KeyProcessingMode::ANCESTOR_EVENT;
620 auto res = pageFocusHub->HandleEvent(event);
621 EXPECT_TRUE(res);
622 EXPECT_TRUE(buttonFocusHub2->IsCurrentFocus());
623 }
624 HWTEST_F(FocusHierarchicalPageTestNG, TabOnFocusTest001, TestSize.Level1)
625 {
626 /**
627 * @tc.steps: step2. Create scope root and focusHub.
628 * @tc.expected: root and focusHub not null.
629 */
630 auto rootNode = CreateRootNode();
631 EXPECT_NE(rootNode, nullptr);
632 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
633 EXPECT_NE(rootNodeFocusHub, nullptr);
634
635 /**
636 * @tc.steps: step2. Create pageNode and focusView and focusHub.
637 * @tc.expected: pageNode and focusView and focusHub not null.
638 */
639 std::list<int32_t> emptyList;
640 auto pageNode = CreateFocusViewWithFocusPattern("pageNode", emptyList, FocusType::SCOPE, true);
641 EXPECT_NE(pageNode, nullptr);
642 pageNode->UpdateInspectorId("PAGENODE");
643 auto pageFocusHub = pageNode->GetOrCreateFocusHub();
644 pageFocusHub->SetFocusDependence(FocusDependence::AUTO);
645 EXPECT_NE(pageFocusHub, nullptr);
646 auto focusView = pageNode->GetPattern<FocusView>();
647 EXPECT_NE(focusView, nullptr);
648
649 /**
650 * @tc.steps: step2. Create columnNode1 and focusHub.
651 * @tc.expected: columnNode1 and focusHub not null.
652 */
653 auto columnNode1 = CreateNodeWithFocusPattern("columnNode1", FocusType::SCOPE, false);
654 EXPECT_NE(columnNode1, nullptr);
655 columnNode1->UpdateInspectorId("columnNode1");
656 auto columnFocusHub1 = columnNode1->GetOrCreateFocusHub();
657 EXPECT_NE(columnFocusHub1, nullptr);
658 columnFocusHub1->SetFocusDependence(FocusDependence::AUTO);
659
660 /**
661 * @tc.steps: step2. Create columnNode2 and focusHub.
662 * @tc.expected: columnNode2 and focusHub not null.
663 */
664 auto columnNode2 = CreateNodeWithFocusPattern("columnNode2", FocusType::NODE, false);
665 EXPECT_NE(columnNode2, nullptr);
666 columnNode2->UpdateInspectorId("columnNode2");
667 auto columnFocusHub2 = columnNode2->GetOrCreateFocusHub();
668 EXPECT_NE(columnFocusHub2, nullptr);
669 columnFocusHub2->SetFocusDependence(FocusDependence::AUTO);
670
671 /**
672 * @tc.steps: step2. Create buttonNode1 and focusHub.
673 * @tc.expected: buttonNode1 and focusHub not null.
674 */
675 auto buttonNode1 = CreateNodeWithFocusPattern("buttonNode1", FocusType::NODE, false);
676 EXPECT_NE(buttonNode1, nullptr);
677 buttonNode1->UpdateInspectorId("BUTTONNODE1");
678 auto buttonFocusHub1 = buttonNode1->GetOrCreateFocusHub();
679 EXPECT_NE(buttonFocusHub1, nullptr);
680
681 rootNode->AddChild(pageNode);
682 pageNode->AddChild(columnNode1);
683 columnNode1->AddChild(columnNode2);
684 columnNode2->AddChild(buttonNode1);
685
686 /**
687 * @tc.steps: step2. Create pipeline and focusManager.
688 * @tc.expected: pipeline and focusManager not null.
689 */
690 auto pipeline = pageNode->GetContextRefPtr();
691 ASSERT_NE(pipeline, nullptr);
692 auto focusManager = pipeline->GetFocusManager();
693 ASSERT_NE(focusManager, nullptr);
694
695 /**
696 * @tc.steps: step2. Create Register the callback function.
697 * @tc.steps: step2. Pressing tab does not trigger a callback.
698 * @tc.expected: focusCount add 1.
699 */
700 int32_t focusCount = 0;
__anonf3ef64850102() 701 pageFocusHub->SetOnFocusCallback(([&focusCount]() {
702 focusCount++;
703 }));
704 pageFocusHub->RequestFocusImmediately();
705 EXPECT_EQ(focusCount, 1);
706 KeyEvent event;
707 event.code = KeyCode::KEY_TAB;
708 event.action = KeyAction::DOWN;
709 event.pressedCodes = {KeyCode::KEY_TAB};
710 focusManager->isFocusActive_ = true;
711 pipeline->eventManager_->isTabJustTriggerOnKeyEvent_ = false;
712 event.eventType = UIInputEventType::KEY;
713 focusManager->keyProcessingMode_ = KeyProcessingMode::ANCESTOR_EVENT;
714 auto res = pageFocusHub->HandleEvent(event);
715 EXPECT_TRUE(res);
716 EXPECT_EQ(focusCount, 1);
717 }
718 } // namespace OHOS::Ace::NG
719