1 /*
2 * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "test/unittest/core/event/focus_hub_test_ng.h"
16
17 using namespace testing;
18 using namespace testing::ext;
19
20 namespace OHOS::Ace::NG {
SetUpTestSuite()21 void FocusHubTestNg::SetUpTestSuite()
22 {
23 MockPipelineContext::SetUp();
24 GTEST_LOG_(INFO) << "FocusHubTestNg SetUpTestCase";
25 }
26
TearDownTestSuite()27 void FocusHubTestNg::TearDownTestSuite()
28 {
29 MockPipelineContext::TearDown();
30 GTEST_LOG_(INFO) << "FocusHubTestNg TearDownTestCase";
31 }
32
SetUp()33 void FocusHubTestNg::SetUp() {}
34
TearDown()35 void FocusHubTestNg::TearDown() {}
36
37 /**
38 * @tc.name: FocusHubCreateTest001
39 * @tc.desc: Create FocusHub.
40 * @tc.type: FUNC
41 */
42 HWTEST_F(FocusHubTestNg, FocusHubCreateTest001, TestSize.Level1)
43 {
44 /**
45 * @tc.steps: step1. Create FocusHub with passing is null as parameter.
46 * @tc.expected: eventHub_ cannot be updated.
47 */
48 auto focusHub1 = AceType::MakeRefPtr<FocusHub>(nullptr);
49 EXPECT_TRUE(focusHub1->GetFrameNode() == nullptr);
50 EXPECT_TRUE(focusHub1->IsEnabled());
51 EXPECT_TRUE(!focusHub1->IsFocusableNode());
52
53 /**
54 * @tc.steps: step2. Create FocusHub with the WeakPtr eventHub_ which does not own frameNode.
55 * @tc.expected: eventHub can be updated, but cannot get frameNode and its related properties.
56 */
57 auto eventHub2 = AceType::MakeRefPtr<EventHub>();
58 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub2);
59 EXPECT_TRUE(focusHub2 != nullptr);
60 EXPECT_TRUE(focusHub2->GetFrameNode() == nullptr);
61 EXPECT_TRUE(focusHub2->GetGeometryNode() == nullptr);
62 EXPECT_EQ(focusHub2->GetFrameName(), "NULL");
63 EXPECT_EQ(focusHub2->GetInspectorKey(), std::nullopt);
64
65 /**
66 * @tc.steps: step3. Invoke GetParentFocusHub without parameter.
67 * @tc.expected: FocusHub will return frameNode' parent focusHub which is also nullptr.
68 */
69 EXPECT_TRUE(focusHub2->GetParentFocusHub() == nullptr);
70
71 /**
72 * @tc.steps: step4. Invoke GetParentFocusHub passing node as parameter which does not have parent.
73 * @tc.expected: FocusHub will return node' parent focusHub which does not exist.
74 */
75 auto node = FrameNodeOnTree(V2::TEXT_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
76 EXPECT_TRUE(focusHub2->GetParentFocusHub() == nullptr);
77 }
78
79 /**
80 * @tc.name: FocusHubCreateTest002
81 * @tc.desc: Create FocusHub.
82 * @tc.type: FUNC
83 */
84 HWTEST_F(FocusHubTestNg, FocusHubCreateTest002, TestSize.Level1)
85 {
86 /**
87 * @tc.steps: step1. Create FocusHub with the WeakPtr eventHub_ owning frameNode.
88 * @tc.expected: eventHub can be updated and can get frameNode and its related properties.
89 */
90 auto eventHub = AceType::MakeRefPtr<EventHub>();
91 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::TEXT_ETS_TAG, -1,
92 AceType::MakeRefPtr<Pattern>());
93 eventHub->AttachHost(frameNode);
94 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
95 EXPECT_TRUE(focusHub->GetFrameNode() != nullptr);
96 EXPECT_TRUE(focusHub->GetGeometryNode() != nullptr);
97 EXPECT_EQ(focusHub->GetFrameName(), V2::TEXT_ETS_TAG);
98 EXPECT_EQ(focusHub->GetInspectorKey(), std::nullopt);
99
100 /**
101 * @tc.steps: step2. Invoke GetParentFocusHub without passing parameter.
102 * @tc.expected: FocusHub will return frameNode' parent focusHub which is also nullptr.
103 */
104 EXPECT_TRUE(focusHub->GetParentFocusHub() == nullptr);
105
106 /**
107 * @tc.steps: step3. Create focusHub and its frameNode has parent node.
108 * @tc.expected: FocusHub will return frameNode' parent focusHub.
109 */
110 auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1,
111 AceType::MakeRefPtr<FlexLayoutPattern>());
112 nodeParent->GetOrCreateFocusHub();
113 frameNode->SetParent(nodeParent);
114 eventHub->AttachHost(frameNode);
115 auto focusHub2 = AceType::MakeRefPtr<FocusHub>(eventHub);
116 EXPECT_TRUE(focusHub2->GetParentFocusHub() != nullptr);
117 }
118
119 /**
120 * @tc.name: FocusHubFlushChildrenFocusHubTest003
121 * @tc.desc: Create FocusHub and invoke FlushChildrenFocusHub.
122 * @tc.type: FUNC
123 */
124 HWTEST_F(FocusHubTestNg, FocusHubFlushChildrenFocusHubTest003, TestSize.Level1)
125 {
126 /**
127 * @tc.steps: step1. Create frameNode and add button as its children which focus type is enable.
128 */
129 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
130 AceType::MakeRefPtr<Pattern>());
131 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
132 AceType::MakeRefPtr<ButtonPattern>());
133 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
134 AceType::MakeRefPtr<ButtonPattern>());
135 child->GetOrCreateFocusHub();
136 child2->GetOrCreateFocusHub();
137 frameNode->AddChild(child);
138 frameNode->AddChild(child2);
139
140 /**
141 * @tc.steps: step2. Create FocusHub.
142 */
143 auto eventHub = AceType::MakeRefPtr<EventHub>();
144 eventHub->AttachHost(frameNode);
145 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
146
147 /**
148 * @tc.steps: step3. Invoke FlushChildrenFocusHub to get the focusable children.
149 * @tc.expected: Button is the focusable child which will be emplace_back in focusNodes_.
150 */
151 std::list<RefPtr<FocusHub>> focusNodes;
152 focusHub->FlushChildrenFocusHub(focusNodes);
153 EXPECT_EQ(focusNodes.size(), FOCUS_NODE_SIZE);
154 EXPECT_EQ(focusHub->lastWeakFocusNode_.Upgrade(), nullptr);
155
156 /**
157 * @tc.steps: step4. lastWeakFocusNode_ is not nullptr.
158 * @tc.expected: itLastFocusNode_ will be assigned the iter corresponding lastWeakFocusNode_ found in focusNodes_.
159 */
160 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(*(focusNodes.begin())));
161 EXPECT_EQ(focusHub->lastWeakFocusNode_.Upgrade(), *(focusNodes.begin()));
162 }
163
164 /**
165 * @tc.name: FocusHubRemoveSelfTest004
166 * @tc.desc: Create FocusHub and invoke RemoveSelf.
167 * @tc.type: FUNC
168 */
169 HWTEST_F(FocusHubTestNg, FocusHubRemoveSelfTest004, TestSize.Level1)
170 {
171 /**
172 * @tc.steps: step1. Create frameNode and add its parent.
173 */
174 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::TEXT_ETS_TAG, -1,
175 AceType::MakeRefPtr<Pattern>());
176 auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1,
177 AceType::MakeRefPtr<FlexLayoutPattern>());
178 nodeParent->GetOrCreateFocusHub();
179 frameNode->SetParent(nodeParent);
180
181 /**
182 * @tc.steps: step2. Create FocusHub.
183 */
184 auto eventHub = AceType::MakeRefPtr<EventHub>();
185 eventHub->AttachHost(frameNode);
186 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
187
188 /**
189 * @tc.steps: step3. Remove self.
190 * @tc.expected: The nodeParent children size is 0.
191 */
192 focusHub->focusScopeId_="1";
193 focusHub->RemoveSelf();
194 EXPECT_EQ(nodeParent->GetChildren().size(), NODE_SIZE);
195 }
196
197 /**
198 * @tc.name: FocusHubLostFocusTest005
199 * @tc.desc: Create FocusHub and invoke LostFocus.
200 * @tc.type: FUNC
201 */
202 HWTEST_F(FocusHubTestNg, FocusHubLostFocusTest005, TestSize.Level1)
203 {
204 /**
205 * @tc.steps: step1. Create frameNode and add button as its children which focus type is enable.
206 */
207 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
208 AceType::MakeRefPtr<Pattern>());
209
210 /**
211 * @tc.steps: step2. Create FocusHub.
212 */
213 auto eventHub = AceType::MakeRefPtr<EventHub>();
214 eventHub->AttachHost(frameNode);
215 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
216
217 /**
218 * @tc.steps: step3. Invoke LostFocus, when FocusType is DISABLE and the blur reason is FOCUS_SWITCH.
219 * @tc.expected: currentFocus_ is false.
220 */
221 focusHub->currentFocus_ = true;
222 focusHub->LostFocus(BLUR_REASON_FOCUS_SWITCH);
223 EXPECT_EQ(focusHub->blurReason_, BLUR_REASON_FOCUS_SWITCH);
224 EXPECT_FALSE(focusHub->currentFocus_);
225
226 /**
227 * @tc.steps: step4. Invoke LostFocus, when FocusType is NODE and the blur reason is WINDOW_BLUR.
228 * @tc.expected: currentFocus_ is false.
229 */
230 focusHub->currentFocus_ = true;
231 focusHub->focusType_ = FocusType::NODE;
232 focusHub->LostFocus(BLUR_REASON_WINDOW_BLUR);
233 EXPECT_EQ(focusHub->blurReason_, BLUR_REASON_WINDOW_BLUR);
234 EXPECT_FALSE(focusHub->currentFocus_);
235
236 /**
237 * @tc.steps: step5. Invoke LostFocus, when FocusType is SCOPE and the blur reason is WINDOW_BLUR.
238 * @tc.expected: currentFocus_ is false.
239 */
240 focusHub->currentFocus_ = true;
241 focusHub->focusType_ = FocusType::SCOPE;
242 focusHub->LostFocus(BLUR_REASON_WINDOW_BLUR);
243 EXPECT_FALSE(focusHub->currentFocus_);
244 }
245
246 /**
247 * @tc.name: FocusHubHandleKeyEventTest006
248 * @tc.desc: Create FocusHub and invoke HandleKeyEvent.
249 * @tc.type: FUNC
250 */
251 HWTEST_F(FocusHubTestNg, FocusHubHandleKeyEventTest006, TestSize.Level1)
252 {
253 /**
254 * @tc.steps: step1. Create frameNode.
255 */
256 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
257 AceType::MakeRefPtr<Pattern>());
258 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
259 AceType::MakeRefPtr<ButtonPattern>());
260 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
261 AceType::MakeRefPtr<ButtonPattern>());
262 child->GetOrCreateFocusHub();
263 child2->GetOrCreateFocusHub();
264 frameNode->AddChild(child);
265 frameNode->AddChild(child2);
266
267 /**
268 * @tc.steps: step2. Create FocusHub.
269 */
270 auto eventHub = AceType::MakeRefPtr<EventHub>();
271 eventHub->AttachHost(frameNode);
272 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
273
274 /**
275 * @tc.steps: step3. Focus hub does not currently focused and FocusType is DISABLE.
276 * @tc.expected: Do not handle key event.
277 */
278 KeyEvent keyEvent;
279 keyEvent.code = KeyCode::TV_CONTROL_UP;
280 EXPECT_FALSE(focusHub->HandleKeyEvent(keyEvent));
281
282 /**
283 * @tc.steps: step4. Focus hub is currently focused, FocusType is DISABLE and key code is TV_CONTROL_UP.
284 * @tc.expected: OnKeyEventScope -> RequestNextFocus.
285 */
286 focusHub->focusType_ = FocusType::SCOPE;
287 focusHub->currentFocus_ = true;
288 EXPECT_FALSE(focusHub->HandleKeyEvent(keyEvent));
289 }
290
291 /**
292 * @tc.name: FocusHubTestNg007
293 * @tc.desc: Test the function IsFocusableScope.
294 * @tc.type: FUNC
295 */
296 HWTEST_F(FocusHubTestNg, FocusHubTestNg007, TestSize.Level1)
297 {
298 /**
299 * @tc.steps1: initialize parameters.
300 */
301 auto eventHub = AceType::MakeRefPtr<EventHub>();
302 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
303 focusHub->focusable_ = true;
304 focusHub->parentFocusable_ = true;
305
306 /**
307 * @tc.steps2: call the function SetEnabled with false
308 * @tc.expected: The return value of IsFocusableScope is false.
309 */
310 eventHub->SetEnabled(false);
311 EXPECT_FALSE(focusHub->IsFocusableScope());
312
313 /**
314 * @tc.steps3: call the function SetEnabled with true.
315 * @tc.expected: The return value of IsFocusableScope is false.
316 */
317 eventHub->SetEnabled(true);
318 EXPECT_FALSE(focusHub->IsFocusableScope());
319 }
320
321 /**
322 * @tc.name: FocusHubTestNg008
323 * @tc.desc: Test the function SetFocusable.
324 * @tc.type: FUNC
325 */
326 HWTEST_F(FocusHubTestNg, FocusHubTestNg008, TestSize.Level1)
327 {
328 /**
329 * @tc.steps1: initialize parameters.
330 * @tc.expected: The default value of focusable_ is false.
331 */
332 auto eventHub = AceType::MakeRefPtr<EventHub>();
333 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
334 EXPECT_FALSE(focusHub->focusable_);
335
336 /**
337 * @tc.steps2: Set focusable_ to true implicitly.
338 * @tc.expected: The value of focusable_ is true.
339 */
340 focusHub->SetFocusable(true, false);
341 EXPECT_TRUE(focusHub->focusable_);
342
343 /**
344 * @tc.steps3:Set focusable_ to false explicitly.
345 * @tc.expected: The value of focusable_ is false.
346 */
347 focusHub->SetFocusable(false);
348
349 /**
350 * @tc.steps4:Set focusable_ to true implicitly.
351 * @tc.expected: The value of focusable_ is false.
352 */
353 focusHub->SetFocusable(true, false);
354 EXPECT_FALSE(focusHub->focusable_);
355
356 /**
357 * @tc.steps5:Set focusable_ to true explicitly.
358 * @tc.expected: The value of focusable_ is true.
359 */
360 focusHub->SetFocusable(true);
361 EXPECT_TRUE(focusHub->focusable_);
362 }
363
364 /**
365 * @tc.name: FocusHubTestNg009
366 * @tc.desc: Test the function IsFocusable.
367 * @tc.type: FUNC
368 */
369 HWTEST_F(FocusHubTestNg, FocusHubTestNg009, TestSize.Level1)
370 {
371 /**
372 * @tc.steps1: initialize parameters.
373 */
374 auto eventHub = AceType::MakeRefPtr<EventHub>();
375 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
376 eventHub->SetEnabled(false);
377
378 /**
379 * @tc.steps2: call the function IsFocusable with FocusType::NODE
380 * @tc.expected: The return value of IsFocusable is false.
381 */
382 focusHub->SetFocusType(FocusType::NODE);
383 EXPECT_FALSE(focusHub->IsFocusable());
384
385 /**
386 * @tc.steps3: call the function IsFocusable with FocusType::SCOPE
387 * @tc.expected: The return value of IsFocusable is false.
388 */
389 focusHub->SetFocusType(FocusType::SCOPE);
390 EXPECT_FALSE(focusHub->IsFocusable());
391
392 /**
393 * @tc.steps4: call the function IsFocusable with FocusType::DISABLE
394 * @tc.expected: The return value of IsFocusable is false.
395 */
396 focusHub->SetFocusType(FocusType::DISABLE);
397 EXPECT_FALSE(focusHub->IsFocusable());
398 }
399
400 /**
401 * @tc.name: FocusHubTestNg010
402 * @tc.desc: Test the function RequestFocusImmediately.
403 * @tc.type: FUNC
404 */
405 HWTEST_F(FocusHubTestNg, FocusHubTestNg0010, TestSize.Level1)
406 {
407 /**
408 * @tc.steps1: initialize parameters.
409 */
410 auto eventHub = AceType::MakeRefPtr<EventHub>();
411 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
412 auto context = PipelineContext::GetCurrentContext();
413 ASSERT_NE(context, nullptr);
414
415 /**
416 * @tc.steps2: call the function SetFocusType with currentFocus_ = false.
417 * @tc.expected: The return value of RequestFocusImmediately is false.
418 */
419 context->SetIsFocusingByTab(true);
420 focusHub->SetFocusType(FocusType::DISABLE);
421 EXPECT_FALSE(focusHub->RequestFocusImmediately());
422
423 /**
424 * @tc.steps3: call the function SetFocusType with currentFocus_ = true
425 * @tc.expected: The return value of RequestFocusImmediately is true.
426 */
427 context->SetIsFocusingByTab(false);
428 focusHub->SetFocusType(FocusType::DISABLE);
429 focusHub->currentFocus_ = true;
430 EXPECT_TRUE(focusHub->RequestFocusImmediately());
431 }
432
433 /**
434 * @tc.name: FocusHubTestNg011
435 * @tc.desc: Test the function LostFocus.
436 * @tc.type: FUNC
437 */
438 HWTEST_F(FocusHubTestNg, FocusHubTestNg0011, TestSize.Level1)
439 {
440 /**
441 * @tc.steps1: initialize parameters.
442 */
443 auto eventHub = AceType::MakeRefPtr<EventHub>();
444 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
445
446 /**
447 * @tc.steps2: call the function LostFocus with currentFocus_ = false.
448 * @tc.expected: The value of blurReason_ is changed to BlurReason::WINDOW_BLUR.
449 */
450 focusHub->blurReason_ = BlurReason::WINDOW_BLUR;
451 focusHub->currentFocus_ = false;
452 focusHub->LostFocus(BlurReason::FOCUS_SWITCH);
453 EXPECT_EQ(focusHub->blurReason_, BlurReason::WINDOW_BLUR);
454
455 /**
456 * @tc.steps3: call the function LostFocus with currentFocus_ = true.
457 * @tc.expected: The value of blurReason_ is changed to BlurReason::FOCUS_SWITCH.
458 */
459 focusHub->currentFocus_ = true;
460 focusHub->LostFocus(BlurReason::FOCUS_SWITCH);
461 EXPECT_EQ(focusHub->blurReason_, BlurReason::FOCUS_SWITCH);
462 }
463
464 /**
465 * @tc.name: FocusHubTestNg012
466 * @tc.desc: Test the function LostSelfFocus.
467 * @tc.type: FUNC
468 */
469 HWTEST_F(FocusHubTestNg, FocusHubTestNg0012, TestSize.Level1)
470 {
471 /**
472 * @tc.steps1: initialize parameters.
473 */
474 auto eventHub = AceType::MakeRefPtr<EventHub>();
475 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
476
477 /**
478 * @tc.steps2: call the function LostSelfFocus with currentFocus_ = false.
479 * @tc.expected: The value of focusable_ is changed to false.
480 */
481 focusHub->currentFocus_ = false;
482 focusHub->SetFocusable(false);
483 focusHub->LostSelfFocus();
484 EXPECT_FALSE(focusHub->focusable_);
485
486 /**
487 * @tc.steps3: call the function LostSelfFocus with currentFocus_ = true.
488 * @tc.expected: The value of focusable_ is changed to true.
489 */
490 focusHub->currentFocus_ = true;
491 focusHub->LostSelfFocus();
492 EXPECT_TRUE(focusHub->focusable_);
493 }
494
495 /**
496 * @tc.name: FocusHubTestNg013
497 * @tc.desc: Test the function SetShow, SetEnabled, SetEnabledNode and SetEnabledScope.
498 * @tc.type: FUNC
499 */
500 HWTEST_F(FocusHubTestNg, FocusHubTestNg0013, TestSize.Level1)
501 {
502 /**
503 * @tc.steps1: initialize parameters.
504 */
505 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
506 AceType::MakeRefPtr<Pattern>());
507 auto eventHub = AceType::MakeRefPtr<EventHub>();
508 eventHub->AttachHost(frameNode);
509 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
510 auto context = PipelineContext::GetCurrentContext();
511 ASSERT_NE(context, nullptr);
512
513 /**
514 * @tc.steps2: call the function SetShow with FocusType::NODE.
515 * @tc.expected: The value of show_ is changed to true.
516 */
517 focusHub->SetFocusType(FocusType::NODE);
518 focusHub->SetShow(true);
519 focusHub->SetEnabled(true);
520 EXPECT_TRUE(focusHub->IsShow());
521
522 /**
523 * @tc.steps3: call the function SetShow with FocusType::SCOPE.
524 * @tc.expected: The value of show_ is changed to false.
525 */
526 focusHub->SetFocusType(FocusType::SCOPE);
527 focusHub->SetShow(false);
528 focusHub->SetEnabled(false);
529 frameNode->layoutProperty_->propVisibility_ = VisibleType::INVISIBLE;
530 EXPECT_FALSE(focusHub->IsShow());
531
532 /**
533 * @tc.steps4: call the function SetShow with FocusType::DISABLE.
534 * @tc.expected: The value of show_ is changed to false.
535 */
536 focusHub->SetFocusType(FocusType::DISABLE);
537 focusHub->SetShow(true);
538 focusHub->SetEnabled(true);
539 EXPECT_FALSE(focusHub->IsShow());
540 }
541
542 /**
543 * @tc.name: FocusHubTestNg015
544 * @tc.desc: Test functions OnBlur, OnBlurNode and OnBlurScope.
545 * @tc.type: FUNC
546 */
547 HWTEST_F(FocusHubTestNg, FocusHubTestNg0015, TestSize.Level1)
548 {
549 /**
550 * @tc.steps1: initialize parameters.
551 */
552 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
553 AceType::MakeRefPtr<ButtonPattern>());
554 auto eventHub = AceType::MakeRefPtr<EventHub>();
555 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
556 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
557
558 /**
559 * @tc.steps2: call the function OnBlur with FocusType::NODE.
560 * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
561 */
562 focusHub->SetFocusType(FocusType::NODE);
563 focusHub->OnBlur();
564 bool flagCbk1 = false;
565 bool flagCbk2 = false;
566 BlurReason flagReason = BlurReason::WINDOW_BLUR;
__anonf3eca3700102() 567 focusHub->onBlurInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
__anonf3eca3700202(BlurReason reason) 568 focusHub->onBlurReasonInternal_ = [&flagReason](BlurReason reason) { flagReason = reason; };
__anonf3eca3700302() 569 focusHub->SetOnBlurCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
570 focusHub->OnBlur();
571 EXPECT_TRUE(flagCbk1);
572 EXPECT_TRUE(flagCbk2);
573 EXPECT_EQ(flagReason, BlurReason::FOCUS_SWITCH);
574
575 /**
576 * @tc.steps3: call the function OnBlur with FocusType::SCOPE.
577 * @tc.expected: The flagCbk1 and flagCbk2 are changed to true.
578 */
579 focusHub->SetFocusType(FocusType::SCOPE);
580 focusHub->OnFocus();
581 flagCbk1 = false;
582 flagCbk2 = false;
583 flagReason = BlurReason::WINDOW_BLUR;
__anonf3eca3700402() 584 focusHub->onBlurInternal_ = [&flagCbk1]() { flagCbk1 = !flagCbk1; };
__anonf3eca3700502(BlurReason reason) 585 focusHub->onBlurReasonInternal_ = [&flagReason](BlurReason reason) { flagReason = reason; };
__anonf3eca3700602() 586 focusHub->SetOnBlurCallback([&flagCbk2]() { flagCbk2 = !flagCbk2; });
587 focusHub->OnBlur();
588 EXPECT_TRUE(flagCbk1);
589 EXPECT_TRUE(flagCbk2);
590 EXPECT_EQ(flagReason, BlurReason::FOCUS_SWITCH);
591 }
592
593 /**
594 * @tc.name: FocusHubTestNg016
595 * @tc.desc: Test the function OnKeyEvent, OnKeyEventScope and OnKeyEventNode.
596 * @tc.type: FUNC
597 */
598 HWTEST_F(FocusHubTestNg, FocusHubTestNg0016, TestSize.Level1)
599 {
600 /**
601 * @tc.steps1: initialize parameters.
602 */
603 auto eventHub = AceType::MakeRefPtr<EventHub>();
604 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
605 auto context = PipelineContext::GetCurrentContext();
606 ASSERT_NE(context, nullptr);
607 KeyEvent keyEvent;
608 keyEvent.action = KeyAction::DOWN;
609 keyEvent.code = KeyCode::KEY_SPACE;
610 keyEvent.isRedispatch = true;
611 keyEvent.isPreIme = true;
612
613 /**
614 * @tc.steps2: call the function OnKeyEvent with FocusType::NODE.
615 * @tc.expected: The return value of OnKeyEvent is false.
616 */
617 focusHub->SetFocusType(FocusType::NODE);
618 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
619
620 /**
621 * @tc.steps3: call the function OnKeyEvent with FocusType::SCOPE.
622 * @tc.expected: The return value of OnKeyEvent is false.
623 */
624 focusHub->SetFocusType(FocusType::SCOPE);
625 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
626
627 /**
628 * @tc.steps4: call the function OnKeyEvent with FocusType::DISABLE.
629 * @tc.expected: The return value of OnKeyEvent is false.
630 */
631 focusHub->SetFocusType(FocusType::DISABLE);
632 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
633 }
634
635 /**
636 * @tc.name: FocusHubTestNg017
637 * @tc.desc: Test the function HandleFocusByTabIndex.
638 * @tc.type: FUNC
639 */
640 HWTEST_F(FocusHubTestNg, FocusHubTestNg0017, TestSize.Level1)
641 {
642 /**
643 * @tc.steps1: initialize parameters.
644 */
645 auto eventHub = AceType::MakeRefPtr<EventHub>();
646 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
647 KeyEvent keyEvent;
648
649 /**
650 * @tc.steps2: call the function HandleFocusByTabIndex with code != KeyCode::KEY_TAB and action != KeyAction::DOWN.
651 * @tc.expected: The return value of HandleFocusByTabIndex is false.
652 */
653 keyEvent.action = KeyAction::UNKNOWN;
654 keyEvent.code = KeyCode::KEY_UNKNOWN;
655 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
656
657 /**
658 * @tc.steps3: call the function HandleFocusByTabIndex with code != KeyCode::KEY_TAB and action == KeyAction::DOWN.
659 * @tc.expected: The return value of HandleFocusByTabIndex is false.
660 */
661 keyEvent.action = KeyAction::DOWN;
662 keyEvent.code = KeyCode::KEY_UNKNOWN;
663 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
664
665 /**
666 * @tc.steps4: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action != KeyAction::DOWN.
667 * @tc.expected: The return value of HandleFocusByTabIndex is false.
668 */
669 keyEvent.action = KeyAction::UNKNOWN;
670 keyEvent.code = KeyCode::KEY_TAB;
671 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
672
673 /**
674 * @tc.steps5: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action == KeyAction::DOWN
675 * and curPage == null.
676 * @tc.expected: The return value of HandleFocusByTabIndex is false.
677 */
678 keyEvent.action = KeyAction::DOWN;
679 keyEvent.code = KeyCode::KEY_TAB;
680 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
681
682 /**
683 * @tc.steps6: call the function HandleFocusByTabIndex with code == KeyCode::KEY_TAB and action == KeyAction::DOWN
684 * and curPage == focusHub.
685 * @tc.expected: The return value of HandleFocusByTabIndex is false.
686 */
687 keyEvent.action = KeyAction::DOWN;
688 keyEvent.code = KeyCode::KEY_TAB;
689 EXPECT_FALSE(focusHub->HandleFocusByTabIndex(keyEvent));
690 }
691
692 /**
693 * @tc.name: FocusHubTestNg018
694 * @tc.desc: Test the function HandleFocusByTabIndex.
695 * @tc.type: FUNC
696 */
697 HWTEST_F(FocusHubTestNg, FocusHubTestNg0018, TestSize.Level1)
698 {
699 /**
700 * @tc.steps1: initialize parameters.
701 */
702 auto eventHub = AceType::MakeRefPtr<EventHub>();
703 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
704 KeyEvent keyEvent;
705
706 /**
707 * @tc.steps2: call the function GetFocusingTabNodeIdx with the empty TabIndexNodeList.
708 * @tc.expected: The return value of the function is NONE_TAB_FOCUSED_INDEX.
709 */
710 TabIndexNodeList tabIndexNodes;
711 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
712
713 /**
714 * @tc.steps3: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
715 * @tc.expected: The return value of the function is DEFAULT_TAB_FOCUSED_INDEX.
716 */
717 int32_t nodeId = 1;
718 focusHub->lastTabIndexNodeId_ = nodeId;
719 tabIndexNodes.emplace_back(focusHub->GetTabIndex(), focusHub);
720 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
721
722 /**
723 * @tc.steps4: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
724 * @tc.expected: The return value of the function is 0.
725 */
726 nodeId = -1;
727 focusHub->lastTabIndexNodeId_ = nodeId;
728 focusHub->currentFocus_ = true;
729 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), 0);
730
731 /**
732 * @tc.steps5: call the function GetFocusingTabNodeIdx with the unempty TabIndexNodeList.
733 * @tc.expected: The return value of the function is NONE_TAB_FOCUSED_INDEX.
734 */
735 focusHub->currentFocus_ = false;
736 EXPECT_EQ(focusHub->GetFocusingTabNodeIdx(tabIndexNodes), DEFAULT_TAB_FOCUSED_INDEX);
737 }
738
739 /**
740 * @tc.name: FocusHubTestNg019
741 * @tc.desc: Test the function RequestFocusImmediatelyById and GetChildFocusNodeById.
742 * @tc.type: FUNC
743 */
744 HWTEST_F(FocusHubTestNg, FocusHubTestNg0019, TestSize.Level1)
745 {
746 /**
747 * @tc.steps1: initialize parameters.
748 */
749 auto eventHub = AceType::MakeRefPtr<EventHub>();
750 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::TEXT_ETS_TAG, -1,
751 AceType::MakeRefPtr<Pattern>());
752 eventHub->AttachHost(frameNode);
753 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
754
755 /**
756 * @tc.steps2: call the function RequestFocusImmediatelyById with the empty id.
757 * @tc.expected: The return value of the function is false.
758 */
759 const std::string nullStr("");
760 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(nullStr));
761
762 /**
763 * @tc.steps3: call the function RequestFocusImmediatelyById with the idStr.
764 * @tc.expected: The return value of the function is false.
765 */
766 const std::string idStr(V2::TEXT_ETS_TAG);
767 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
768
769 /**
770 * @tc.steps4: call the function RequestFocusImmediatelyById with the idStr and FocusType::NODE.
771 * @tc.expected: The return value of the function is false.
772 */
773 focusHub->SetFocusType(FocusType::NODE);
774 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
775
776 /**
777 * @tc.steps5: call the function RequestFocusImmediatelyById with the idStr and FocusType::SCOPE.
778 * @tc.expected: The return value of the function is false.
779 */
780 focusHub->SetFocusType(FocusType::SCOPE);
781 EXPECT_FALSE(focusHub->RequestFocusImmediatelyById(idStr));
782 }
783
784 /**
785 * @tc.name: FocusHubTestNg020
786 * @tc.desc: Test the function GetChildFocusNodeByType.
787 * @tc.type: FUNC
788 */
789 HWTEST_F(FocusHubTestNg, FocusHubTestNg0020, TestSize.Level1)
790 {
791 /**
792 * @tc.steps1: initialize parameters.
793 */
794 auto eventHub = AceType::MakeRefPtr<EventHub>();
795 eventHub->SetEnabled(true);
796 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
797
798 /**
799 * @tc.steps2: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT.
800 * @tc.expected: The return value of the function is focusHub.
801 */
802 focusHub->SetFocusType(FocusType::NODE);
803 focusHub->SetShow(true);
804 focusHub->focusable_ = true;
805 focusHub->parentFocusable_ = true;
806 focusHub->SetIsDefaultFocus(true);
807 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), focusHub);
808
809 /**
810 * @tc.steps3: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = false.
811 * @tc.expected: The return value of the function is nullptr.
812 */
813 focusHub->focusable_ = false;
814 focusHub->SetShow(false);
815 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), nullptr);
816
817 /**
818 * @tc.steps4: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and IsDefaultFocus = false.
819 * @tc.expected: The return value of the function is nullptr.
820 */
821 focusHub->SetIsDefaultFocus(false);
822 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::DEFAULT), nullptr);
823
824 /**
825 * @tc.steps5: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = true.
826 * @tc.expected: The return value of the function is focusHub.
827 */
828 focusHub->SetShow(true);
829 focusHub->focusable_ = true;
830 focusHub->SetIsDefaultGroupFocus(true);
831 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), focusHub);
832
833 /**
834 * @tc.steps6: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = false.
835 * @tc.expected: The return value of the function is nullptr.
836 */
837 focusHub->focusable_ = false;
838 focusHub->SetShow(false);
839 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
840
841 /**
842 * @tc.steps7: call the function GetChildFocusNodeByType with FocusNodeType::DEFAULT and show_ = true and
843 * IsDefaultGroupFocus = false.
844 * @tc.expected: The return value of the function is nullptr.
845 */
846 focusHub->SetShow(true);
847 focusHub->SetIsDefaultGroupFocus(false);
848 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
849
850 /**
851 * @tc.steps8: call the function GetChildFocusNodeByType with FocusType::SCOPE.
852 * @tc.expected: The return value of the function is nullptr.
853 */
854 focusHub->SetFocusType(FocusType::SCOPE);
855 EXPECT_EQ(focusHub->GetChildFocusNodeByType(FocusNodeType::GROUP_DEFAULT), nullptr);
856 }
857
858 /**
859 * @tc.name: FocusHubTestNg021
860 * @tc.desc: Test the function GoToFocusByTabNodeIdx.
861 * @tc.type: FUNC
862 */
863 HWTEST_F(FocusHubTestNg, FocusHubTestNg0021, TestSize.Level1)
864 {
865 /**
866 * @tc.steps1: initialize parameters.
867 */
868 auto eventHub = AceType::MakeRefPtr<EventHub>();
869 eventHub->SetEnabled(true);
870 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
871
872 /**
873 * @tc.steps2: call the function GoToFocusByTabNodeIdx with the empty TabIndexNodeList.
874 * @tc.expected: The return value of the function is false.
875 */
876 TabIndexNodeList tabIndexNodes;
877 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 0));
878
879 /**
880 * @tc.steps3: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
881 * @tc.expected: The return value of the function is false.
882 */
883 tabIndexNodes.emplace_back(focusHub->GetTabIndex(), nullptr);
884 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 0));
885
886 /**
887 * @tc.steps4: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
888 * @tc.expected: The return value of the function is false.
889 */
890 tabIndexNodes.emplace_back(focusHub->GetTabIndex(), focusHub);
891 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
892
893 /**
894 * @tc.steps5: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
895 * @tc.expected: The return value of the function is false.
896 */
897 focusHub->SetIsDefaultGroupHasFocused(false);
898 focusHub->SetFocusType(FocusType::SCOPE);
899 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
900
901 /**
902 * @tc.steps6: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
903 * @tc.expected: The return value of the function is false.
904 */
905 focusHub->SetIsDefaultGroupHasFocused(true);
906 focusHub->SetFocusType(FocusType::NODE);
907 EXPECT_FALSE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
908
909 /**
910 * @tc.steps7: call the function GoToFocusByTabNodeIdx with the unempty TabIndexNodeList.
911 * @tc.expected: The return value of the function is true.
912 */
913 focusHub->SetShow(true);
914 focusHub->focusable_ = true;
915 focusHub->parentFocusable_ = true;
916 EXPECT_TRUE(focusHub->GoToFocusByTabNodeIdx(tabIndexNodes, 1));
917 }
918
919 /**
920 * @tc.name: FocusHubTestNg022
921 * @tc.desc: Test the function IsFocusableByTab, IsFocusableNodeByTab and IsFocusableScopeByTab.
922 * @tc.type: FUNC
923 */
924 HWTEST_F(FocusHubTestNg, FocusHubTestNg0022, TestSize.Level1)
925 {
926 /**
927 * @tc.steps1: initialize parameters.
928 */
929 auto eventHub = AceType::MakeRefPtr<EventHub>();
930 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
931
932 /**
933 * @tc.steps2: call the function IsFocusableByTab with FocusType::NODE.
934 * @tc.expected: The return value of the function is true.
935 */
936 focusHub->SetFocusType(FocusType::NODE);
937 EXPECT_TRUE(focusHub->IsFocusableByTab());
938
939 /**
940 * @tc.steps3: call the function IsFocusableByTab with FocusType::SCOPE.
941 * @tc.expected: The return value of the function is true.
942 */
943 focusHub->SetFocusType(FocusType::SCOPE);
944 EXPECT_TRUE(focusHub->IsFocusableByTab());
945
946 /**
947 * @tc.steps4: call the function IsFocusableByTab with FocusType::DISABLE.
948 * @tc.expected: The return value of the function is false.
949 */
950 focusHub->SetFocusType(FocusType::DISABLE);
951 EXPECT_FALSE(focusHub->IsFocusableByTab());
952 }
953
954 /**
955 * @tc.name: FocusHubHandleDumpFocusTreeTest023
956 * @tc.desc: Test the function DumpFocusTree.
957 * @tc.type: FUNC
958 */
959 HWTEST_F(FocusHubTestNg, FocusHubHandleDumpFocusTreeTest023, TestSize.Level1)
960 {
961 /**
962 * @tc.steps: step1. Create frameNode.
963 */
964 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
965 AceType::MakeRefPtr<Pattern>());
966
967 /**
968 * @tc.steps: step2. Create FocusHub.
969 */
970 auto eventHub = AceType::MakeRefPtr<EventHub>();
971 eventHub->AttachHost(frameNode);
972 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
973
974 /**
975 * @tc.steps: step3. test function DumpFocusNodeTree.
976 * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty.
977 */
978 int32_t depth = 1;
979 focusHub->focusType_ = FocusType::NODE;
980 auto ss = std::make_unique<std::ostringstream>();
981 DumpLog::GetInstance().SetDumpFile(std::move(ss));
982 focusHub->currentFocus_ = true;
983 focusHub->DumpFocusTree(depth);
984 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
985
986 DumpLog::GetInstance().description_.push_back("test");
987 focusHub->currentFocus_ = false;
988 focusHub->focusable_ = false;
989 focusHub->DumpFocusTree(depth);
990 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
991
992 /**
993 * @tc.steps: step4. test function DumpFocusScopeTree.
994 * @tc.expected: After DumpFocusTree, the DumpLog.description_ is empty.
995 */
996 DumpLog::GetInstance().description_.push_back("test");
997 focusHub->focusType_ = FocusType::SCOPE;
998 focusHub->currentFocus_ = true;
999 focusHub->DumpFocusTree(depth);
1000 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1001
1002 DumpLog::GetInstance().description_.push_back("test");
1003 focusHub->currentFocus_ = false;
1004 focusHub->focusable_ = false;
1005 focusHub->DumpFocusTree(depth);
1006 EXPECT_TRUE(DumpLog::GetInstance().description_.empty());
1007 }
1008
1009 /**
1010 * @tc.name: FocusHubRemoveChildTest001
1011 * @tc.desc: Test the function RemoveChild.
1012 * @tc.type: FUNC
1013 */
1014 HWTEST_F(FocusHubTestNg, FocusHubRemoveChildTest001, TestSize.Level1)
1015 {
1016 /**
1017 * @tc.steps: step1. Create frameNode.
1018 */
1019 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1020 AceType::MakeRefPtr<Pattern>());
1021 auto frameNode2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1022 AceType::MakeRefPtr<Pattern>());
1023 auto nodeParent = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BLANK_ETS_TAG, -1,
1024 AceType::MakeRefPtr<FlexLayoutPattern>());
1025 frameNode->GetOrCreateFocusHub();
1026 frameNode2->GetOrCreateFocusHub();
1027 nodeParent->GetOrCreateFocusHub();
1028 frameNode->SetParent(nodeParent);
1029 frameNode2->SetParent(nodeParent);
1030
1031 /**
1032 * @tc.steps: step2. Create FocusHub.
1033 */
1034 auto eventHub = AceType::MakeRefPtr<EventHub>();
1035 eventHub->AttachHost(frameNode);
1036 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1037
1038 /**
1039 * @tc.steps: step3. Get parentFocusHub.
1040 */
1041 focusHub->currentFocus_ = true;
1042 auto parent = focusHub->GetParentFocusHub();
1043
1044 /**
1045 * @tc.steps: step4. Test RemoveChild and parentFocusHub RemoveSelf.
1046 * @tc.expected: focusHub and parentFocusHub both lostFocus.
1047 */
1048 parent->currentFocus_ = true;
1049 parent->RemoveChild(focusHub);
1050 EXPECT_EQ(parent->blurReason_, BlurReason::FOCUS_SWITCH);
1051 EXPECT_EQ(focusHub->blurReason_, BlurReason::FRAME_DESTROY);
1052 }
1053
1054 /**
1055 * @tc.name: FocusHubSetIsFocusOnTouch001
1056 * @tc.desc: Test the function SetIsFocusOnTouch.
1057 * @tc.type: FUNC
1058 */
1059 HWTEST_F(FocusHubTestNg, FocusHubSetIsFocusOnTouch001, TestSize.Level1)
1060 {
1061 /**
1062 * @tc.steps1: create frameNode.
1063 */
1064 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1065 AceType::MakeRefPtr<Pattern>());
1066
1067 /**
1068 * @tc.steps2: create eventHub and focusHub.
1069 */
1070 auto eventHub = AceType::MakeRefPtr<EventHub>();
1071 eventHub->AttachHost(frameNode);
1072 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1073
1074 /**
1075 * @tc.steps3: test SetIsFocusOnTouch.
1076 * @tc.expected: create touchEvents and set FocusOnTouch success.
1077 */
1078 focusHub->SetIsFocusOnTouch(true);
1079 auto gesture = frameNode->GetOrCreateGestureEventHub();
1080 EXPECT_FALSE(gesture->touchEventActuator_->touchEvents_.empty());
1081
1082 /**
1083 * @tc.steps4: test SetIsFocusOnTouch.
1084 * @tc.expected: when touchEvents has been set, return.
1085 */
1086 focusHub->SetIsFocusOnTouch(true);
1087 EXPECT_TRUE(focusHub->IsFocusOnTouch().value());
1088
1089 /**
1090 * @tc.steps4: test SetIsFocusOnTouch.
1091 * @tc.expected: set touchEvents false.
1092 */
1093 focusHub->SetIsFocusOnTouch(false);
1094 EXPECT_TRUE(gesture->touchEventActuator_->touchEvents_.empty());
1095
1096 /**
1097 * @tc.steps5: test SetIsFocusOnTouch.
1098 * @tc.expected: set focusOnTouchListener_ success.
1099 */
1100 focusHub->SetIsFocusOnTouch(false);
1101 focusHub->focusOnTouchListener_ = nullptr;
1102 focusHub->SetIsFocusOnTouch(true);
1103 EXPECT_TRUE(focusHub->focusOnTouchListener_);
1104 auto touchCallback = focusHub->focusOnTouchListener_;
1105 TouchEventInfo touchEventInfo("onTouchUp");
1106 (*touchCallback)(touchEventInfo);
1107 TouchLocationInfo touchLocationInfo(1);
1108 touchLocationInfo.SetTouchType(TouchType::UP);
1109 touchEventInfo.AddTouchLocationInfo(std::move(touchLocationInfo));
1110 focusHub->SetFocusType(FocusType::NODE);
1111 focusHub->focusable_ = true;
1112 (*touchCallback)(touchEventInfo);
1113 EXPECT_TRUE(focusHub->currentFocus_);
1114 }
1115
1116 /**
1117 * @tc.name: FocusHubOnKeyEvent002
1118 * @tc.desc: Test the function OnKeyEvent.
1119 * @tc.type: FUNC
1120 */
1121 HWTEST_F(FocusHubTestNg, FocusHubOnKeyEvent002, TestSize.Level1)
1122 {
1123 /**
1124 * @tc.steps1: create frameNode.
1125 */
1126 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1127 AceType::MakeRefPtr<Pattern>());
1128
1129 /**
1130 * @tc.steps2: create eventHub and focusHub.
1131 */
1132 auto eventHub = AceType::MakeRefPtr<EventHub>();
1133 eventHub->AttachHost(frameNode);
1134 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1135 KeyEvent keyEvent;
1136 keyEvent.action = KeyAction::UP;
1137 keyEvent.code = KeyCode::KEY_SPACE;
1138
1139 /**
1140 * @tc.steps3: call the function OnKeyEvent with FocusType::NODE.
1141 * @tc.expected: The return value of OnKeyEvent is true.
1142 */
1143 focusHub->SetFocusType(FocusType::NODE);
__anonf3eca3700702(KeyEventInfo& eventInfo) 1144 auto onKeyEventCallback = [](KeyEventInfo& eventInfo) -> bool {
1145 eventInfo.SetStopPropagation(true);
1146 return false;
1147 };
__anonf3eca3700802(const KeyEvent& event) 1148 auto onKeyEvent = [](const KeyEvent& event) -> bool { return true; };
1149 focusHub->SetOnKeyEventInternal(std::move(onKeyEvent));
1150 focusHub->SetOnKeyCallback(std::move(onKeyEventCallback));
1151 EXPECT_TRUE(focusHub->OnKeyEvent(keyEvent));
1152 }
1153
1154 /**
1155 * @tc.name: FocusHubOnKeyEvent004
1156 * @tc.desc: Test the function OnKeyEvent.
1157 * @tc.type: FUNC
1158 */
1159 HWTEST_F(FocusHubTestNg, FocusHubOnKeyEvent004, TestSize.Level1)
1160 {
1161 /**
1162 * @tc.steps1: create frameNode.
1163 */
1164 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1165 AceType::MakeRefPtr<Pattern>());
1166 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1167 AceType::MakeRefPtr<ButtonPattern>());
1168 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1169 AceType::MakeRefPtr<ButtonPattern>());
1170 child->GetOrCreateFocusHub();
1171 child2->GetOrCreateFocusHub();
1172 frameNode->AddChild(child);
1173 frameNode->AddChild(child2);
1174
1175 /**
1176 * @tc.steps2: create eventHub and focusHub.
1177 */
1178 auto eventHub = AceType::MakeRefPtr<EventHub>();
1179 eventHub->AttachHost(frameNode);
1180 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1181 auto childEventHub = AceType::MakeRefPtr<EventHub>();
1182 childEventHub->AttachHost(child);
1183
1184 /**
1185 * @tc.steps3: create lastWeakFocusNode_.
1186 */
1187 std::list<RefPtr<FocusHub>> focusNodes;
1188 focusHub->FlushChildrenFocusHub(focusNodes);
1189 auto childFocusHub = *focusNodes.begin();
1190 childFocusHub->eventHub_ = childEventHub;
1191 focusHub->lastWeakFocusNode_ = AceType::WeakClaim(AceType::RawPtr(childFocusHub));
1192
1193 KeyEvent keyEvent;
1194 keyEvent.action = KeyAction::UP;
1195 auto pipeline = PipelineContext::GetCurrentContext();
1196 pipeline->isFocusActive_ = true;
1197
1198 /**
1199 * @tc.steps5: test keyEvent with keyEvent.code == KeyCode::TV_CONTROL_UP.
1200 * @tc.expected: The return value of OnKeyEvent is false.
1201 */
1202 keyEvent.code = KeyCode::TV_CONTROL_UP;
1203 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1204
1205 keyEvent.code = KeyCode::TV_CONTROL_DOWN;
1206 focusHub->SetScopeFocusAlgorithm();
1207 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1208
1209 keyEvent.code = KeyCode::TV_CONTROL_LEFT;
1210 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1211
1212 keyEvent.code = KeyCode::TV_CONTROL_RIGHT;
1213 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1214
1215 keyEvent.code = KeyCode::KEY_TAB;
1216 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1217
1218 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_SHIFT_LEFT);
1219 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1220
1221 keyEvent.pressedCodes.emplace_back(KeyCode::KEY_TAB);
1222 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1223
1224 keyEvent.code = KeyCode::KEY_MOVE_HOME;
1225 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1226
1227 keyEvent.code = KeyCode::KEY_MOVE_END;
1228 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1229
1230 keyEvent.code = KeyCode::KEY_SPACE;
1231 EXPECT_FALSE(focusHub->OnKeyEvent(keyEvent));
1232 }
1233
1234 /**
1235 * @tc.name: FocusHubGoToNextFocusLinear001
1236 * @tc.desc: Test the function GoToNextFocusLinear.
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(FocusHubTestNg, FocusHubGoToNextFocusLinear001, TestSize.Level1)
1240 {
1241 /**
1242 * @tc.steps: step1. Create frameNode.
1243 */
1244 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1245 AceType::MakeRefPtr<Pattern>());
1246 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1247 AceType::MakeRefPtr<ButtonPattern>());
1248 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1249 AceType::MakeRefPtr<ButtonPattern>());
1250 child->GetOrCreateFocusHub();
1251 child2->GetOrCreateFocusHub();
1252 frameNode->AddChild(child);
1253 frameNode->AddChild(child2);
1254
1255 /**
1256 * @tc.steps: step2. Create FocusHub.
1257 */
1258 auto eventHub = AceType::MakeRefPtr<EventHub>();
1259 eventHub->AttachHost(frameNode);
1260 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1261
1262 focusHub->currentFocus_ = true;
1263
1264 std::list<RefPtr<FocusHub>> focusNodes;
1265 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1266
1267 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1268 EXPECT_TRUE(focusHub->GoToNextFocusLinear(FocusStep::TAB));
1269 }
1270
1271 /**
1272 * @tc.name: FocusHubPaintFocusState001
1273 * @tc.desc: Test the function PaintFocusState.
1274 * @tc.type: FUNC
1275 */
1276 HWTEST_F(FocusHubTestNg, PaintFocusState001, TestSize.Level1)
1277 {
1278 /**
1279 * @tc.steps1: create frameNode.
1280 */
1281 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1282 AceType::MakeRefPtr<Pattern>());
1283 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1284 AceType::MakeRefPtr<ButtonPattern>());
1285 child->GetOrCreateFocusHub();
1286 frameNode->AddChild(child);
1287
1288 /**
1289 * @tc.steps2: create eventHub and focusHub.
1290 */
1291 auto eventHub = AceType::MakeRefPtr<EventHub>();
1292 ASSERT_NE(eventHub, nullptr);
1293 eventHub->AttachHost(frameNode);
1294 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1295 ASSERT_NE(focusHub, nullptr);
1296 auto context = PipelineContext::GetCurrentContext();
1297 ASSERT_NE(context, nullptr);
1298 auto renderContext = frameNode->GetRenderContext();
1299 ASSERT_NE(renderContext, nullptr);
1300
1301 /**
1302 * @tc.steps3: create KeyEvent.
1303 */
1304 KeyEvent keyEvent;
1305 keyEvent.action = KeyAction::DOWN;
1306 keyEvent.code = KeyCode::KEY_SPACE;
1307
1308 focusHub->SetFocusType(FocusType::SCOPE);
1309 EXPECT_EQ(focusHub->focusStyleType_, FocusStyleType::NONE);
1310 }
1311
1312 /**
1313 * @tc.name: FocusHubSetIsDefaultFocus001
1314 * @tc.desc: Test the function SetIsDefaultFocus.
1315 * @tc.type: FUNC
1316 */
1317 HWTEST_F(FocusHubTestNg, SetIsDefaultFocus001, TestSize.Level1)
1318 {
1319 /**
1320 * @tc.steps1: create frameNode.
1321 */
1322 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1323 AceType::MakeRefPtr<Pattern>());
1324
1325 auto eventHub = AceType::MakeRefPtr<EventHub>();
1326 ASSERT_NE(eventHub, nullptr);
1327 eventHub->AttachHost(frameNode);
1328 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1329 ASSERT_NE(focusHub, nullptr);
1330
1331 auto pipeline = PipelineContext::GetCurrentContext();
1332 ASSERT_NE(pipeline, nullptr);
1333 auto manager = pipeline->GetOverlayManager();
1334 ASSERT_NE(manager, nullptr);
1335 auto rootNode = pipeline->GetRootElement();
1336 EXPECT_NE(rootNode, nullptr);
1337
1338 focusHub->focusCallbackEvents_ = nullptr;
1339 focusHub->SetIsDefaultGroupFocus(false);
1340 EXPECT_NE(focusHub->focusCallbackEvents_, nullptr);
1341 }
1342
1343 /**
1344 * @tc.name: FocusHubTestDisableBlur001
1345 * @tc.desc: Test disable functions OnBlur.
1346 * @tc.type: FUNC
1347 */
1348 HWTEST_F(FocusHubTestNg, FocusHubTestDisableBlur001, TestSize.Level1)
1349 {
1350 /**
1351 * @tc.steps1: initialize parameters.
1352 */
1353 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1354 AceType::MakeRefPtr<ButtonPattern>());
1355 auto eventHub = AceType::MakeRefPtr<EventHub>();
1356 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1357 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1358
1359 /**
1360 * @tc.steps2: call the function OnBlur with FocusType::NODE.
1361 * @tc.expected: The result is right.
1362 */
1363 focusHub->SetFocusType(FocusType::NODE);
1364 std::string result;
__anonf3eca3700902() 1365 auto onBlur = [&result]() { result = RESULT_SUCCESS_ONE; };
1366 focusHub->SetOnBlurCallback(onBlur);
1367 EXPECT_NE(focusHub->GetOnBlurCallback(), nullptr);
1368
1369 focusHub->OnBlur();
1370 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1371
1372 /**
1373 * @tc.steps3: clear the function OnBlur.
1374 * @tc.expected: The result is nullptr.
1375 */
1376 focusHub->ClearUserOnBlur();
1377 EXPECT_EQ(focusHub->GetOnBlurCallback(), nullptr);
1378
1379 /**
1380 * @tc.steps3: set the function OnBlur again.
1381 * @tc.expected: The result is right.
1382 */
__anonf3eca3700a02() 1383 auto onBlur2 = [&result]() { result = RESULT_SUCCESS_TWO; };
1384 focusHub->SetOnBlurCallback(onBlur2);
1385 EXPECT_NE(focusHub->GetOnBlurCallback(), nullptr);
1386
1387 focusHub->OnBlur();
1388 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1389 }
1390
1391 /**
1392 * @tc.name: FocusHubTestDisableKey001
1393 * @tc.desc: Test disable functions OnKey.
1394 * @tc.type: FUNC
1395 */
1396 HWTEST_F(FocusHubTestNg, FocusHubTestDisableKey001, TestSize.Level1)
1397 {
1398 /**
1399 * @tc.steps1: initialize parameters.
1400 */
1401 auto frameNode = FrameNodeOnTree::CreateFrameNode("frameNode", 101,
1402 AceType::MakeRefPtr<ButtonPattern>());
1403 auto eventHub = AceType::MakeRefPtr<EventHub>();
1404 eventHub->host_ = AceType::WeakClaim(AceType::RawPtr(frameNode));
1405 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1406
1407 /**
1408 * @tc.steps2: call the function OnKey with FocusType::NODE.
1409 * @tc.expected: The result is right.
1410 */
1411 focusHub->SetFocusType(FocusType::NODE);
1412 std::string result;
__anonf3eca3700b02(KeyEventInfo& info) 1413 auto onKey = [&result](KeyEventInfo& info) { result = RESULT_SUCCESS_ONE; };
1414 focusHub->SetOnKeyCallback(onKey);
1415 EXPECT_NE(focusHub->GetOnKeyCallback(), nullptr);
1416 KeyEvent keyEvent;
1417 keyEvent.action = KeyAction::UP;
1418 focusHub->OnKeyEvent(keyEvent);
1419 EXPECT_EQ(result, RESULT_SUCCESS_ONE);
1420
1421 /**
1422 * @tc.steps3: clear the function OnKey.
1423 * @tc.expected: The result is nullptr.
1424 */
1425 focusHub->ClearUserOnKey();
1426 EXPECT_EQ(focusHub->GetOnKeyCallback(), nullptr);
1427
1428 /**
1429 * @tc.steps4: set the function OnKey again.
1430 * @tc.expected: The result is right.
1431 */
__anonf3eca3700c02(KeyEventInfo& info) 1432 auto onKey2 = [&result](KeyEventInfo& info) { result = RESULT_SUCCESS_TWO; };
1433 focusHub->SetOnKeyCallback(onKey2);
1434 EXPECT_NE(focusHub->GetOnKeyCallback(), nullptr);
1435
1436 focusHub->OnKeyEvent(keyEvent);
1437 EXPECT_EQ(result, RESULT_SUCCESS_TWO);
1438 }
1439
1440 /**
1441 * @tc.name: FocusHubTestNg0030
1442 * @tc.desc: Test the function GoToNextFocusLinear.
1443 * @tc.type: FUNC
1444 */
1445 HWTEST_F(FocusHubTestNg, FocusHubTestNg0030, TestSize.Level1)
1446 {
1447 /**
1448 * @tc.steps: step1. Create frameNode.
1449 */
1450 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1451 AceType::MakeRefPtr<Pattern>());
1452 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1453 AceType::MakeRefPtr<ButtonPattern>());
1454 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1455 AceType::MakeRefPtr<ButtonPattern>());
1456 child->GetOrCreateFocusHub();
1457 child2->GetOrCreateFocusHub();
1458 frameNode->AddChild(child);
1459 frameNode->AddChild(child2);
1460 auto eventHub = AceType::MakeRefPtr<EventHub>();
1461 eventHub->AttachHost(frameNode);
1462 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1463 focusHub->currentFocus_ = true;
1464 std::list<RefPtr<FocusHub>> focusNodes;
1465 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1466 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1467 EXPECT_FALSE(focusHub->GoToNextFocusLinear(FocusStep::NONE));
1468 }
1469
1470 /**
1471 * @tc.name: FocusHubTestNg0031
1472 * @tc.desc: Test the function IsNeedPaintFocusState.
1473 * @tc.type: FUNC
1474 */
1475 HWTEST_F(FocusHubTestNg, FocusHubTestNg0031, TestSize.Level1)
1476 {
1477 /**
1478 * @tc.steps: step1. Create frameNode.
1479 */
1480 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1481 AceType::MakeRefPtr<Pattern>());
1482 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1483 AceType::MakeRefPtr<ButtonPattern>());
1484 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1485 AceType::MakeRefPtr<ButtonPattern>());
1486 child->GetOrCreateFocusHub();
1487 child2->GetOrCreateFocusHub();
1488 frameNode->AddChild(child);
1489 frameNode->AddChild(child2);
1490 auto eventHub = AceType::MakeRefPtr<EventHub>();
1491 eventHub->AttachHost(frameNode);
1492 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1493 std::list<RefPtr<FocusHub>> focusNodes;
1494 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1495 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1496 focusHub->IsNeedPaintFocusState();
1497 focusHub->focusType_ = FocusType::NODE;
1498 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
1499 focusHub->IsNeedPaintFocusState();
1500 focusHub->focusType_ = FocusType::NODE;
1501 EXPECT_TRUE(focusHub->IsNeedPaintFocusState());
1502 }
1503
1504 /**
1505 * @tc.name: FocusHubTestNg0032
1506 * @tc.desc: Test the function PaintFocusState.
1507 * @tc.type: FUNC
1508 */
1509 HWTEST_F(FocusHubTestNg, FocusHubTestNg0032, TestSize.Level1)
1510 {
1511 /**
1512 * @tc.steps: step1. Create frameNode.
1513 */
1514 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1515 AceType::MakeRefPtr<Pattern>());
1516 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1517 AceType::MakeRefPtr<ButtonPattern>());
1518 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1519 AceType::MakeRefPtr<ButtonPattern>());
1520 child->GetOrCreateFocusHub();
1521 child2->GetOrCreateFocusHub();
1522 frameNode->AddChild(child);
1523 frameNode->AddChild(child2);
1524 auto eventHub = AceType::MakeRefPtr<EventHub>();
1525 eventHub->AttachHost(frameNode);
1526 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1527 auto context = PipelineContext::GetCurrentContext();
1528 ASSERT_NE(context, nullptr);
1529 context->isFocusActive_ = true;
1530 focusHub->focusType_ = FocusType::NODE;
1531 focusHub->focusStyleType_ = FocusStyleType::OUTER_BORDER;
1532 std::list<RefPtr<FocusHub>> focusNodes;
1533 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1534 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1535 EXPECT_FALSE(focusHub->PaintFocusState());
1536 }
1537
1538 /**
1539 * @tc.name: FocusHubTestNg0033
1540 * @tc.desc: Test the function AcceptFocusOfSpecifyChild.
1541 * @tc.type: FUNC
1542 */
1543 HWTEST_F(FocusHubTestNg, FocusHubTestNg0033, TestSize.Level1)
1544 {
1545 /**
1546 * @tc.steps: step1. Create frameNode.
1547 */
1548 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1549 AceType::MakeRefPtr<Pattern>());
1550 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1551 AceType::MakeRefPtr<ButtonPattern>());
1552 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1553 AceType::MakeRefPtr<ButtonPattern>());
1554 child->GetOrCreateFocusHub();
1555 child2->GetOrCreateFocusHub();
1556 frameNode->AddChild(child);
1557 frameNode->AddChild(child2);
1558 auto eventHub = AceType::MakeRefPtr<EventHub>();
1559 eventHub->AttachHost(frameNode);
1560 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1561 focusHub->focusType_ = FocusType::DISABLE;
1562 std::list<RefPtr<FocusHub>> focusNodes;
1563 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1564 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1565 focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB);
1566 focusHub->focusType_ = FocusType::SCOPE;
1567 EXPECT_FALSE(focusHub->AcceptFocusOfSpecifyChild(FocusStep::SHIFT_TAB));
1568 EXPECT_FALSE(focusHub->AcceptFocusOfSpecifyChild(FocusStep::TAB));
1569 }
1570
1571 /**
1572 * @tc.name: FocusHubTestNg0034
1573 * @tc.desc: Test the function ClearFocusState.
1574 * @tc.type: FUNC
1575 */
1576 HWTEST_F(FocusHubTestNg, FocusHubTestNg0034, TestSize.Level1)
1577 {
1578 /**
1579 * @tc.steps: step1. Create frameNode.
1580 */
1581 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1582 AceType::MakeRefPtr<Pattern>());
1583 auto eventHub = AceType::MakeRefPtr<EventHub>();
1584 eventHub->AttachHost(frameNode);
1585 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1586 focusHub->focusStyleType_ = FocusStyleType::CUSTOM_REGION;
1587 std::list<RefPtr<FocusHub>> focusNodes;
1588 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1589 EXPECT_EQ(itNewFocusNode, focusNodes.end());
__anonf3eca3700d02() 1590 focusHub->onClearFocusStateCallback_ = []() {};
1591 focusHub->ClearFocusState();
1592 EXPECT_NE(focusHub->focusStyleType_, FocusStyleType::NONE);
1593 }
1594
1595 /**
1596 * @tc.name: FocusHubTestNg0035
1597 * @tc.desc: Test the function RequestFocusImmediately.
1598 * @tc.type: FUNC
1599 */
1600 HWTEST_F(FocusHubTestNg, FocusHubTestNg0035, TestSize.Level1)
1601 {
1602 auto eventHub = AceType::MakeRefPtr<EventHub>();
1603 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1604 auto context = PipelineContext::GetCurrentContext();
1605 ASSERT_NE(context, nullptr);
1606
1607 context->SetIsFocusingByTab(true);
1608 focusHub->SetFocusType(FocusType::DISABLE);
1609 focusHub->focusType_ = FocusType::NODE;
1610 focusHub->currentFocus_ = false;
__anonf3eca3700e02() 1611 focusHub->onPreFocusCallback_ = []() {};
1612 EXPECT_FALSE(focusHub->RequestFocusImmediately());
1613 EXPECT_FALSE(focusHub->RequestFocusImmediately());
1614 context->SetIsFocusingByTab(false);
1615 focusHub->SetFocusType(FocusType::DISABLE);
1616 focusHub->currentFocus_ = true;
1617 EXPECT_TRUE(focusHub->RequestFocusImmediately());
1618 }
1619
1620 /**
1621 * @tc.name: FocusHubTestNg0036
1622 * @tc.desc: Test the function OnFocusScope.
1623 * @tc.type: FUNC
1624 */
1625 HWTEST_F(FocusHubTestNg, FocusHubTestNg0036, TestSize.Level1)
1626 {
1627 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1628 AceType::MakeRefPtr<Pattern>());
1629 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1630 AceType::MakeRefPtr<ButtonPattern>());
1631 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1632 AceType::MakeRefPtr<ButtonPattern>());
1633 child->GetOrCreateFocusHub();
1634 child2->GetOrCreateFocusHub();
1635 frameNode->AddChild(child);
1636 frameNode->AddChild(child2);
1637 auto eventHub = AceType::MakeRefPtr<EventHub>();
1638 eventHub->AttachHost(frameNode);
1639 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1640 focusHub->currentFocus_ = true;
1641 std::list<RefPtr<FocusHub>> focusNodes;
1642 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1643 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1644 focusHub->OnFocusScope();
1645 EXPECT_TRUE(focusHub->currentFocus_);
1646 }
1647
1648 /**
1649 * @tc.name: FocusHubTestNg0037
1650 * @tc.desc: Test the function IsFocusableScopeByTab.
1651 * @tc.type: FUNC
1652 */
1653 HWTEST_F(FocusHubTestNg, FocusHubTestNg0037, TestSize.Level1)
1654 {
1655 /**
1656 * @tc.steps: step1. Create frameNode.
1657 */
1658 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1659 AceType::MakeRefPtr<Pattern>());
1660 auto child = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1661 AceType::MakeRefPtr<ButtonPattern>());
1662 auto child2 = AceType::MakeRefPtr<FrameNodeOnTree>(V2::BUTTON_ETS_TAG, -1,
1663 AceType::MakeRefPtr<ButtonPattern>());
1664 child->GetOrCreateFocusHub();
1665 child2->GetOrCreateFocusHub();
1666 frameNode->AddChild(child);
1667 frameNode->AddChild(child2);
1668 auto eventHub = AceType::MakeRefPtr<EventHub>();
1669 eventHub->AttachHost(frameNode);
1670 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1671 focusHub->currentFocus_ = true;
1672 std::list<RefPtr<FocusHub>> focusNodes;
1673 auto itNewFocusNode = focusHub->FlushChildrenFocusHub(focusNodes);
1674 EXPECT_EQ(itNewFocusNode, focusNodes.end());
1675 EXPECT_TRUE(focusHub->IsFocusableScopeByTab());
1676 }
1677
1678 /**
1679 * @tc.name: FocusHubTestNg0038
1680 * @tc.desc: Test the function IsCurrentFocusWholePath.
1681 * @tc.type: FUNC
1682 */
1683 HWTEST_F(FocusHubTestNg, FocusHubTestNg0038, TestSize.Level1)
1684 {
1685 /**
1686 * @tc.steps: step1. Create frameNode.
1687 */
1688 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1689 AceType::MakeRefPtr<Pattern>());
1690 auto eventHub = AceType::MakeRefPtr<EventHub>();
1691 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1692 ASSERT_NE(focusHub, nullptr);
1693 EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1694 focusHub->currentFocus_ = true;
1695 EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1696 focusHub->focusType_ = FocusType::NODE;
1697 EXPECT_TRUE(focusHub->IsCurrentFocusWholePath());
1698 focusHub->focusType_ = FocusType::SCOPE;
1699 EXPECT_FALSE(focusHub->IsCurrentFocusWholePath());
1700 }
1701
1702 /**
1703 * @tc.name: FocusHubTestNg0039
1704 * @tc.desc: Test the function DumpFocusTree.
1705 * @tc.type: FUNC
1706 */
1707 HWTEST_F(FocusHubTestNg, FocusHubTestNg0039, TestSize.Level1)
1708 {
1709 /**
1710 * @tc.steps: step1. Create frameNode.
1711 */
1712 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1713 AceType::MakeRefPtr<Pattern>());
1714 auto eventHub = AceType::MakeRefPtr<EventHub>();
1715 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1716 ASSERT_NE(focusHub, nullptr);
1717 int32_t depth = 1;
1718 focusHub->focusType_ = FocusType::DISABLE;
1719 focusHub->DumpFocusTree(depth);
1720 }
1721
1722 /**
1723 * @tc.name: FocusHubTestNg0040
1724 * @tc.desc: Test the function AcceptFocusOfLastFocus and AcceptFocusByRectOfLastFocus.
1725 * @tc.type: FUNC
1726 */
1727 HWTEST_F(FocusHubTestNg, FocusHubTestNg0040, TestSize.Level1)
1728 {
1729 /**
1730 * @tc.steps: step1. Create frameNode.
1731 */
1732 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1733 AceType::MakeRefPtr<Pattern>());
1734 auto eventHub = AceType::MakeRefPtr<EventHub>();
1735 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1736 ASSERT_NE(focusHub, nullptr);
1737 RectF childRect;
1738 focusHub->focusType_ = FocusType::SCOPE;
1739 EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1740 EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1741 focusHub->focusType_ = FocusType::NODE;
1742 EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1743 EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1744 focusHub->focusType_ = FocusType::DISABLE;
1745 EXPECT_FALSE(focusHub->AcceptFocusOfLastFocus());
1746 EXPECT_FALSE(focusHub->AcceptFocusByRectOfLastFocus(childRect));
1747 }
1748
1749 /**
1750 * @tc.name: FocusHubTestNg0041
1751 * @tc.desc: Test the function SetShow, SetEnabled, SetEnabledNode and SetEnabledScope.
1752 * @tc.type: FUNC
1753 */
1754 HWTEST_F(FocusHubTestNg, FocusHubTestNg0041, TestSize.Level1)
1755 {
1756 /**
1757 * @tc.steps: step1. Create frameNode.
1758 */
1759 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1760 AceType::MakeRefPtr<Pattern>());
1761 auto eventHub = AceType::MakeRefPtr<EventHub>();
1762 eventHub->AttachHost(frameNode);
1763 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1764 ASSERT_NE(focusHub, nullptr);
1765 auto frameNode_test = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_COMPONENT_TAG, -1,
1766 AceType::MakeRefPtr<Pattern>());
1767 frameNode->parent_ = AceType::WeakClaim(AceType::RawPtr(frameNode_test));
1768 AceType::DynamicCast<FrameNodeOnTree>(frameNode->GetParent())
1769 ->GetLayoutProperty()
1770 ->UpdateVisibility(VisibleType::INVISIBLE);
1771 focusHub->IsShow();
1772 }
1773
1774 /**
1775 * @tc.name: FocusHubTestNg0042
1776 * @tc.desc: Test the function OnClick.
1777 * @tc.type: FUNC
1778 */
1779 HWTEST_F(FocusHubTestNg, FocusHubTestNg0042, TestSize.Level1)
1780 {
1781 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1,
1782 AceType::MakeRefPtr<Pattern>());
1783 auto eventHub = AceType::MakeRefPtr<EventHub>();
1784 eventHub->AttachHost(frameNode);
1785 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1786 ASSERT_NE(focusHub, nullptr);
1787 KeyEvent keyEvent;
__anonf3eca3700f02(GestureEvent&) 1788 focusHub->SetOnClickCallback([](GestureEvent&) { return; });
1789 focusHub->OnClick(keyEvent);
1790 }
1791
1792 /**
1793 * @tc.name: HasBackwardFocusMovementInChildren001
1794 * @tc.desc: Test the function HasBackwardFocusMovementInChildren.
1795 * @tc.type: FUNC
1796 */
1797 HWTEST_F(FocusHubTestNg, HasBackwardFocusMovementInChildren001, TestSize.Level1)
1798 {
1799 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1800 auto eventHub = AceType::MakeRefPtr<EventHub>();
1801 eventHub->AttachHost(frameNode);
1802 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1803 ASSERT_NE(focusHub, nullptr);
1804 KeyEvent keyEvent;
1805 ASSERT_FALSE(focusHub->HasBackwardFocusMovementInChildren());
1806 }
1807
1808 /**
1809 * @tc.name: HasForwardFocusMovementInChildren001
1810 * @tc.desc: Test the function HasForwardFocusMovementInChildren.
1811 * @tc.type: FUNC
1812 */
1813 HWTEST_F(FocusHubTestNg, HasForwardFocusMovementInChildren001, TestSize.Level1)
1814 {
1815 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1816 auto eventHub = AceType::MakeRefPtr<EventHub>();
1817 eventHub->AttachHost(frameNode);
1818 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1819 ASSERT_NE(focusHub, nullptr);
1820 KeyEvent keyEvent;
1821 ASSERT_FALSE(focusHub->HasForwardFocusMovementInChildren());
1822 }
1823
1824 /**
1825 * @tc.name: ClearFocusMovementFlagsInChildren001
1826 * @tc.desc: Test the function ClearFocusMovementFlagsInChildren.
1827 * @tc.type: FUNC
1828 */
1829 HWTEST_F(FocusHubTestNg, ClearFocusMovementFlagsInChildren001, TestSize.Level1)
1830 {
1831 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1832 auto eventHub = AceType::MakeRefPtr<EventHub>();
1833 eventHub->AttachHost(frameNode);
1834 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1835 ASSERT_NE(focusHub, nullptr);
1836 KeyEvent keyEvent;
1837 ASSERT_FALSE(focusHub->HasBackwardFocusMovement());
1838 }
1839
1840 /**
1841 * @tc.name: SetLastWeakFocusToPreviousInFocusView001
1842 * @tc.desc: Test the function SetLastWeakFocusToPreviousInFocusView.
1843 * @tc.type: FUNC
1844 */
1845 HWTEST_F(FocusHubTestNg, SetLastWeakFocusToPreviousInFocusView001, TestSize.Level1)
1846 {
1847 auto frameNode = AceType::MakeRefPtr<FrameNodeOnTree>(V2::ROW_ETS_TAG, -1, AceType::MakeRefPtr<Pattern>());
1848 auto eventHub = AceType::MakeRefPtr<EventHub>();
1849 eventHub->AttachHost(frameNode);
1850 auto focusHub = AceType::MakeRefPtr<FocusHub>(eventHub);
1851 ASSERT_NE(focusHub, nullptr);
1852 KeyEvent keyEvent;
1853 focusHub->SetLastWeakFocusToPreviousInFocusView();
1854 ASSERT_FALSE(focusHub->lastWeakFocusNode_.Upgrade());
1855 }
1856 } // namespace OHOS::Ace::NG
1857