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/pattern/test_ng.h"
27
28 #include "base/log/log_wrapper.h"
29 #include "core/components/container_modal/container_modal_constants.h"
30 #include "core/components/theme/theme_constants.h"
31 #include "core/components_ng/base/ui_node.h"
32 #include "core/components_ng/base/view_stack_processor.h"
33 #include "core/components_ng/event/focus_hub.h"
34 #include "core/components_ng/event/focus_state.h"
35 #include "core/components_ng/pattern/button/button_pattern.h"
36 #include "core/components_ng/pattern/container_modal/container_modal_pattern.h"
37 #include "core/components_ng/pattern/container_modal/container_modal_theme.h"
38 #include "core/components_ng/pattern/container_modal/container_modal_view.h"
39 #include "core/components_ng/pattern/image/image_layout_property.h"
40 #include "core/components_ng/pattern/image/image_pattern.h"
41 #include "core/components_ng/pattern/linear_layout/linear_layout_pattern.h"
42 #include "core/components_ng/pattern/pattern.h"
43 #include "core/components_ng/pattern/root/root_pattern.h"
44 #include "core/components_ng/pattern/stack/stack_pattern.h"
45 #include "core/components_ng/pattern/text/text_pattern.h"
46 #include "core/components_ng/pattern/text_picker/textpicker_column_pattern.h"
47 #include "core/pipeline_ng/pipeline_context.h"
48
49 using namespace testing;
50 using namespace testing::ext;
51 namespace OHOS::Ace::NG {
52
53 const std::vector<FocusRequestTestCase> FOCUS_TEST_REQUEST_CASES = {
54 // case1
55 FocusRequestTestCase(FocusRequestFocusAble { true, true }, true, true, true, "NODEA", { true, false }),
56 // case2
57 FocusRequestTestCase(FocusRequestFocusAble { true, true }, true, true, true, "NODEB", { false, true }),
58 // case3
59 FocusRequestTestCase(FocusRequestFocusAble { true, true }, true, false, true, "NODEA", { true, false }),
60 // case4
61 FocusRequestTestCase(FocusRequestFocusAble { true, true }, true, false, true, "NODEB", { false, true }),
62 // case5
63 FocusRequestTestCase(FocusRequestFocusAble { true, true }, false, true, true, "NODEA", { false, true }),
64 // case6
65 FocusRequestTestCase(FocusRequestFocusAble { true, true }, false, true, true, "NODEB", { false, true }),
66 // case7
67 FocusRequestTestCase(FocusRequestFocusAble { true, true }, false, false, true, "NODEA", { false, true }),
68 // case8
69 FocusRequestTestCase(FocusRequestFocusAble { true, true }, false, false, true, "NODEB", { false, true }),
70 // case9
71 FocusRequestTestCase(FocusRequestFocusAble { true, false }, true, false, true, "NODEA", { true, false }),
72 // case10
73 FocusRequestTestCase(FocusRequestFocusAble { true, false }, true, false, true, "NODEB", { false, false }),
74 // case11
75 FocusRequestTestCase(FocusRequestFocusAble { true, false }, true, false, true, "NODEA", { true, false }),
76 // case12
77 FocusRequestTestCase(FocusRequestFocusAble { true, false }, true, false, true, "NODEB", { false, false }),
78 };
79
SetUpTestSuite()80 void FocusRequestTestNG::SetUpTestSuite()
81 {
82 MockPipelineContext::SetUp();
83 GTEST_LOG_(INFO) << "FocusRequestTestNG SetUpTestCase";
84 }
85
TearDownTestSuite()86 void FocusRequestTestNG::TearDownTestSuite()
87 {
88 MockPipelineContext::TearDown();
89 GTEST_LOG_(INFO) << "FocusRequestTestNG TearDownTestCase";
90 }
91
IsRequestFocusStateEqual(int32_t caseNum,const std::vector<bool> & actualState,const std::vector<bool> & expectState)92 testing::AssertionResult FocusRequestTestNG::IsRequestFocusStateEqual(
93 int32_t caseNum, const std::vector<bool>& actualState, const std::vector<bool>& expectState)
94 {
95 auto length = actualState.size();
96 for (int32_t i = 0; i < length; i++) {
97 if (actualState[i] != expectState[i]) {
98 return testing::AssertionFailure()
99 << "TestCaseNum: " << caseNum << ", NodeId: " << i << ", actual state: " << actualState[i]
100 << ", expect state: " << expectState[i];
101 }
102 }
103 return testing::AssertionSuccess();
104 }
CreatNode(bool isFocusable)105 RefPtr<FrameNode> FocusRequestTestNG::CreatNode(bool isFocusable)
106 {
107 auto node = CreateNodeWithFocusPattern("node", FocusType::NODE, isFocusable);
108 EXPECT_NE(node, nullptr);
109 node->UpdateInspectorId("NODE");
110 return node;
111 }
SetDependence(bool isDependenceSelf,const RefPtr<FocusHub> & focusHub)112 void FocusRequestTestNG::SetDependence(bool isDependenceSelf, const RefPtr<FocusHub>& focusHub)
113 {
114 if (isDependenceSelf) {
115 focusHub->SetFocusDependence(FocusDependence::SELF);
116 } else {
117 focusHub->SetFocusDependence(FocusDependence::AUTO);
118 }
119 }
SetWindowSwiping(bool isWindowSwiping)120 void FocusRequestTestNG::SetWindowSwiping(bool isWindowSwiping)
121 {
122 if (isWindowSwiping) {
123 auto context = PipelineBase::GetCurrentContext();
124 context->RequestFrame();
125 }
126 }
SetFcousCurrents(const RefPtr<FocusHub> & focusHub,const RefPtr<FrameNode> & node)127 void FocusRequestTestNG::SetFcousCurrents(const RefPtr<FocusHub>& focusHub, const RefPtr<FrameNode>& node)
128 {
129 auto pipeline = AceType::MakeRefPtr<MockPipelineContext>();
130 focusHub->RequestFocus();
131 pipeline->dirtyFocusNode_ = AceType::WeakClaim(AceType::RawPtr(node));
132 pipeline->dirtyRequestFocusNode_ = AceType::WeakClaim(AceType::RawPtr(node));
133 pipeline->FlushFocus();
134 }
InitFocusRequest()135 void FocusRequestTestNG::InitFocusRequest()
136 {
137 int32_t caseNum = 1;
138 for (const auto& testCase : FOCUS_TEST_REQUEST_CASES) {
139 auto rootNode = CreateRootNode();
140 EXPECT_NE(rootNode, nullptr);
141 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
142 EXPECT_NE(rootNodeFocusHub, nullptr);
143
144 auto nodeA = CreatNode(testCase.isFocusable.isAFocusable);
145 auto focusHubA = nodeA->GetOrCreateFocusHub();
146 EXPECT_NE(focusHubA, nullptr);
147
148 auto nodeB = CreatNode(testCase.isFocusable.isBFocusable);
149 auto focusHubB = nodeB->GetOrCreateFocusHub();
150 EXPECT_NE(focusHubB, nullptr);
151
152 rootNode->AddChild(nodeA);
153 nodeA->AddChild(nodeB);
154
155 SetDependence(testCase.isADependenceSelf, focusHubA);
156 SetWindowSwiping(testCase.isWindowSwiping);
157 nodeA->onMainTree_ = testCase.isAOnMainTree;
158 nodeB->onMainTree_ = testCase.isAOnMainTree;
159
160 if (testCase.isFocusable.isAFocusable) {
161 if ((!testCase.isFocusable.isBFocusable && testCase.inspectorId == "NODEA") ||
162 (testCase.isADependenceSelf && testCase.inspectorId == "NODEA")) {
163 SetFcousCurrents(focusHubA, nodeA);
164 }
165 if ((!testCase.isADependenceSelf && testCase.inspectorId == "NODEA") ||
166 (testCase.isFocusable.isBFocusable && testCase.inspectorId == "NODEB")) {
167 SetFcousCurrents(focusHubB, nodeB);
168 }
169 }
170
171 std::vector<bool> results = { focusHubA->IsCurrentFocus(), focusHubB->IsCurrentFocus() };
172 EXPECT_TRUE(IsRequestFocusStateEqual(caseNum, results, testCase.expectResults));
173 caseNum++;
174 }
175 }
176
177 HWTEST_F(FocusRequestTestNG, FocusRequestTest001, TestSize.Level1)
178 {
179 bool initResult = InitFocusTestBaseNG();
180 EXPECT_TRUE(initResult);
181 InitFocusRequest();
182 }
183
184 /**
185 * @tc.name: TriggerFocusMoveWithTabIndex001
186 * @tc.desc:
187 * @tc.type: FUNC
188 */
189 HWTEST_F(FocusRequestTestNG, TriggerFocusMoveWithTabIndex001, TestSize.Level1)
190 {
191 bool initResult = InitFocusTestBaseNG();
192 EXPECT_TRUE(initResult);
193 /**
194 * @tc.steps: step1. Create rootNode and focusHub.
195 * @tc.expected: rootNode and focusHub not null.
196 */
197 auto rootNode = CreateRootNode();
198 EXPECT_NE(rootNode, nullptr);
199 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
200 EXPECT_NE(rootNodeFocusHub, nullptr);
201 rootNode->onMainTree_ = true;
202
203 /**
204 * @tc.steps: step2. Create scope testFocusView and focusHub.
205 * @tc.expected: testFocusView and focusHub not null.
206 */
207 std::list<int32_t> emptyList;
208 auto testFocusView = CreateFocusViewWithFocusPattern("nodeA", emptyList, FocusType::SCOPE, true);
209 EXPECT_NE(testFocusView, nullptr);
210 testFocusView->UpdateInspectorId("testFocusView");
211 auto testFocusViewHub = testFocusView->GetOrCreateFocusHub();
212 EXPECT_NE(testFocusViewHub, nullptr);
213 auto testFocusViewPattern = testFocusView->GetPattern<FocusView>();
214 EXPECT_NE(testFocusViewPattern, nullptr);
215 testFocusViewPattern->SetIsViewRootScopeFocused(true);
216
217 /**
218 * @tc.steps: step3. Create nodeA and focusHub.
219 * @tc.expected: nodeA and focusHub not null.
220 */
221 auto nodeA = CreateNodeWithFocusPattern("nodeA", FocusType::NODE, true);
222 EXPECT_NE(nodeA, nullptr);
223 nodeA->UpdateInspectorId("NODEA");
224 auto focusHubA = nodeA->GetOrCreateFocusHub();
225 EXPECT_NE(focusHubA, nullptr);
226 focusHubA->SetTabIndex(-1);
227
228 /**
229 * @tc.steps: step4. Create nodeB and focusHub.
230 * @tc.expected: nodeB and focusHub not null.
231 */
232 auto nodeB = CreateNodeWithFocusPattern("nodeB", FocusType::NODE, true);
233 EXPECT_NE(nodeB, nullptr);
234 nodeB->UpdateInspectorId("NODEB");
235 auto focusHubB = nodeB->GetOrCreateFocusHub();
236 EXPECT_NE(focusHubB, nullptr);
237
238 /**
239 * @tc.steps: step5. Create tree.
240 */
241 rootNode->AddChild(testFocusView);
242 testFocusView->AddChild(nodeA);
243 testFocusView->AddChild(nodeB);
244 testFocusView->onMainTree_ = true;
245 nodeA->onMainTree_ = true;
246 nodeB->onMainTree_ = true;
247
248 /**
249 * @tc.steps: step6. testFocusViewHub request focus.
250 * @tc.expected: testFocusViewHub focus. focusHubA not focus. focusHubB not focus.
251 */
252 testFocusViewHub->RequestFocusImmediatelyInner();
253 EXPECT_EQ(testFocusViewHub->IsCurrentFocus(), true);
254 EXPECT_EQ(focusHubA->IsCurrentFocus(), false);
255 EXPECT_EQ(focusHubB->IsCurrentFocus(), false);
256
257 /**
258 * @tc.steps: step7. ExtendOrActivateFocus.
259 * @tc.expected: focusHubA not focus. focusHubB focus.
260 */
261 EXPECT_NE(focusManager_, nullptr);
262 focusManager_->ExtendOrActivateFocus(testFocusViewPattern);
263 EXPECT_EQ(focusHubA->IsCurrentFocus(), true);
264 EXPECT_EQ(focusHubB->IsCurrentFocus(), false);
265 }
266
267 /**
268 * @tc.name: TriggerFocusMoveWithTabIndex002
269 * @tc.desc:
270 * @tc.type: FUNC
271 */
272 HWTEST_F(FocusRequestTestNG, TriggerFocusMoveWithTabIndex002, TestSize.Level1)
273 {
274 bool initResult = InitFocusTestBaseNG();
275 EXPECT_TRUE(initResult);
276 /**
277 * @tc.steps: step1. Create rootNode and focusHub.
278 * @tc.expected: rootNode and focusHub not null.
279 */
280 auto rootNode = CreateRootNode();
281 EXPECT_NE(rootNode, nullptr);
282 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
283 EXPECT_NE(rootNodeFocusHub, nullptr);
284 rootNode->onMainTree_ = true;
285
286 /**
287 * @tc.steps: step2. Create scope testFocusView and focusHub.
288 * @tc.expected: testFocusView and focusHub not null.
289 */
290 std::list<int32_t> emptyList;
291 auto testFocusView = CreateFocusViewWithFocusPattern("nodeA", emptyList, FocusType::SCOPE, true);
292 EXPECT_NE(testFocusView, nullptr);
293 testFocusView->UpdateInspectorId("testFocusView");
294 auto testFocusViewHub = testFocusView->GetOrCreateFocusHub();
295 EXPECT_NE(testFocusViewHub, nullptr);
296 auto testFocusViewPattern = testFocusView->GetPattern<FocusView>();
297 EXPECT_NE(testFocusViewPattern, nullptr);
298 testFocusViewPattern->SetIsViewRootScopeFocused(true);
299
300 /**
301 * @tc.steps: step3. Create nodeA and focusHub.
302 * @tc.expected: nodeA and focusHub not null.
303 */
304 auto nodeA = CreateNodeWithFocusPattern("nodeA", FocusType::NODE, true);
305 EXPECT_NE(nodeA, nullptr);
306 nodeA->UpdateInspectorId("NODEA");
307 auto focusHubA = nodeA->GetOrCreateFocusHub();
308 EXPECT_NE(focusHubA, nullptr);
309 focusHubA->SetTabIndex(1);
310
311 /**
312 * @tc.steps: step4. Create nodeB and focusHub.
313 * @tc.expected: nodeB and focusHub not null.
314 */
315 auto nodeB = CreateNodeWithFocusPattern("nodeB", FocusType::NODE, true);
316 EXPECT_NE(nodeB, nullptr);
317 nodeB->UpdateInspectorId("NODEB");
318 auto focusHubB = nodeB->GetOrCreateFocusHub();
319 EXPECT_NE(focusHubB, nullptr);
320
321 /**
322 * @tc.steps: step5. Create tree.
323 */
324 rootNode->AddChild(testFocusView);
325 testFocusView->AddChild(nodeA);
326 testFocusView->AddChild(nodeB);
327 testFocusView->onMainTree_ = true;
328 nodeA->onMainTree_ = true;
329 nodeB->onMainTree_ = true;
330
331 /**
332 * @tc.steps: step6. testFocusViewHub request focus.
333 * @tc.expected: testFocusViewHub focus. focusHubA not focus. focusHubB not focus.
334 */
335 testFocusViewHub->RequestFocusImmediatelyInner();
336 EXPECT_EQ(testFocusViewHub->IsCurrentFocus(), true);
337 EXPECT_EQ(focusHubA->IsCurrentFocus(), false);
338 EXPECT_EQ(focusHubB->IsCurrentFocus(), false);
339
340 /**
341 * @tc.steps: step7. ExtendOrActivateFocus.
342 * @tc.expected: focusHubA focus. focusHubB not focus.
343 */
344 EXPECT_NE(focusManager_, nullptr);
345 focusManager_->ExtendOrActivateFocus(testFocusViewPattern);
346 EXPECT_EQ(focusHubA->IsCurrentFocus(), true);
347 EXPECT_EQ(focusHubB->IsCurrentFocus(), false);
348 }
349
350 /**
351 * @tc.name: TriggerFocusMoveWithTabIndex003
352 * @tc.desc:
353 * @tc.type: FUNC
354 */
355 HWTEST_F(FocusRequestTestNG, TriggerFocusMoveWithTabIndex003, TestSize.Level1)
356 {
357 bool initResult = InitFocusTestBaseNG();
358 EXPECT_TRUE(initResult);
359 /**
360 * @tc.steps: step1. Create rootNode and focusHub.
361 * @tc.expected: rootNode and focusHub not null.
362 */
363 auto rootNode = CreateRootNode();
364 EXPECT_NE(rootNode, nullptr);
365 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
366 EXPECT_NE(rootNodeFocusHub, nullptr);
367 rootNode->onMainTree_ = true;
368
369 /**
370 * @tc.steps: step2. Create scope testFocusView and focusHub.
371 * @tc.expected: testFocusView and focusHub not null.
372 */
373 std::list<int32_t> emptyList;
374 auto testFocusView = CreateFocusViewWithFocusPattern("nodeA", emptyList, FocusType::SCOPE, true);
375 EXPECT_NE(testFocusView, nullptr);
376 testFocusView->UpdateInspectorId("testFocusView");
377 auto testFocusViewHub = testFocusView->GetOrCreateFocusHub();
378 EXPECT_NE(testFocusViewHub, nullptr);
379 auto testFocusViewPattern = testFocusView->GetPattern<FocusView>();
380 EXPECT_NE(testFocusViewPattern, nullptr);
381 testFocusViewPattern->SetIsViewRootScopeFocused(false);
382
383 /**
384 * @tc.steps: step3. Create nodeA and focusHub.
385 * @tc.expected: nodeA and focusHub not null.
386 */
387 auto nodeA = CreateNodeWithFocusPattern("nodeA", FocusType::NODE, true);
388 EXPECT_NE(nodeA, nullptr);
389 nodeA->UpdateInspectorId("NODEA");
390 auto focusHubA = nodeA->GetOrCreateFocusHub();
391 EXPECT_NE(focusHubA, nullptr);
392 focusHubA->SetTabIndex(-1);
393
394 /**
395 * @tc.steps: step4. Create nodeB and focusHub.
396 * @tc.expected: nodeB and focusHub not null.
397 */
398 auto nodeB = CreateNodeWithFocusPattern("nodeB", FocusType::NODE, true);
399 EXPECT_NE(nodeB, nullptr);
400 nodeB->UpdateInspectorId("NODEB");
401 auto focusHubB = nodeB->GetOrCreateFocusHub();
402 EXPECT_NE(focusHubB, nullptr);
403
404 /**
405 * @tc.steps: step5. Create tree.
406 */
407 rootNode->AddChild(testFocusView);
408 testFocusView->AddChild(nodeA);
409 testFocusView->AddChild(nodeB);
410 testFocusView->onMainTree_ = true;
411 nodeA->onMainTree_ = true;
412 nodeB->onMainTree_ = true;
413
414 /**
415 * @tc.steps: step6. testFocusViewHub request focus.
416 * @tc.expected: testFocusViewHub focus. focusHubA not focus. focusHubB not focus.
417 */
418 testFocusViewHub->RequestFocusImmediatelyInner();
419 EXPECT_EQ(testFocusViewHub->IsCurrentFocus(), true);
420 EXPECT_EQ(focusHubA->IsCurrentFocus(), true);
421 EXPECT_EQ(focusHubB->IsCurrentFocus(), false);
422
423 /**
424 * @tc.steps: step7. ExtendOrActivateFocus.
425 * @tc.expected: focusHubA focus. focusHubB not focus.
426 */
427 EXPECT_NE(focusManager_, nullptr);
428 focusManager_->ExtendOrActivateFocus(testFocusViewPattern);
429 EXPECT_EQ(focusHubA->IsCurrentFocus(), true);
430 EXPECT_EQ(focusHubB->IsCurrentFocus(), false);
431 }
432
433 /**
434 * @tc.name: TriggerFocusMoveWithTabIndex004
435 * @tc.desc:
436 * @tc.type: FUNC
437 */
438 HWTEST_F(FocusRequestTestNG, TriggerFocusMoveWithTabIndex004, TestSize.Level1)
439 {
440 bool initResult = InitFocusTestBaseNG();
441 EXPECT_TRUE(initResult);
442 /**
443 * @tc.steps: step1. Create rootNode and focusHub.
444 * @tc.expected: rootNode and focusHub not null.
445 */
446 auto rootNode = CreateRootNode();
447 EXPECT_NE(rootNode, nullptr);
448 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
449 EXPECT_NE(rootNodeFocusHub, nullptr);
450 rootNode->onMainTree_ = true;
451
452 /**
453 * @tc.steps: step2. Create scope testFocusView and focusHub.
454 * @tc.expected: testFocusView and focusHub not null.
455 */
456 std::list<int32_t> emptyList;
457 auto testFocusView = CreateFocusViewWithFocusPattern("nodeA", emptyList, FocusType::SCOPE, true);
458 EXPECT_NE(testFocusView, nullptr);
459 testFocusView->UpdateInspectorId("testFocusView");
460 auto testFocusViewHub = testFocusView->GetOrCreateFocusHub();
461 EXPECT_NE(testFocusViewHub, nullptr);
462 auto testFocusViewPattern = testFocusView->GetPattern<FocusView>();
463 EXPECT_NE(testFocusViewPattern, nullptr);
464 testFocusViewPattern->SetIsViewRootScopeFocused(false);
465
466 /**
467 * @tc.steps: step3. Create nodeA and focusHub.
468 * @tc.expected: nodeA and focusHub not null.
469 */
470 auto nodeA = CreateNodeWithFocusPattern("nodeA", FocusType::NODE, true);
471 EXPECT_NE(nodeA, nullptr);
472 nodeA->UpdateInspectorId("NODEA");
473 auto focusHubA = nodeA->GetOrCreateFocusHub();
474 EXPECT_NE(focusHubA, nullptr);
475 focusHubA->SetTabIndex(-1);
476
477 /**
478 * @tc.steps: step4. Create nodeB and focusHub.
479 * @tc.expected: nodeB and focusHub not null.
480 */
481 auto nodeB = CreateNodeWithFocusPattern("nodeB", FocusType::NODE, true);
482 EXPECT_NE(nodeB, nullptr);
483 nodeB->UpdateInspectorId("NODEB");
484 auto focusHubB = nodeB->GetOrCreateFocusHub();
485 EXPECT_NE(focusHubB, nullptr);
486
487 /**
488 * @tc.steps: step5. Create tree.
489 */
490 rootNode->AddChild(testFocusView);
491 testFocusView->AddChild(nodeA);
492 testFocusView->AddChild(nodeB);
493
494 /**
495 * @tc.steps: step6. ExtendOrActivateFocus.
496 * @tc.expected: focusHubA focus. focusHubB not focus.
497 */
498 EXPECT_NE(focusManager_, nullptr);
499 focusManager_->ExtendOrActivateFocus(testFocusViewPattern);
500 EXPECT_EQ(focusHubA->IsCurrentFocus(), false);
501 EXPECT_EQ(focusHubB->IsCurrentFocus(), false);
502 }
503 } // namespace OHOS::Ace::NG