1 /*
2 * Copyright (c) 2025 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 "gtest/gtest.h"
17
18 #define private public
19 #define protected public
20 #include "test/mock/core/common/mock_resource_adapter.h"
21 #include "test/mock/core/common/mock_theme_manager.h"
22 #include "test/mock/core/pipeline/mock_pipeline_context.h"
23 #include "test/mock/core/render/mock_render_context.h"
24 #include "test/unittest/core/event/focus_core/focus_test_base.h"
25 #include "test/unittest/core/event/focus_core/linear_focus_test.h"
26 #include "test/unittest/core/pattern/test_ng.h"
27 #include "base/log/log_wrapper.h"
28 #include "core/components/container_modal/container_modal_constants.h"
29 #include "core/components/flex/flex_element.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/pattern/button/button_pattern.h"
35 #include "core/components_ng/pattern/container_modal/container_modal_pattern.h"
36 #include "core/components_ng/pattern/container_modal/container_modal_theme.h"
37 #include "core/components_ng/pattern/container_modal/container_modal_view.h"
38 #include "core/components_ng/pattern/image/image_layout_property.h"
39 #include "core/components_ng/pattern/image/image_pattern.h"
40 #include "core/components_ng/pattern/linear_layout/linear_layout_pattern.h"
41 #include "core/components_ng/pattern/pattern.h"
42 #include "core/components_ng/pattern/root/root_pattern.h"
43 #include "core/components_ng/pattern/stack/stack_pattern.h"
44 #include "core/components_ng/pattern/text/text_pattern.h"
45 #include "core/components_ng/pattern/text_picker/textpicker_column_pattern.h"
46 #include "core/event/focus_axis_event.h"
47 #include "core/event/key_event.h"
48 #include "core/pipeline/base/composed_element.h"
49 #include "core/pipeline_ng/pipeline_context.h"
50
51 using namespace testing;
52 using namespace testing::ext;
53 namespace OHOS::Ace::NG {
54
SetUpTestSuite()55 void LinearFocusingTestNG::SetUpTestSuite()
56 {
57 MockPipelineContext::SetUp();
58 GTEST_LOG_(INFO) << "LinearFocusingTestNG SetUpTestCase";
59 }
60
TearDownTestSuite()61 void LinearFocusingTestNG::TearDownTestSuite()
62 {
63 MockPipelineContext::TearDown();
64 GTEST_LOG_(INFO) << "GoFocusTestNG TearDownTestCase";
65 }
66
CreateAndInitNodes(RefPtr<FrameNode> & rootNode,RefPtr<FocusHub> & rootNodeFocusHub,RefPtr<FrameNode> & nodeA,RefPtr<FocusHub> & focusHubA,RefPtr<FrameNode> & nodeB,RefPtr<FocusHub> & focusHubB,RefPtr<FrameNode> & nodeC,RefPtr<FocusHub> & focusHubC,RefPtr<FrameNode> & nodeD,RefPtr<FocusHub> & focusHubD,RefPtr<FrameNode> & nodeE,RefPtr<FocusHub> & focusHubE,RefPtr<FrameNode> & nodeF,RefPtr<FocusHub> & focusHubF)67 void LinearFocusingTestNG::CreateAndInitNodes(RefPtr<FrameNode>& rootNode, RefPtr<FocusHub>& rootNodeFocusHub,
68 RefPtr<FrameNode>& nodeA, RefPtr<FocusHub>& focusHubA, RefPtr<FrameNode>& nodeB, RefPtr<FocusHub>& focusHubB,
69 RefPtr<FrameNode>& nodeC, RefPtr<FocusHub>& focusHubC, RefPtr<FrameNode>& nodeD, RefPtr<FocusHub>& focusHubD,
70 RefPtr<FrameNode>& nodeE, RefPtr<FocusHub>& focusHubE, RefPtr<FrameNode>& nodeF, RefPtr<FocusHub>& focusHubF)
71 {
72 rootNode = CreateRootNode();
73 EXPECT_NE(rootNode, nullptr);
74 rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
75 EXPECT_NE(rootNodeFocusHub, nullptr);
76 rootNode->UpdateInspectorId("ROOTNODE");
77
78 nodeA = CreateNodeWithFocusPattern("nodeA", FocusType::NODE, true);
79 EXPECT_NE(nodeA, nullptr);
80 nodeA->UpdateInspectorId("A");
81 focusHubA = nodeA->GetOrCreateFocusHub();
82 EXPECT_NE(focusHubA, nullptr);
83
84 nodeB = CreateNodeWithFocusPattern("nodeB", FocusType::NODE, true);
85 EXPECT_NE(nodeB, nullptr);
86 nodeB->UpdateInspectorId("B");
87 focusHubB = nodeB->GetOrCreateFocusHub();
88 EXPECT_NE(focusHubB, nullptr);
89
90 nodeC = CreateNodeWithFocusPattern("nodeC", FocusType::NODE, true);
91 EXPECT_NE(nodeC, nullptr);
92 nodeC->UpdateInspectorId("C");
93 focusHubC = nodeC->GetOrCreateFocusHub();
94 EXPECT_NE(focusHubC, nullptr);
95
96 nodeD = CreateNodeWithFocusPattern("nodeD", FocusType::NODE, true);
97 EXPECT_NE(nodeD, nullptr);
98 nodeD->UpdateInspectorId("D");
99 focusHubD = nodeD->GetOrCreateFocusHub();
100 EXPECT_NE(focusHubD, nullptr);
101
102 nodeE = CreateNodeWithFocusPattern("nodeE", FocusType::NODE, true);
103 EXPECT_NE(nodeE, nullptr);
104 nodeE->UpdateInspectorId("E");
105 focusHubE = nodeE->GetOrCreateFocusHub();
106 EXPECT_NE(focusHubE, nullptr);
107
108 nodeF = CreateNodeWithFocusPattern("nodeF", FocusType::NODE, true);
109 EXPECT_NE(nodeF, nullptr);
110 nodeF->UpdateInspectorId("F");
111 focusHubF = nodeF->GetOrCreateFocusHub();
112 EXPECT_NE(focusHubF, nullptr);
113
114 rootNode->AddChild(nodeA);
115 nodeA->AddChild(nodeB);
116 nodeA->AddChild(nodeC);
117 nodeA->AddChild(nodeD);
118 nodeC->AddChild(nodeE);
119 nodeC->AddChild(nodeF);
120 }
121
HandleFocusAndExecuteTest(int32_t caseNum,const LinearFocusingDirectCase & testCase,RefPtr<FocusHub> focusHubB,RefPtr<FocusHub> focusHubC,RefPtr<FocusHub> focusHubD,RefPtr<FocusHub> focusHubE,RefPtr<FocusHub> focusHubF)122 void LinearFocusingTestNG::HandleFocusAndExecuteTest(int32_t caseNum, const LinearFocusingDirectCase& testCase,
123 RefPtr<FocusHub> focusHubB, RefPtr<FocusHub> focusHubC, RefPtr<FocusHub> focusHubD, RefPtr<FocusHub> focusHubE,
124 RefPtr<FocusHub> focusHubF)
125 {
126 if (testCase.goFocusStartPoint == "B") {
127 LinearFocusingTestNG::Test02Focus(caseNum, testCase, focusHubB);
128 }
129 if (testCase.goFocusStartPoint == "C") {
130 if (testCase.isChildNodeGetFocus) {
131 focusHubE->SetFocusable(true);
132 focusHubF->SetFocusable(true);
133 } else {
134 focusHubE->SetFocusable(false);
135 focusHubF->SetFocusable(false);
136 }
137 LinearFocusingTestNG::Test02Focus(caseNum, testCase, focusHubC);
138 }
139 if (testCase.goFocusStartPoint == "D") {
140 LinearFocusingTestNG::Test02Focus(caseNum, testCase, focusHubD);
141 }
142 }
143
HomeOrTabFocus(int caseNum,const LinearFocusingCase & testCase,RefPtr<FocusHub> focusHub)144 void LinearFocusingTestNG::HomeOrTabFocus(int caseNum, const LinearFocusingCase& testCase, RefPtr<FocusHub> focusHub)
145 {
146 focusHub->SetCurrentFocus(true);
147 if (testCase.isGoFocusActivityStatus) {
148 focusHub->isFocusActiveWhenFocused_ = true;
149 }
150 if (testCase.goFocusStartPoint == "D") {
151 if (testCase.inputValue == "上键走焦") {
152 focusHub->RequestNextFocus(FocusStep::UP);
153 } else if (testCase.inputValue == "下键走焦") {
154 focusHub->RequestNextFocus(FocusStep::DOWN);
155 } else if (testCase.inputValue == "左键走焦") {
156 focusHub->RequestNextFocus(FocusStep::LEFT);
157 } else if (testCase.inputValue == "右键走焦") {
158 focusHub->RequestNextFocus(FocusStep::RIGHT);
159 }
160 } else if (testCase.goFocusStartPoint == "A") {
161 if (testCase.inputValue == "Tab走焦") {
162 focusHub->RequestNextFocus(FocusStep::TAB);
163 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
164 << "TestCaseNum: " << caseNum << ", inputvalue: " << testCase.inputValue;
165 } else if (testCase.inputValue == "Shift+Tab走焦") {
166 focusHub->RequestNextFocus(FocusStep::SHIFT_TAB);
167 }
168 } else if (testCase.goFocusStartPoint == "B") {
169 if (testCase.inputValue == "Tab走焦") {
170 focusHub->RequestNextFocus(FocusStep::TAB);
171 } else if (testCase.inputValue == "Shift+Tab走焦") {
172 focusHub->RequestNextFocus(FocusStep::SHIFT_TAB);
173 }
174 }
175 HomeOrTabFocusExpect(caseNum, testCase, focusHub);
176 }
177
HomeOrTabFocusExpect(int caseNum,const LinearFocusingCase & testCase,RefPtr<FocusHub> focusHub)178 void LinearFocusingTestNG::HomeOrTabFocusExpect(
179 int caseNum, const LinearFocusingCase& testCase, RefPtr<FocusHub> focusHub)
180 {
181 if (testCase.expectResults == "A") {
182 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
183 << "TestCaseNum: " << caseNum << ", actual A STATUS: " << focusHub->IsCurrentFocus();
184 } else if (testCase.expectResults == "B") {
185 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
186 << "TestCaseNum: " << caseNum << ", actual B STATUS: " << focusHub->IsCurrentFocus();
187 } else if (testCase.expectResults == "C") {
188 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
189 << "TestCaseNum: " << caseNum << ", actual C STATUS: " << focusHub->IsCurrentFocus();
190 } else if (testCase.expectResults == "D") {
191 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
192 << "TestCaseNum: " << caseNum << ", actual D STATSU: " << focusHub->IsCurrentFocus();
193 } else if (testCase.expectResults == "E") {
194 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
195 << "TestCaseNum: " << caseNum << ", actual E STATSU: " << focusHub->IsCurrentFocus();
196 } else if (testCase.expectResults == "F") {
197 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
198 << "TestCaseNum: " << caseNum << ", actual F STATSU: " << focusHub->IsCurrentFocus();
199 }
200 }
201
Test02Focus(int caseNum,const LinearFocusingDirectCase & testCase,RefPtr<FocusHub> focusHub)202 void LinearFocusingTestNG::Test02Focus(int caseNum, const LinearFocusingDirectCase& testCase, RefPtr<FocusHub> focusHub)
203 {
204 focusHub->SetCurrentFocus(true);
205 if (testCase.isGoFocusActivityStatus) {
206 focusHub->isFocusActiveWhenFocused_ = true;
207 }
208
209 if (testCase.isparentCanDealCurrentOperation) {
210 focusHub->SetParentFocusable(true);
211 }
212
213 if (testCase.isBrotherNodeGetFocus) {
214 focusHub->focusable_ = true;
215 }
216 if (testCase.inputValue == "上键走焦") {
217 focusHub->RequestNextFocus(FocusStep::UP);
218 } else if (testCase.inputValue == "下键走焦") {
219 focusHub->RequestNextFocus(FocusStep::DOWN);
220 } else if (testCase.inputValue == "左键走焦") {
221 focusHub->RequestNextFocus(FocusStep::LEFT);
222 } else if (testCase.inputValue == "右键走焦") {
223 focusHub->RequestNextFocus(FocusStep::RIGHT);
224 }
225 Test02FocusExpect(caseNum, testCase, focusHub);
226 }
Test02FocusExpect(int caseNum,const LinearFocusingDirectCase & testCase,RefPtr<FocusHub> focusHub)227 void LinearFocusingTestNG::Test02FocusExpect(
228 int caseNum, const LinearFocusingDirectCase& testCase, RefPtr<FocusHub> focusHub)
229 {
230 if (testCase.expectResults == "A") {
231 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
232 << "TestCaseNum: " << caseNum << ", actual A STATUS: " << focusHub->IsCurrentFocus();
233 } else if (testCase.expectResults == "B") {
234 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
235 << "TestCaseNum: " << caseNum << ", actual B STATUS: " << focusHub->IsCurrentFocus();
236 } else if (testCase.expectResults == "C") {
237 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
238 << "TestCaseNum: " << caseNum << ", actual C STATUS: " << focusHub->IsCurrentFocus();
239 } else if (testCase.expectResults == "D") {
240 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
241 << "TestCaseNum: " << caseNum << ", actual D STATSU: " << focusHub->IsCurrentFocus();
242 } else if (testCase.expectResults == "E") {
243 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
244 << "TestCaseNum: " << caseNum << ", actual E STATSU: " << focusHub->IsCurrentFocus();
245 } else if (testCase.expectResults == "F") {
246 EXPECT_EQ(focusHub->IsCurrentFocus(), true)
247 << "TestCaseNum: " << caseNum << ", actual F STATSU: " << focusHub->IsCurrentFocus();
248 }
249 }
250
CreatNodeHandleLeftRightFocus(int caseNum,const LinearFocusingHomeCase & testCase)251 void LinearFocusingTestNG::CreatNodeHandleLeftRightFocus(int caseNum, const LinearFocusingHomeCase& testCase)
252 {
253 auto rootNode = CreateRootNode();
254 EXPECT_NE(rootNode, nullptr);
255 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
256 EXPECT_NE(rootNodeFocusHub, nullptr);
257 rootNode->UpdateInspectorId("ROOTNODE");
258
259 /**
260 * @tc.steps: step2. Create FocusView nodeB.
261 * @tc.expected: nodeB and focusHubB not null.
262 */
263 auto nodeA = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
264 AceType::MakeRefPtr<LinearLayoutPattern>(false));
265 EXPECT_NE(nodeA, nullptr);
266 nodeA->UpdateInspectorId("A");
267 auto focusHubA = nodeA->GetOrCreateFocusHub();
268 EXPECT_NE(focusHubA, nullptr);
269 /**
270 * @tc.steps: step3. Create FocusView nodeB.
271 * @tc.expected: nodeB and focusHubB not null.
272 */
273 auto nodeB = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
274 AceType::MakeRefPtr<LinearLayoutPattern>(false));
275 EXPECT_NE(nodeB, nullptr);
276 nodeB->UpdateInspectorId("B");
277 auto focusHubB = nodeB->GetOrCreateFocusHub();
278 EXPECT_NE(focusHubB, nullptr);
279
280 /**
281 * @tc.steps: step4. Create FocusView nodec.
282 * @tc.expected: nodeB and focusHubB not null.
283 */
284 auto nodeC = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
285 AceType::MakeRefPtr<LinearLayoutPattern>(false));
286 EXPECT_NE(nodeC, nullptr);
287 nodeC->UpdateInspectorId("C");
288 auto focusHubC = nodeC->GetOrCreateFocusHub();
289 EXPECT_NE(focusHubC, nullptr);
290
291 /**
292 * @tc.steps: step5. Create nodeC.
293 * @tc.expected: nodeC and focusHubC not null.
294 */
295 auto nodeD = FrameNode::CreateFrameNode(V2::ROW_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
296 AceType::MakeRefPtr<LinearLayoutPattern>(false));
297 EXPECT_NE(nodeD, nullptr);
298 nodeD->UpdateInspectorId("D");
299 auto focusHubD = nodeC->GetOrCreateFocusHub();
300 EXPECT_NE(focusHubD, nullptr);
301 /**
302 * @tc.steps: step6. Add nodes
303 */
304 rootNode->AddChild(nodeA);
305 nodeA->AddChild(nodeB);
306 nodeA->AddChild(nodeC);
307 nodeA->AddChild(nodeD);
308
309 if (testCase.isGoFocusActivityStatus) {
310 focusHubC->isFocusActiveWhenFocused_ = true;
311 }
312 if (!testCase.goFocusStartPoint.empty()) {
313 focusHubC->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHubC));
314 }
315
316 if (testCase.inputValue == "HOME键走焦") {
317 focusHubC->RequestNextFocus(FocusStep::LEFT_END) || focusHubC->RequestNextFocus(FocusStep::UP_END);
318 } else if (testCase.inputValue == "END键走焦") {
319 focusHubC->RequestNextFocus(FocusStep::RIGHT_END) || focusHubC->RequestNextFocus(FocusStep::DOWN_END);
320 }
321
322 auto lastFocusNode = focusHubC->GetLastWeakFocusNode().Upgrade();
323 std::string actualNode = lastFocusNode ? lastFocusNode->GetFrameNode()->GetInspectorId().value_or("") : "";
324
325 EXPECT_EQ(actualNode, testCase.expectResults)
326 << "TestCaseNum: " << caseNum << ", actual node: " << actualNode << ", expect node: " << testCase.expectResults;
327 }
328
CreatNodeHandleUpDownFocus(int caseNum,const LinearFocusingHomeCase & testCase)329 void LinearFocusingTestNG::CreatNodeHandleUpDownFocus(int caseNum, const LinearFocusingHomeCase& testCase)
330 {
331 auto rootNode = CreateRootNode();
332 EXPECT_NE(rootNode, nullptr);
333 auto rootNodeFocusHub = rootNode->GetOrCreateFocusHub();
334 EXPECT_NE(rootNodeFocusHub, nullptr);
335 rootNode->UpdateInspectorId("ROOTNODE");
336 auto nodeA = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
337 AceType::MakeRefPtr<LinearLayoutPattern>(true));
338 EXPECT_NE(nodeA, nullptr);
339 nodeA->UpdateInspectorId("A");
340 auto focusHubA = nodeA->GetOrCreateFocusHub();
341 EXPECT_NE(focusHubA, nullptr);
342
343 /**
344 * @tc.steps: step3. Create FocusView nodeB.
345 * @tc.expected: nodeB and focusHubB not null.
346 */
347 auto nodeB = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
348 AceType::MakeRefPtr<LinearLayoutPattern>(true));
349 EXPECT_NE(nodeB, nullptr);
350 nodeB->UpdateInspectorId("B");
351 auto focusHubB = nodeB->GetOrCreateFocusHub();
352 EXPECT_NE(focusHubB, nullptr);
353
354 /**
355 * @tc.steps: step4. Create FocusView nodec.
356 * @tc.expected: nodeB and focusHubB not null.
357 */
358 auto nodeC = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
359 AceType::MakeRefPtr<LinearLayoutPattern>(true));
360 EXPECT_NE(nodeC, nullptr);
361 nodeC->UpdateInspectorId("C");
362 auto focusHubC = nodeC->GetOrCreateFocusHub();
363 EXPECT_NE(focusHubC, nullptr);
364
365 /**
366 * @tc.steps: step5. Create nodeC.
367 * @tc.expected: nodeC and focusHubC not null.
368 */
369 auto nodeD = FrameNode::CreateFrameNode(V2::COLUMN_ETS_TAG, ElementRegister::GetInstance()->MakeUniqueId(),
370 AceType::MakeRefPtr<LinearLayoutPattern>(true));
371 EXPECT_NE(nodeD, nullptr);
372 nodeD->UpdateInspectorId("D");
373 auto focusHubD = nodeC->GetOrCreateFocusHub();
374 EXPECT_NE(focusHubD, nullptr);
375 /**
376 * @tc.steps: step6. Add nodes
377 */
378 rootNode->AddChild(nodeA);
379 nodeA->AddChild(nodeB);
380 nodeA->AddChild(nodeC);
381 nodeA->AddChild(nodeD);
382
383 if (testCase.isGoFocusActivityStatus) {
384 focusHubC->isFocusActiveWhenFocused_ = true;
385 }
386
387 if (!testCase.goFocusStartPoint.empty()) {
388 focusHubC->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(focusHubC));
389 }
390 if (testCase.inputValue == "HOME键走焦") {
391 focusHubC->RequestNextFocus(FocusStep::LEFT_END) || focusHubC->RequestNextFocus(FocusStep::UP_END);
392 } else if (testCase.inputValue == "END键走焦") {
393 focusHubC->RequestNextFocus(FocusStep::RIGHT_END) || focusHubC->RequestNextFocus(FocusStep::DOWN_END);
394 }
395 auto lastFocusNode = focusHubC->GetLastWeakFocusNode().Upgrade();
396 std::string actualNode = lastFocusNode ? lastFocusNode->GetFrameNode()->GetInspectorId().value_or("") : "";
397 EXPECT_EQ(actualNode, testCase.expectResults)
398 << "TestCaseNum: " << caseNum << ", actual node: " << actualNode << ", expect node: " << testCase.expectResults;
399 }
400
401 HWTEST_F(LinearFocusingTestNG, LinearFocusingTestNG001, TestSize.Level1)
402 {
403 int32_t caseNum = 1;
404 bool initResult = InitFocusTestBaseNG();
405 EXPECT_TRUE(initResult);
406 for (const auto& testCase : LINEAR_FOCUSING_CASES) {
407 RefPtr<FrameNode> rootNode;
408 RefPtr<FocusHub> rootNodeFocusHub;
409 RefPtr<FrameNode> nodeA, nodeB, nodeC, nodeD, nodeE, nodeF;
410 RefPtr<FocusHub> focusHubA, focusHubB, focusHubC, focusHubD, focusHubE, focusHubF;
411 CreateAndInitNodes(rootNode, rootNodeFocusHub, nodeA, focusHubA, nodeB, focusHubB, nodeC, focusHubC, nodeD,
412 focusHubD, nodeE, focusHubE, nodeF, focusHubF);
413
414 if (!testCase.goFocusStartPoint.empty()) {
415 if (testCase.isConfigurationTabindexNode) {
416 OHOS::Ace::KeyEvent keyEvent;
417 keyEvent.action = KeyAction::DOWN;
418 keyEvent.code = KeyCode::KEY_TAB;
419 focusHubA->HandleFocusByTabIndex(keyEvent);
420 }
421 if (testCase.isBrotherNodeGetFocus)
422 focusHubC->focusable_ = true;
423 if (testCase.isChildNodeGetFocus)
424 focusHubE->SetFocusable(true);
425 else
426 focusHubE->SetFocusable(false);
427
428 RefPtr<FocusHub> startHub;
429 if (testCase.goFocusStartPoint == "A")
430 startHub = focusHubA;
431 else if (testCase.goFocusStartPoint == "B")
432 startHub = focusHubB;
433 else if (testCase.goFocusStartPoint == "D")
434 startHub = focusHubD;
435
436 LinearFocusingTestNG::HomeOrTabFocus(caseNum, testCase, startHub);
437 }
438 ++caseNum;
439 }
440 }
441
442 HWTEST_F(LinearFocusingTestNG, LinearFocusingTestNG002, TestSize.Level1)
443 {
444 int32_t caseNum = 1;
445 bool initResult = InitFocusTestBaseNG();
446 EXPECT_TRUE(initResult);
447 for (const auto& testCase : LINEAR_FOCUSING_DIRECT_CASES) {
448 RefPtr<FrameNode> rootNode;
449 RefPtr<FocusHub> rootNodeFocusHub;
450 RefPtr<FrameNode> nodeA, nodeB, nodeC, nodeD, nodeE, nodeF;
451 RefPtr<FocusHub> focusHubA, focusHubB, focusHubC, focusHubD, focusHubE, focusHubF;
452
453 CreateAndInitNodes(rootNode, rootNodeFocusHub, nodeA, focusHubA, nodeB, focusHubB, nodeC, focusHubC, nodeD,
454 focusHubD, nodeE, focusHubE, nodeF, focusHubF);
455
456 HandleFocusAndExecuteTest(caseNum, testCase, focusHubB, focusHubC, focusHubD, focusHubE, focusHubF);
457
458 ++caseNum;
459 }
460 }
461
462 HWTEST_F(LinearFocusingTestNG, LinearFocusingTestNG003, TestSize.Level1)
463 {
464 int32_t caseNum = 1;
465 bool initResult = InitFocusTestBaseNG();
466 EXPECT_TRUE(initResult);
467 for (const auto& testCase : LINEAR_FOCUSING_HOME_CASES) {
468 if (testCase.isparentNodeHandleLeftRightFocus) {
469 CreatNodeHandleLeftRightFocus(caseNum, testCase);
470 } else {
471 CreatNodeHandleUpDownFocus(caseNum, testCase);
472 }
473 ++caseNum;
474 }
475 }
476
477 } // namespace OHOS::Ace::NG
478